@spatius/avatarkit 1.3.1-beta.7 → 1.3.1

package/dist/otel-trace-Ct4T48nC.js

@@ -0,0 +1,2565 @@
+import { $ as isSpanContextValid, A as defaultResource, B as otperformance, D as createResource, E as createInstrumentationScope, F as hrTime, G as getNumberFromEnv, H as ATTR_EXCEPTION_STACKTRACE, I as hrTimeDuration, J as isTracingSuppressed, K as getStringFromEnv, L as isTimeInput, M as BindOnceFuture, N as ExportResultCode, O as toAttributes, P as addHrTimes, Q as context, R as isTimeInputHrTime, T as JSON_ENCODER, U as ATTR_EXCEPTION_TYPE, V as ATTR_EXCEPTION_MESSAGE, W as ATTR_SERVICE_NAME, X as trace, Y as suppressTracing, Z as diag$1, a as clientContextFields, at as ROOT_CONTEXT, ct as getGlobal, et as isValidTraceId, ft as OTEL_PASSWORD, gt as OTEL_USERNAME, ht as OTEL_TRACES_STREAM_NAME, it as createNoopMeter, j as resourceFromAttributes, k as OTLPExporterBase, lt as registerGlobal, mt as OTEL_TRACES_ENDPOINT, nt as TraceFlags, ot as createContextKey, q as globalErrorHandler, rt as ContextAPI, st as DiagAPI, t as logger, tt as INVALID_SPAN_CONTEXT, ut as unregisterGlobal, vt as idManager, w as createLegacyOtlpBrowserExportDelegate, y as observeExporter, z as millisToHrTime } from "./logger-BOpQ7u0w.js";
+//#region node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/baggage/internal/baggage-impl.js
+var BaggageImpl = class BaggageImpl {
+	constructor(entries) {
+		this._entries = entries ? new Map(entries) : /* @__PURE__ */ new Map();
+	}
+	getEntry(key) {
+		const entry = this._entries.get(key);
+		if (!entry) return;
+		return Object.assign({}, entry);
+	}
+	getAllEntries() {
+		return Array.from(this._entries.entries());
+	}
+	setEntry(key, entry) {
+		const newBaggage = new BaggageImpl(this._entries);
+		newBaggage._entries.set(key, entry);
+		return newBaggage;
+	}
+	removeEntry(key) {
+		const newBaggage = new BaggageImpl(this._entries);
+		newBaggage._entries.delete(key);
+		return newBaggage;
+	}
+	removeEntries(...keys) {
+		const newBaggage = new BaggageImpl(this._entries);
+		for (const key of keys) newBaggage._entries.delete(key);
+		return newBaggage;
+	}
+	clear() {
+		return new BaggageImpl();
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/baggage/internal/symbol.js
+/**
+* Symbol used to make BaggageEntryMetadata an opaque type
+*/
+var baggageEntryMetadataSymbol = Symbol("BaggageEntryMetadata");
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/baggage/utils.js
+var diag = DiagAPI.instance();
+/**
+* Create a new Baggage with optional entries
+*
+* @param entries An array of baggage entries the new baggage should contain
+*/
+function createBaggage(entries = {}) {
+	return new BaggageImpl(new Map(Object.entries(entries)));
+}
+/**
+* Create a serializable BaggageEntryMetadata object from a string.
+*
+* @param str string metadata. Format is currently not defined by the spec and has no special meaning.
+*
+* @since 1.0.0
+*/
+function baggageEntryMetadataFromString(str) {
+	if (typeof str !== "string") {
+		diag.error(`Cannot create baggage metadata from unknown type: ${typeof str}`);
+		str = "";
+	}
+	return {
+		__TYPE__: baggageEntryMetadataSymbol,
+		toString() {
+			return str;
+		}
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/propagation/TextMapPropagator.js
+/**
+* @since 1.0.0
+*/
+var defaultTextMapGetter = {
+	get(carrier, key) {
+		if (carrier == null) return;
+		return carrier[key];
+	},
+	keys(carrier) {
+		if (carrier == null) return [];
+		return Object.keys(carrier);
+	}
+};
+/**
+* @since 1.0.0
+*/
+var defaultTextMapSetter = { set(carrier, key, value) {
+	if (carrier == null) return;
+	carrier[key] = value;
+} };
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/SamplingResult.js
+/**
+* @deprecated use the one declared in @opentelemetry/sdk-trace-base instead.
+* A sampling decision that determines how a {@link Span} will be recorded
+* and collected.
+*
+* @since 1.0.0
+*/
+var SamplingDecision$1;
+(function(SamplingDecision) {
+	/**
+	* `Span.isRecording() === false`, span will not be recorded and all events
+	* and attributes will be dropped.
+	*/
+	SamplingDecision[SamplingDecision["NOT_RECORD"] = 0] = "NOT_RECORD";
+	/**
+	* `Span.isRecording() === true`, but `Sampled` flag in {@link TraceFlags}
+	* MUST NOT be set.
+	*/
+	SamplingDecision[SamplingDecision["RECORD"] = 1] = "RECORD";
+	/**
+	* `Span.isRecording() === true` AND `Sampled` flag in {@link TraceFlags}
+	* MUST be set.
+	*/
+	SamplingDecision[SamplingDecision["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
+})(SamplingDecision$1 || (SamplingDecision$1 = {}));
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/span_kind.js
+/**
+* @since 1.0.0
+*/
+var SpanKind;
+(function(SpanKind) {
+	/** Default value. Indicates that the span is used internally. */
+	SpanKind[SpanKind["INTERNAL"] = 0] = "INTERNAL";
+	/**
+	* Indicates that the span covers server-side handling of an RPC or other
+	* remote request.
+	*/
+	SpanKind[SpanKind["SERVER"] = 1] = "SERVER";
+	/**
+	* Indicates that the span covers the client-side wrapper around an RPC or
+	* other remote request.
+	*/
+	SpanKind[SpanKind["CLIENT"] = 2] = "CLIENT";
+	/**
+	* Indicates that the span describes producer sending a message to a
+	* broker. Unlike client and server, there is no direct critical path latency
+	* relationship between producer and consumer spans.
+	*/
+	SpanKind[SpanKind["PRODUCER"] = 3] = "PRODUCER";
+	/**
+	* Indicates that the span describes consumer receiving a message from a
+	* broker. Unlike client and server, there is no direct critical path latency
+	* relationship between producer and consumer spans.
+	*/
+	SpanKind[SpanKind["CONSUMER"] = 4] = "CONSUMER";
+})(SpanKind || (SpanKind = {}));
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/status.js
+/**
+* An enumeration of status codes.
+*
+* @since 1.0.0
+*/
+var SpanStatusCode;
+(function(SpanStatusCode) {
+	/**
+	* The default status.
+	*/
+	SpanStatusCode[SpanStatusCode["UNSET"] = 0] = "UNSET";
+	/**
+	* The operation has been validated by an Application developer or
+	* Operator to have completed successfully.
+	*/
+	SpanStatusCode[SpanStatusCode["OK"] = 1] = "OK";
+	/**
+	* The operation contains an error.
+	*/
+	SpanStatusCode[SpanStatusCode["ERROR"] = 2] = "ERROR";
+})(SpanStatusCode || (SpanStatusCode = {}));
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/propagation/NoopTextMapPropagator.js
+/**
+* No-op implementations of {@link TextMapPropagator}.
+*/
+var NoopTextMapPropagator = class {
+	/** Noop inject function does nothing */
+	inject(_context, _carrier) {}
+	/** Noop extract function does nothing and returns the input context */
+	extract(context, _carrier) {
+		return context;
+	}
+	fields() {
+		return [];
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/baggage/context-helpers.js
+/**
+* Baggage key
+*/
+var BAGGAGE_KEY = createContextKey("OpenTelemetry Baggage Key");
+/**
+* Retrieve the current baggage from the given context
+*
+* @param {Context} Context that manage all context values
+* @returns {Baggage} Extracted baggage from the context
+*/
+function getBaggage(context) {
+	return context.getValue(BAGGAGE_KEY) || void 0;
+}
+/**
+* Retrieve the current baggage from the active/current context
+*
+* @returns {Baggage} Extracted baggage from the context
+*/
+function getActiveBaggage() {
+	return getBaggage(ContextAPI.getInstance().active());
+}
+/**
+* Store a baggage in the given context
+*
+* @param {Context} Context that manage all context values
+* @param {Baggage} baggage that will be set in the actual context
+*/
+function setBaggage(context, baggage) {
+	return context.setValue(BAGGAGE_KEY, baggage);
+}
+/**
+* Delete the baggage stored in the given context
+*
+* @param {Context} Context that manage all context values
+*/
+function deleteBaggage(context) {
+	return context.deleteValue(BAGGAGE_KEY);
+}
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/propagation.js
+var API_NAME = "propagation";
+var NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator();
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/propagation-api.js
+/**
+* Entrypoint for propagation API
+*
+* @since 1.0.0
+*/
+var propagation = class PropagationAPI {
+	/** Empty private constructor prevents end users from constructing a new instance of the API */
+	constructor() {
+		this.createBaggage = createBaggage;
+		this.getBaggage = getBaggage;
+		this.getActiveBaggage = getActiveBaggage;
+		this.setBaggage = setBaggage;
+		this.deleteBaggage = deleteBaggage;
+	}
+	/** Get the singleton instance of the Propagator API */
+	static getInstance() {
+		if (!this._instance) this._instance = new PropagationAPI();
+		return this._instance;
+	}
+	/**
+	* Set the current propagator.
+	*
+	* @returns true if the propagator was successfully registered, else false
+	*/
+	setGlobalPropagator(propagator) {
+		return registerGlobal(API_NAME, propagator, DiagAPI.instance());
+	}
+	/**
+	* Inject context into a carrier to be propagated inter-process
+	*
+	* @param context Context carrying tracing data to inject
+	* @param carrier carrier to inject context into
+	* @param setter Function used to set values on the carrier
+	*/
+	inject(context, carrier, setter = defaultTextMapSetter) {
+		return this._getGlobalPropagator().inject(context, carrier, setter);
+	}
+	/**
+	* Extract context from a carrier
+	*
+	* @param context Context which the newly created context will inherit from
+	* @param carrier Carrier to extract context from
+	* @param getter Function used to extract keys from a carrier
+	*/
+	extract(context, carrier, getter = defaultTextMapGetter) {
+		return this._getGlobalPropagator().extract(context, carrier, getter);
+	}
+	/**
+	* Return a list of all fields which may be used by the propagator.
+	*/
+	fields() {
+		return this._getGlobalPropagator().fields();
+	}
+	/** Remove the global propagator */
+	disable() {
+		unregisterGlobal(API_NAME, DiagAPI.instance());
+	}
+	_getGlobalPropagator() {
+		return getGlobal(API_NAME) || NOOP_TEXT_MAP_PROPAGATOR;
+	}
+}.getInstance();
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+core@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/baggage/constants.js
+var BAGGAGE_HEADER = "baggage";
+var BAGGAGE_MAX_PER_NAME_VALUE_PAIRS = 4096;
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+core@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/baggage/utils.js
+function serializeKeyPairs(keyPairs) {
+	return keyPairs.reduce((hValue, current) => {
+		const value = `${hValue}${hValue !== "" ? "," : ""}${current}`;
+		return value.length > 8192 ? hValue : value;
+	}, "");
+}
+function getKeyPairs(baggage) {
+	return baggage.getAllEntries().map(([key, value]) => {
+		let entry = `${encodeURIComponent(key)}=${encodeURIComponent(value.value)}`;
+		if (value.metadata !== void 0) entry += ";" + value.metadata.toString();
+		return entry;
+	});
+}
+function parsePairKeyValue(entry) {
+	if (!entry) return;
+	const metadataSeparatorIndex = entry.indexOf(";");
+	const keyPairPart = metadataSeparatorIndex === -1 ? entry : entry.substring(0, metadataSeparatorIndex);
+	const separatorIndex = keyPairPart.indexOf("=");
+	if (separatorIndex <= 0) return;
+	const rawKey = keyPairPart.substring(0, separatorIndex).trim();
+	const rawValue = keyPairPart.substring(separatorIndex + 1).trim();
+	if (!rawKey || !rawValue) return;
+	let key;
+	let value;
+	try {
+		key = decodeURIComponent(rawKey);
+		value = decodeURIComponent(rawValue);
+	} catch {
+		return;
+	}
+	let metadata;
+	if (metadataSeparatorIndex !== -1 && metadataSeparatorIndex < entry.length - 1) metadata = baggageEntryMetadataFromString(entry.substring(metadataSeparatorIndex + 1));
+	return {
+		key,
+		value,
+		metadata
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+core@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/baggage/propagation/W3CBaggagePropagator.js
+/**
+* Propagates {@link Baggage} through Context format propagation.
+*
+* Based on the Baggage specification:
+* https://w3c.github.io/baggage/
+*/
+var W3CBaggagePropagator = class {
+	inject(context, carrier, setter) {
+		const baggage = propagation.getBaggage(context);
+		if (!baggage || isTracingSuppressed(context)) return;
+		const headerValue = serializeKeyPairs(getKeyPairs(baggage).filter((pair) => {
+			return pair.length <= BAGGAGE_MAX_PER_NAME_VALUE_PAIRS;
+		}).slice(0, 180));
+		if (headerValue.length > 0) setter.set(carrier, BAGGAGE_HEADER, headerValue);
+	}
+	extract(context, carrier, getter) {
+		const headerValue = getter.get(carrier, BAGGAGE_HEADER);
+		const baggageString = Array.isArray(headerValue) ? headerValue.join(",") : headerValue;
+		if (!baggageString) return context;
+		const baggage = {};
+		if (baggageString.length === 0) return context;
+		baggageString.split(",").forEach((entry) => {
+			const keyPair = parsePairKeyValue(entry);
+			if (keyPair) {
+				const baggageEntry = { value: keyPair.value };
+				if (keyPair.metadata) baggageEntry.metadata = keyPair.metadata;
+				baggage[keyPair.key] = baggageEntry;
+			}
+		});
+		if (Object.entries(baggage).length === 0) return context;
+		return propagation.setBaggage(context, propagation.createBaggage(baggage));
+	}
+	fields() {
+		return [BAGGAGE_HEADER];
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+core@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/common/attributes.js
+function sanitizeAttributes(attributes) {
+	const out = {};
+	if (typeof attributes !== "object" || attributes == null) return out;
+	for (const key in attributes) {
+		if (!Object.prototype.hasOwnProperty.call(attributes, key)) continue;
+		if (!isAttributeKey(key)) {
+			diag$1.warn(`Invalid attribute key: ${key}`);
+			continue;
+		}
+		const val = attributes[key];
+		if (!isAttributeValue(val)) {
+			diag$1.warn(`Invalid attribute value set for key: ${key}`);
+			continue;
+		}
+		if (Array.isArray(val)) out[key] = val.slice();
+		else out[key] = val;
+	}
+	return out;
+}
+function isAttributeKey(key) {
+	return typeof key === "string" && key !== "";
+}
+function isAttributeValue(val) {
+	if (val == null) return true;
+	if (Array.isArray(val)) return isHomogeneousAttributeValueArray(val);
+	return isValidPrimitiveAttributeValueType(typeof val);
+}
+function isHomogeneousAttributeValueArray(arr) {
+	let type;
+	for (const element of arr) {
+		if (element == null) continue;
+		const elementType = typeof element;
+		if (elementType === type) continue;
+		if (!type) {
+			if (isValidPrimitiveAttributeValueType(elementType)) {
+				type = elementType;
+				continue;
+			}
+			return false;
+		}
+		return false;
+	}
+	return true;
+}
+function isValidPrimitiveAttributeValueType(valType) {
+	switch (valType) {
+		case "number":
+		case "boolean":
+		case "string": return true;
+	}
+	return false;
+}
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+core@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/propagation/composite.js
+/** Combines multiple propagators into a single propagator. */
+var CompositePropagator = class {
+	_propagators;
+	_fields;
+	/**
+	* Construct a composite propagator from a list of propagators.
+	*
+	* @param [config] Configuration object for composite propagator
+	*/
+	constructor(config = {}) {
+		this._propagators = config.propagators ?? [];
+		const fields = /* @__PURE__ */ new Set();
+		for (const propagator of this._propagators) {
+			const propagatorFields = typeof propagator.fields === "function" ? propagator.fields() : [];
+			for (const field of propagatorFields) fields.add(field);
+		}
+		this._fields = Array.from(fields);
+	}
+	/**
+	* Run each of the configured propagators with the given context and carrier.
+	* Propagators are run in the order they are configured, so if multiple
+	* propagators write the same carrier key, the propagator later in the list
+	* will "win".
+	*
+	* @param context Context to inject
+	* @param carrier Carrier into which context will be injected
+	*/
+	inject(context, carrier, setter) {
+		for (const propagator of this._propagators) try {
+			propagator.inject(context, carrier, setter);
+		} catch (err) {
+			diag$1.warn(`Failed to inject with ${propagator.constructor.name}. Err: ${err.message}`);
+		}
+	}
+	/**
+	* Run each of the configured propagators with the given context and carrier.
+	* Propagators are run in the order they are configured, so if multiple
+	* propagators write the same context key, the propagator later in the list
+	* will "win".
+	*
+	* @param context Context to add values to
+	* @param carrier Carrier from which to extract context
+	*/
+	extract(context, carrier, getter) {
+		return this._propagators.reduce((ctx, propagator) => {
+			try {
+				return propagator.extract(ctx, carrier, getter);
+			} catch (err) {
+				diag$1.warn(`Failed to extract with ${propagator.constructor.name}. Err: ${err.message}`);
+			}
+			return ctx;
+		}, context);
+	}
+	fields() {
+		return this._fields.slice();
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+core@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/internal/validators.js
+var VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]";
+var VALID_KEY_REGEX = new RegExp(`^(?:${`[a-z]${VALID_KEY_CHAR_RANGE}{0,255}`}|${`[a-z0-9]${VALID_KEY_CHAR_RANGE}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE}{0,13}`})$`);
+var VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
+var INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
+/**
+* Key is opaque string up to 256 characters printable. It MUST begin with a
+* lowercase letter, and can only contain lowercase letters a-z, digits 0-9,
+* underscores _, dashes -, asterisks *, and forward slashes /.
+* For multi-tenant vendor scenarios, an at sign (@) can be used to prefix the
+* vendor name. Vendors SHOULD set the tenant ID at the beginning of the key.
+* see https://www.w3.org/TR/trace-context/#key
+*/
+function validateKey(key) {
+	return VALID_KEY_REGEX.test(key);
+}
+/**
+* Value is opaque string up to 256 characters printable ASCII RFC0020
+* characters (i.e., the range 0x20 to 0x7E) except comma , and =.
+*/
+function validateValue(value) {
+	return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value);
+}
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+core@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/trace/TraceState.js
+var MAX_TRACE_STATE_ITEMS = 32;
+var MAX_TRACE_STATE_LEN = 512;
+var LIST_MEMBERS_SEPARATOR = ",";
+var LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
+/**
+* TraceState must be a class and not a simple object type because of the spec
+* requirement (https://www.w3.org/TR/trace-context/#tracestate-field).
+*
+* Here is the list of allowed mutations:
+* - New key-value pair should be added into the beginning of the list
+* - The value of any key can be updated. Modified keys MUST be moved to the
+* beginning of the list.
+*/
+var TraceState = class TraceState {
+	_length;
+	_rawTraceState;
+	_internalState;
+	constructor(rawTraceState) {
+		this._rawTraceState = typeof rawTraceState === "string" ? rawTraceState : "";
+		this._length = this._rawTraceState.length;
+	}
+	set(key, value) {
+		if (!validateKey(key) || !validateValue(value)) return this;
+		const currState = this._getState();
+		const currValue = currState.get(key);
+		let newLength = this._length;
+		if (typeof currValue === "string") newLength += value.length - currValue.length;
+		else newLength += key.length + value.length + (currState.size > 0 ? 2 : 1);
+		if (newLength > MAX_TRACE_STATE_LEN) return this;
+		const newState = new Map(currState);
+		newState.delete(key);
+		newState.set(key, value);
+		return this._fromState(newState, newLength);
+	}
+	unset(key) {
+		const currState = this._getState();
+		const currValue = currState.get(key);
+		if (typeof currValue !== "string") return this;
+		let newLength = this._length - (key.length + currValue.length + 1);
+		if (currState.size > 1) newLength = newLength - 1;
+		const newState = new Map(currState);
+		newState.delete(key);
+		return this._fromState(newState, newLength);
+	}
+	get(key) {
+		return this._getState().get(key);
+	}
+	serialize() {
+		let serialized = "";
+		let index = 0;
+		for (const entry of this._getState()) {
+			if (index > 0) serialized = LIST_MEMBERS_SEPARATOR + serialized;
+			serialized = `${entry[0]}${LIST_MEMBER_KEY_VALUE_SPLITTER}${entry[1]}` + serialized;
+			index++;
+		}
+		return serialized;
+	}
+	_getState() {
+		if (this._internalState) return this._internalState;
+		const vendorMembers = this._rawTraceState.split(LIST_MEMBERS_SEPARATOR);
+		const vendorEntries = /* @__PURE__ */ new Map();
+		let currentLength = 0;
+		for (const member of vendorMembers) {
+			const m = member.trim();
+			const idx = m.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
+			if (idx === -1) continue;
+			const key = m.slice(0, idx);
+			const value = m.slice(idx + 1);
+			if (!validateKey(key) || !validateValue(value)) continue;
+			const futureLength = currentLength + m.length + (vendorEntries.size > 0 ? 1 : 0);
+			if (futureLength > MAX_TRACE_STATE_LEN) continue;
+			vendorEntries.set(key, value);
+			currentLength = futureLength;
+			if (vendorEntries.size >= MAX_TRACE_STATE_ITEMS) break;
+		}
+		this._length = currentLength;
+		this._internalState = new Map(Array.from(vendorEntries.entries()).reverse());
+		return this._internalState;
+	}
+	_fromState(state, length) {
+		const traceState = Object.create(TraceState.prototype);
+		traceState._internalState = state;
+		traceState._length = length;
+		return traceState;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+core@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/trace/W3CTraceContextPropagator.js
+var TRACE_PARENT_HEADER = "traceparent";
+var TRACE_STATE_HEADER = "tracestate";
+var VERSION$1 = "00";
+var TRACE_PARENT_REGEX = new RegExp(`^\\s?((?!ff)[\\da-f]{2})-((?![0]{32})[\\da-f]{32})-((?![0]{16})[\\da-f]{16})-([\\da-f]{2})(-.*)?\\s?$`);
+/**
+* Parses information from the [traceparent] span tag and converts it into {@link SpanContext}
+* @param traceParent - A meta property that comes from server.
+*     It should be dynamically generated server side to have the server's request trace Id,
+*     a parent span Id that was set on the server's request span,
+*     and the trace flags to indicate the server's sampling decision
+*     (01 = sampled, 00 = not sampled).
+*     for example: '{version}-{traceId}-{spanId}-{sampleDecision}'
+*     For more information see {@link https://www.w3.org/TR/trace-context/}
+*/
+function parseTraceParent(traceParent) {
+	const match = TRACE_PARENT_REGEX.exec(traceParent);
+	if (!match) return null;
+	if (match[1] === "00" && match[5]) return null;
+	return {
+		traceId: match[2],
+		spanId: match[3],
+		traceFlags: parseInt(match[4], 16)
+	};
+}
+/**
+* Propagates {@link SpanContext} through Trace Context format propagation.
+*
+* Based on the Trace Context specification:
+* https://www.w3.org/TR/trace-context/
+*/
+var W3CTraceContextPropagator = class {
+	inject(context, carrier, setter) {
+		const spanContext = trace.getSpanContext(context);
+		if (!spanContext || isTracingSuppressed(context) || !isSpanContextValid(spanContext)) return;
+		const traceParent = `${VERSION$1}-${spanContext.traceId}-${spanContext.spanId}-0${Number(spanContext.traceFlags || TraceFlags.NONE).toString(16)}`;
+		setter.set(carrier, TRACE_PARENT_HEADER, traceParent);
+		if (spanContext.traceState) setter.set(carrier, TRACE_STATE_HEADER, spanContext.traceState.serialize());
+	}
+	extract(context, carrier, getter) {
+		const traceParentHeader = getter.get(carrier, TRACE_PARENT_HEADER);
+		if (!traceParentHeader) return context;
+		const traceParent = Array.isArray(traceParentHeader) ? traceParentHeader[0] : traceParentHeader;
+		if (typeof traceParent !== "string") return context;
+		const spanContext = parseTraceParent(traceParent);
+		if (!spanContext) return context;
+		spanContext.isRemote = true;
+		const traceStateHeader = getter.get(carrier, TRACE_STATE_HEADER);
+		if (traceStateHeader) {
+			const state = Array.isArray(traceStateHeader) ? traceStateHeader.join(",") : traceStateHeader;
+			spanContext.traceState = new TraceState(typeof state === "string" ? state : void 0);
+		}
+		return trace.setSpanContext(context, spanContext);
+	}
+	fields() {
+		return [TRACE_PARENT_HEADER, TRACE_STATE_HEADER];
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+core@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/utils/lodash.merge.js
+/**
+* based on lodash in order to support esm builds without esModuleInterop.
+* lodash is using MIT License.
+**/
+var objectTag = "[object Object]";
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var funcToString = Function.prototype.toString;
+var objectCtorString = funcToString.call(Object);
+var getPrototypeOf = Object.getPrototypeOf;
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+var nativeObjectToString = objectProto.toString;
+/**
+* Checks if `value` is a plain object, that is, an object created by the
+* `Object` constructor or one with a `[[Prototype]]` of `null`.
+*
+* @static
+* @memberOf _
+* @since 0.8.0
+* @category Lang
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+* @example
+*
+* function Foo() {
+*   this.a = 1;
+* }
+*
+* _.isPlainObject(new Foo);
+* // => false
+*
+* _.isPlainObject([1, 2, 3]);
+* // => false
+*
+* _.isPlainObject({ 'x': 0, 'y': 0 });
+* // => true
+*
+* _.isPlainObject(Object.create(null));
+* // => true
+*/
+function isPlainObject(value) {
+	if (!isObjectLike(value) || baseGetTag(value) !== objectTag) return false;
+	const proto = getPrototypeOf(value);
+	if (proto === null) return true;
+	const Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
+	return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) === objectCtorString;
+}
+/**
+* Checks if `value` is object-like. A value is object-like if it's not `null`
+* and has a `typeof` result of "object".
+*
+* @static
+* @memberOf _
+* @since 4.0.0
+* @category Lang
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+* @example
+*
+* _.isObjectLike({});
+* // => true
+*
+* _.isObjectLike([1, 2, 3]);
+* // => true
+*
+* _.isObjectLike(_.noop);
+* // => false
+*
+* _.isObjectLike(null);
+* // => false
+*/
+function isObjectLike(value) {
+	return value != null && typeof value == "object";
+}
+/**
+* The base implementation of `getTag` without fallbacks for buggy environments.
+*
+* @private
+* @param {*} value The value to query.
+* @returns {string} Returns the `toStringTag`.
+*/
+function baseGetTag(value) {
+	if (value == null) return value === void 0 ? undefinedTag : nullTag;
+	return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+/**
+* A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+*
+* @private
+* @param {*} value The value to query.
+* @returns {string} Returns the raw `toStringTag`.
+*/
+function getRawTag(value) {
+	const isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+	let unmasked = false;
+	try {
+		value[symToStringTag] = void 0;
+		unmasked = true;
+	} catch {}
+	const result = nativeObjectToString.call(value);
+	if (unmasked) if (isOwn) value[symToStringTag] = tag;
+	else delete value[symToStringTag];
+	return result;
+}
+/**
+* Converts `value` to a string using `Object.prototype.toString`.
+*
+* @private
+* @param {*} value The value to convert.
+* @returns {string} Returns the converted string.
+*/
+function objectToString(value) {
+	return nativeObjectToString.call(value);
+}
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+core@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/utils/merge.js
+var MAX_LEVEL = 20;
+/**
+* Merges objects together
+* @param args - objects / values to be merged
+*/
+function merge(...args) {
+	let result = args.shift();
+	const objects = /* @__PURE__ */ new WeakMap();
+	while (args.length > 0) result = mergeTwoObjects(result, args.shift(), 0, objects);
+	return result;
+}
+function takeValue(value) {
+	if (isArray(value)) return value.slice();
+	return value;
+}
+/**
+* Merges two objects
+* @param one - first object
+* @param two - second object
+* @param level - current deep level
+* @param objects - objects holder that has been already referenced - to prevent
+* cyclic dependency
+*/
+function mergeTwoObjects(one, two, level = 0, objects) {
+	let result;
+	if (level > MAX_LEVEL) return;
+	level++;
+	if (isPrimitive(one) || isPrimitive(two) || isFunction(two)) result = takeValue(two);
+	else if (isArray(one)) {
+		result = one.slice();
+		if (isArray(two)) for (let i = 0, j = two.length; i < j; i++) result.push(takeValue(two[i]));
+		else if (isObject(two)) {
+			const keys = Object.keys(two);
+			for (let i = 0, j = keys.length; i < j; i++) {
+				const key = keys[i];
+				if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+				result[key] = takeValue(two[key]);
+			}
+		}
+	} else if (isObject(one)) if (isObject(two)) {
+		if (!shouldMerge(one, two)) return two;
+		result = Object.assign({}, one);
+		const keys = Object.keys(two);
+		for (let i = 0, j = keys.length; i < j; i++) {
+			const key = keys[i];
+			if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+			const twoValue = two[key];
+			if (isPrimitive(twoValue)) if (typeof twoValue === "undefined") delete result[key];
+			else result[key] = twoValue;
+			else {
+				const obj1 = result[key];
+				const obj2 = twoValue;
+				if (wasObjectReferenced(one, key, objects) || wasObjectReferenced(two, key, objects)) delete result[key];
+				else {
+					if (isObject(obj1) && isObject(obj2)) {
+						const arr1 = objects.get(obj1) || [];
+						const arr2 = objects.get(obj2) || [];
+						arr1.push({
+							obj: one,
+							key
+						});
+						arr2.push({
+							obj: two,
+							key
+						});
+						objects.set(obj1, arr1);
+						objects.set(obj2, arr2);
+					}
+					result[key] = mergeTwoObjects(result[key], twoValue, level, objects);
+				}
+			}
+		}
+	} else result = two;
+	return result;
+}
+/**
+* Function to check if object has been already reference
+* @param obj
+* @param key
+* @param objects
+*/
+function wasObjectReferenced(obj, key, objects) {
+	const arr = objects.get(obj[key]) || [];
+	for (let i = 0, j = arr.length; i < j; i++) {
+		const info = arr[i];
+		if (info.key === key && info.obj === obj) return true;
+	}
+	return false;
+}
+function isArray(value) {
+	return Array.isArray(value);
+}
+function isFunction(value) {
+	return typeof value === "function";
+}
+function isObject(value) {
+	return !isPrimitive(value) && !isArray(value) && !isFunction(value) && typeof value === "object";
+}
+function isPrimitive(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "undefined" || value instanceof Date || value instanceof RegExp || value === null;
+}
+function shouldMerge(one, two) {
+	if (!isPlainObject(one) || !isPlainObject(two)) return false;
+	return true;
+}
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+otlp-transformer@0.218.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-transformer/build/esm/trace/internal.js
+var SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK = 256;
+var SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK = 512;
+/**
+* Builds the 32-bit span flags value combining the low 8-bit W3C TraceFlags
+* with the HAS_IS_REMOTE and IS_REMOTE bits according to the OTLP spec.
+*/
+function buildSpanFlagsFrom(traceFlags, isRemote) {
+	let flags = traceFlags & 255 | SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK;
+	if (isRemote) flags |= SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK;
+	return flags;
+}
+function sdkSpanToOtlpSpan(span, encoder) {
+	const ctx = span.spanContext();
+	const status = span.status;
+	const parentSpanId = span.parentSpanContext?.spanId ? encoder.encodeSpanContext(span.parentSpanContext?.spanId) : void 0;
+	return {
+		traceId: encoder.encodeSpanContext(ctx.traceId),
+		spanId: encoder.encodeSpanContext(ctx.spanId),
+		parentSpanId,
+		traceState: ctx.traceState?.serialize(),
+		name: span.name,
+		kind: span.kind == null ? 0 : span.kind + 1,
+		startTimeUnixNano: encoder.encodeHrTime(span.startTime),
+		endTimeUnixNano: encoder.encodeHrTime(span.endTime),
+		attributes: toAttributes(span.attributes, encoder),
+		droppedAttributesCount: span.droppedAttributesCount,
+		events: span.events.map((event) => toOtlpSpanEvent(event, encoder)),
+		droppedEventsCount: span.droppedEventsCount,
+		status: {
+			code: status.code,
+			message: status.message
+		},
+		links: span.links.map((link) => toOtlpLink(link, encoder)),
+		droppedLinksCount: span.droppedLinksCount,
+		flags: buildSpanFlagsFrom(ctx.traceFlags, span.parentSpanContext?.isRemote)
+	};
+}
+function toOtlpLink(link, encoder) {
+	return {
+		attributes: link.attributes ? toAttributes(link.attributes, encoder) : [],
+		spanId: encoder.encodeSpanContext(link.context.spanId),
+		traceId: encoder.encodeSpanContext(link.context.traceId),
+		traceState: link.context.traceState?.serialize(),
+		droppedAttributesCount: link.droppedAttributesCount || 0,
+		flags: buildSpanFlagsFrom(link.context.traceFlags, link.context.isRemote)
+	};
+}
+function toOtlpSpanEvent(timedEvent, encoder) {
+	return {
+		attributes: timedEvent.attributes ? toAttributes(timedEvent.attributes, encoder) : [],
+		name: timedEvent.name,
+		timeUnixNano: encoder.encodeHrTime(timedEvent.time),
+		droppedAttributesCount: timedEvent.droppedAttributesCount || 0
+	};
+}
+function createExportTraceServiceRequest(spans, encoder) {
+	return { resourceSpans: spanRecordsToResourceSpans(spans, encoder) };
+}
+function createResourceMap(readableSpans) {
+	const resourceMap = /* @__PURE__ */ new Map();
+	for (const record of readableSpans) {
+		let ilsMap = resourceMap.get(record.resource);
+		if (!ilsMap) {
+			ilsMap = /* @__PURE__ */ new Map();
+			resourceMap.set(record.resource, ilsMap);
+		}
+		const instrumentationScopeKey = `${record.instrumentationScope.name}@${record.instrumentationScope.version || ""}:${record.instrumentationScope.schemaUrl || ""}`;
+		let records = ilsMap.get(instrumentationScopeKey);
+		if (!records) {
+			records = [];
+			ilsMap.set(instrumentationScopeKey, records);
+		}
+		records.push(record);
+	}
+	return resourceMap;
+}
+function spanRecordsToResourceSpans(readableSpans, encoder) {
+	const resourceMap = createResourceMap(readableSpans);
+	const out = [];
+	const entryIterator = resourceMap.entries();
+	let entry = entryIterator.next();
+	while (!entry.done) {
+		const [resource, ilmMap] = entry.value;
+		const scopeResourceSpans = [];
+		const ilmIterator = ilmMap.values();
+		let ilmEntry = ilmIterator.next();
+		while (!ilmEntry.done) {
+			const scopeSpans = ilmEntry.value;
+			if (scopeSpans.length > 0) {
+				const spans = scopeSpans.map((readableSpan) => sdkSpanToOtlpSpan(readableSpan, encoder));
+				scopeResourceSpans.push({
+					scope: createInstrumentationScope(scopeSpans[0].instrumentationScope),
+					spans,
+					schemaUrl: scopeSpans[0].instrumentationScope.schemaUrl
+				});
+			}
+			ilmEntry = ilmIterator.next();
+		}
+		const processedResource = createResource(resource, encoder);
+		out.push({
+			resource: processedResource,
+			scopeSpans: scopeResourceSpans,
+			schemaUrl: processedResource.schemaUrl
+		});
+		entry = entryIterator.next();
+	}
+	return out;
+}
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+otlp-transformer@0.218.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-transformer/build/esm/trace/json/trace.js
+var JsonTraceSerializer = {
+	serializeRequest: (arg) => {
+		const request = createExportTraceServiceRequest(arg, JSON_ENCODER);
+		return new TextEncoder().encode(JSON.stringify(request));
+	},
+	deserializeResponse: (arg) => {
+		if (arg.length === 0) return {};
+		const decoder = new TextDecoder();
+		try {
+			return JSON.parse(decoder.decode(arg));
+		} catch (err) {
+			diag$1.warn(`Failed to parse trace export response: ${err.message}. Returning empty response`);
+			return {};
+		}
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/esm/enums.js
+var ExceptionEventName = "exception";
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/esm/Span.js
+/**
+* This class represents a span.
+*/
+var SpanImpl = class {
+	_spanContext;
+	kind;
+	parentSpanContext;
+	attributes = {};
+	links = [];
+	events = [];
+	startTime;
+	resource;
+	instrumentationScope;
+	_droppedAttributesCount = 0;
+	_droppedEventsCount = 0;
+	_droppedLinksCount = 0;
+	_attributesCount = 0;
+	name;
+	status = { code: SpanStatusCode.UNSET };
+	endTime = [0, 0];
+	_ended = false;
+	_duration = [-1, -1];
+	_spanProcessor;
+	_spanLimits;
+	_attributeValueLengthLimit;
+	_recordEndMetrics;
+	_performanceStartTime;
+	_performanceOffset;
+	_startTimeProvided;
+	/**
+	* Constructs a new SpanImpl instance.
+	*/
+	constructor(opts) {
+		const now = Date.now();
+		this._spanContext = opts.spanContext;
+		this._performanceStartTime = otperformance.now();
+		this._performanceOffset = now - (this._performanceStartTime + otperformance.timeOrigin);
+		this._startTimeProvided = opts.startTime != null;
+		this._spanLimits = opts.spanLimits;
+		this._attributeValueLengthLimit = this._spanLimits.attributeValueLengthLimit ?? 0;
+		this._spanProcessor = opts.spanProcessor;
+		this.name = opts.name;
+		this.parentSpanContext = opts.parentSpanContext;
+		this.kind = opts.kind;
+		if (opts.links) for (const link of opts.links) this.addLink(link);
+		this.startTime = this._getTime(opts.startTime ?? now);
+		this.resource = opts.resource;
+		this.instrumentationScope = opts.scope;
+		this._recordEndMetrics = opts.recordEndMetrics;
+		if (opts.attributes != null) this.setAttributes(opts.attributes);
+		this._spanProcessor.onStart(this, opts.context);
+	}
+	spanContext() {
+		return this._spanContext;
+	}
+	setAttribute(key, value) {
+		if (value == null || this._isSpanEnded()) return this;
+		if (key.length === 0) {
+			diag$1.warn(`Invalid attribute key: ${key}`);
+			return this;
+		}
+		if (!isAttributeValue(value)) {
+			diag$1.warn(`Invalid attribute value set for key: ${key}`);
+			return this;
+		}
+		const { attributeCountLimit } = this._spanLimits;
+		const isNewKey = !Object.prototype.hasOwnProperty.call(this.attributes, key);
+		if (attributeCountLimit !== void 0 && this._attributesCount >= attributeCountLimit && isNewKey) {
+			this._droppedAttributesCount++;
+			return this;
+		}
+		this.attributes[key] = this._truncateToSize(value);
+		if (isNewKey) this._attributesCount++;
+		return this;
+	}
+	setAttributes(attributes) {
+		for (const key in attributes) if (Object.prototype.hasOwnProperty.call(attributes, key)) this.setAttribute(key, attributes[key]);
+		return this;
+	}
+	/**
+	*
+	* @param name Span Name
+	* @param [attributesOrStartTime] Span attributes or start time
+	*     if type is {@type TimeInput} and 3rd param is undefined
+	* @param [timeStamp] Specified time stamp for the event
+	*/
+	addEvent(name, attributesOrStartTime, timeStamp) {
+		if (this._isSpanEnded()) return this;
+		const { eventCountLimit } = this._spanLimits;
+		if (eventCountLimit === 0) {
+			diag$1.warn("No events allowed.");
+			this._droppedEventsCount++;
+			return this;
+		}
+		if (eventCountLimit !== void 0 && this.events.length >= eventCountLimit) {
+			if (this._droppedEventsCount === 0) diag$1.debug("Dropping extra events.");
+			this.events.shift();
+			this._droppedEventsCount++;
+		}
+		if (isTimeInput(attributesOrStartTime)) {
+			if (!isTimeInput(timeStamp)) timeStamp = attributesOrStartTime;
+			attributesOrStartTime = void 0;
+		}
+		const sanitized = sanitizeAttributes(attributesOrStartTime);
+		const { attributePerEventCountLimit } = this._spanLimits;
+		const attributes = {};
+		let droppedAttributesCount = 0;
+		let eventAttributesCount = 0;
+		for (const attr in sanitized) {
+			if (!Object.prototype.hasOwnProperty.call(sanitized, attr)) continue;
+			const attrVal = sanitized[attr];
+			if (attributePerEventCountLimit !== void 0 && eventAttributesCount >= attributePerEventCountLimit) {
+				droppedAttributesCount++;
+				continue;
+			}
+			attributes[attr] = this._truncateToSize(attrVal);
+			eventAttributesCount++;
+		}
+		this.events.push({
+			name,
+			attributes,
+			time: this._getTime(timeStamp),
+			droppedAttributesCount
+		});
+		return this;
+	}
+	addLink(link) {
+		if (this._isSpanEnded()) return this;
+		const { linkCountLimit } = this._spanLimits;
+		if (linkCountLimit === 0) {
+			this._droppedLinksCount++;
+			return this;
+		}
+		if (linkCountLimit !== void 0 && this.links.length >= linkCountLimit) {
+			if (this._droppedLinksCount === 0) diag$1.debug("Dropping extra links.");
+			this.links.shift();
+			this._droppedLinksCount++;
+		}
+		const { attributePerLinkCountLimit } = this._spanLimits;
+		const sanitized = sanitizeAttributes(link.attributes);
+		const attributes = {};
+		let droppedAttributesCount = 0;
+		let linkAttributesCount = 0;
+		for (const attr in sanitized) {
+			if (!Object.prototype.hasOwnProperty.call(sanitized, attr)) continue;
+			const attrVal = sanitized[attr];
+			if (attributePerLinkCountLimit !== void 0 && linkAttributesCount >= attributePerLinkCountLimit) {
+				droppedAttributesCount++;
+				continue;
+			}
+			attributes[attr] = this._truncateToSize(attrVal);
+			linkAttributesCount++;
+		}
+		const processedLink = { context: link.context };
+		if (linkAttributesCount > 0) processedLink.attributes = attributes;
+		if (droppedAttributesCount > 0) processedLink.droppedAttributesCount = droppedAttributesCount;
+		this.links.push(processedLink);
+		return this;
+	}
+	addLinks(links) {
+		for (const link of links) this.addLink(link);
+		return this;
+	}
+	setStatus(status) {
+		if (this._isSpanEnded()) return this;
+		if (status.code === SpanStatusCode.UNSET) return this;
+		if (this.status.code === SpanStatusCode.OK) return this;
+		const newStatus = { code: status.code };
+		if (status.code === SpanStatusCode.ERROR) {
+			if (typeof status.message === "string") newStatus.message = status.message;
+			else if (status.message != null) diag$1.warn(`Dropping invalid status.message of type '${typeof status.message}', expected 'string'`);
+		}
+		this.status = newStatus;
+		return this;
+	}
+	updateName(name) {
+		if (this._isSpanEnded()) return this;
+		this.name = name;
+		return this;
+	}
+	end(endTime) {
+		if (this._isSpanEnded()) {
+			diag$1.error(`${this.name} ${this._spanContext.traceId}-${this._spanContext.spanId} - You can only call end() on a span once.`);
+			return;
+		}
+		this.endTime = this._getTime(endTime);
+		this._duration = hrTimeDuration(this.startTime, this.endTime);
+		if (this._duration[0] < 0) {
+			diag$1.warn("Inconsistent start and end time, startTime > endTime. Setting span duration to 0ms.", this.startTime, this.endTime);
+			this.endTime = this.startTime.slice();
+			this._duration = [0, 0];
+		}
+		if (this._droppedEventsCount > 0) diag$1.warn(`Dropped ${this._droppedEventsCount} events because eventCountLimit reached`);
+		if (this._droppedLinksCount > 0) diag$1.warn(`Dropped ${this._droppedLinksCount} links because linkCountLimit reached`);
+		if (this._spanProcessor.onEnding) this._spanProcessor.onEnding(this);
+		this._recordEndMetrics?.();
+		this._ended = true;
+		this._spanProcessor.onEnd(this);
+	}
+	_getTime(inp) {
+		if (typeof inp === "number" && inp <= otperformance.now()) return hrTime(inp + this._performanceOffset);
+		if (typeof inp === "number") return millisToHrTime(inp);
+		if (inp instanceof Date) return millisToHrTime(inp.getTime());
+		if (isTimeInputHrTime(inp)) return inp;
+		if (this._startTimeProvided) return millisToHrTime(Date.now());
+		const msDuration = otperformance.now() - this._performanceStartTime;
+		return addHrTimes(this.startTime, millisToHrTime(msDuration));
+	}
+	isRecording() {
+		return this._ended === false;
+	}
+	recordException(exception, time) {
+		const attributes = {};
+		if (typeof exception === "string") attributes[ATTR_EXCEPTION_MESSAGE] = exception;
+		else if (exception) {
+			if (exception.code) attributes[ATTR_EXCEPTION_TYPE] = exception.code.toString();
+			else if (exception.name) attributes[ATTR_EXCEPTION_TYPE] = exception.name;
+			if (exception.message) attributes[ATTR_EXCEPTION_MESSAGE] = exception.message;
+			if (exception.stack) attributes[ATTR_EXCEPTION_STACKTRACE] = exception.stack;
+		}
+		if (attributes["exception.type"] || attributes["exception.message"]) this.addEvent(ExceptionEventName, attributes, time);
+		else diag$1.warn(`Failed to record an exception ${exception}`);
+	}
+	get duration() {
+		return this._duration;
+	}
+	get ended() {
+		return this._ended;
+	}
+	get droppedAttributesCount() {
+		return this._droppedAttributesCount;
+	}
+	get droppedEventsCount() {
+		return this._droppedEventsCount;
+	}
+	get droppedLinksCount() {
+		return this._droppedLinksCount;
+	}
+	_isSpanEnded() {
+		if (this._ended) {
+			const error = /* @__PURE__ */ new Error(`Operation attempted on ended Span {traceId: ${this._spanContext.traceId}, spanId: ${this._spanContext.spanId}}`);
+			diag$1.warn(`Cannot execute the operation on ended Span {traceId: ${this._spanContext.traceId}, spanId: ${this._spanContext.spanId}}`, error);
+		}
+		return this._ended;
+	}
+	_truncateToLimitUtil(value, limit) {
+		if (value.length <= limit) return value;
+		return value.substring(0, limit);
+	}
+	/**
+	* If the given attribute value is of type string and has more characters than given {@code attributeValueLengthLimit} then
+	* return string with truncated to {@code attributeValueLengthLimit} characters
+	*
+	* If the given attribute value is array of strings then
+	* return new array of strings with each element truncated to {@code attributeValueLengthLimit} characters
+	*
+	* Otherwise return same Attribute {@code value}
+	*
+	* @param value Attribute value
+	* @returns truncated attribute value if required, otherwise same value
+	*/
+	_truncateToSize(value) {
+		const limit = this._attributeValueLengthLimit;
+		if (limit <= 0) {
+			diag$1.warn(`Attribute value limit must be positive, got ${limit}`);
+			return value;
+		}
+		if (typeof value === "string") return this._truncateToLimitUtil(value, limit);
+		if (Array.isArray(value)) return value.map((val) => typeof val === "string" ? this._truncateToLimitUtil(val, limit) : val);
+		return value;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/esm/Sampler.js
+/**
+* A sampling decision that determines how a {@link Span} will be recorded
+* and collected.
+*/
+var SamplingDecision;
+(function(SamplingDecision) {
+	/**
+	* `Span.isRecording() === false`, span will not be recorded and all events
+	* and attributes will be dropped.
+	*/
+	SamplingDecision[SamplingDecision["NOT_RECORD"] = 0] = "NOT_RECORD";
+	/**
+	* `Span.isRecording() === true`, but `Sampled` flag in {@link TraceFlags}
+	* MUST NOT be set.
+	*/
+	SamplingDecision[SamplingDecision["RECORD"] = 1] = "RECORD";
+	/**
+	* `Span.isRecording() === true` AND `Sampled` flag in {@link TraceFlags}
+	* MUST be set.
+	*/
+	SamplingDecision[SamplingDecision["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
+})(SamplingDecision || (SamplingDecision = {}));
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/AlwaysOffSampler.js
+/** Sampler that samples no traces. */
+var AlwaysOffSampler = class {
+	shouldSample() {
+		return { decision: SamplingDecision.NOT_RECORD };
+	}
+	toString() {
+		return "AlwaysOffSampler";
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/AlwaysOnSampler.js
+/** Sampler that samples all traces. */
+var AlwaysOnSampler = class {
+	shouldSample() {
+		return { decision: SamplingDecision.RECORD_AND_SAMPLED };
+	}
+	toString() {
+		return "AlwaysOnSampler";
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/ParentBasedSampler.js
+/**
+* A composite sampler that either respects the parent span's sampling decision
+* or delegates to `delegateSampler` for root spans.
+*/
+var ParentBasedSampler = class {
+	_root;
+	_remoteParentSampled;
+	_remoteParentNotSampled;
+	_localParentSampled;
+	_localParentNotSampled;
+	constructor(config) {
+		this._root = config.root;
+		if (!this._root) {
+			globalErrorHandler(/* @__PURE__ */ new Error("ParentBasedSampler must have a root sampler configured"));
+			this._root = new AlwaysOnSampler();
+		}
+		this._remoteParentSampled = config.remoteParentSampled ?? new AlwaysOnSampler();
+		this._remoteParentNotSampled = config.remoteParentNotSampled ?? new AlwaysOffSampler();
+		this._localParentSampled = config.localParentSampled ?? new AlwaysOnSampler();
+		this._localParentNotSampled = config.localParentNotSampled ?? new AlwaysOffSampler();
+	}
+	shouldSample(context, traceId, spanName, spanKind, attributes, links) {
+		const parentContext = trace.getSpanContext(context);
+		if (!parentContext || !isSpanContextValid(parentContext)) return this._root.shouldSample(context, traceId, spanName, spanKind, attributes, links);
+		if (parentContext.isRemote) {
+			if (parentContext.traceFlags & TraceFlags.SAMPLED) return this._remoteParentSampled.shouldSample(context, traceId, spanName, spanKind, attributes, links);
+			return this._remoteParentNotSampled.shouldSample(context, traceId, spanName, spanKind, attributes, links);
+		}
+		if (parentContext.traceFlags & TraceFlags.SAMPLED) return this._localParentSampled.shouldSample(context, traceId, spanName, spanKind, attributes, links);
+		return this._localParentNotSampled.shouldSample(context, traceId, spanName, spanKind, attributes, links);
+	}
+	toString() {
+		return `ParentBased{root=${this._root.toString()}, remoteParentSampled=${this._remoteParentSampled.toString()}, remoteParentNotSampled=${this._remoteParentNotSampled.toString()}, localParentSampled=${this._localParentSampled.toString()}, localParentNotSampled=${this._localParentNotSampled.toString()}}`;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/TraceIdRatioBasedSampler.js
+/** Sampler that samples a given fraction of traces based of trace id deterministically. */
+var TraceIdRatioBasedSampler = class {
+	_ratio;
+	_upperBound;
+	constructor(ratio = 0) {
+		this._ratio = this._normalize(ratio);
+		this._upperBound = Math.floor(this._ratio * 4294967295);
+	}
+	shouldSample(context, traceId) {
+		return { decision: isValidTraceId(traceId) && this._accumulate(traceId) < this._upperBound ? SamplingDecision.RECORD_AND_SAMPLED : SamplingDecision.NOT_RECORD };
+	}
+	toString() {
+		return `TraceIdRatioBased{${this._ratio}}`;
+	}
+	_normalize(ratio) {
+		if (typeof ratio !== "number" || isNaN(ratio)) return 0;
+		return ratio >= 1 ? 1 : ratio <= 0 ? 0 : ratio;
+	}
+	_accumulate(traceId) {
+		let accumulation = 0;
+		for (let i = 0; i < 32; i += 8) {
+			let part = 0;
+			for (let j = 0; j < 8; j++) {
+				const c = traceId.charCodeAt(i + j);
+				const v = c < 58 ? c - 48 : c < 71 ? c - 55 : c - 87;
+				part = part << 4 | v;
+			}
+			accumulation = (accumulation ^ part) >>> 0;
+		}
+		return accumulation;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/esm/config.js
+var TracesSamplerValues;
+(function(TracesSamplerValues) {
+	TracesSamplerValues["AlwaysOff"] = "always_off";
+	TracesSamplerValues["AlwaysOn"] = "always_on";
+	TracesSamplerValues["ParentBasedAlwaysOff"] = "parentbased_always_off";
+	TracesSamplerValues["ParentBasedAlwaysOn"] = "parentbased_always_on";
+	TracesSamplerValues["ParentBasedTraceIdRatio"] = "parentbased_traceidratio";
+	TracesSamplerValues["TraceIdRatio"] = "traceidratio";
+})(TracesSamplerValues || (TracesSamplerValues = {}));
+var DEFAULT_RATIO = 1;
+/**
+* Load default configuration. For fields with primitive values, any user-provided
+* value will override the corresponding default value. For fields with
+* non-primitive values (like `spanLimits`), the user-provided value will be
+* used to extend the default value.
+*/
+function loadDefaultConfig() {
+	return {
+		sampler: buildSamplerFromEnv(),
+		forceFlushTimeoutMillis: 3e4,
+		generalLimits: {
+			attributeValueLengthLimit: /* @__PURE__ */ getNumberFromEnv("OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT") ?? Infinity,
+			attributeCountLimit: /* @__PURE__ */ getNumberFromEnv("OTEL_ATTRIBUTE_COUNT_LIMIT") ?? 128
+		},
+		spanLimits: {
+			attributeValueLengthLimit: /* @__PURE__ */ getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT") ?? Infinity,
+			attributeCountLimit: /* @__PURE__ */ getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT") ?? 128,
+			linkCountLimit: /* @__PURE__ */ getNumberFromEnv("OTEL_SPAN_LINK_COUNT_LIMIT") ?? 128,
+			eventCountLimit: /* @__PURE__ */ getNumberFromEnv("OTEL_SPAN_EVENT_COUNT_LIMIT") ?? 128,
+			attributePerEventCountLimit: /* @__PURE__ */ getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_PER_EVENT_COUNT_LIMIT") ?? 128,
+			attributePerLinkCountLimit: /* @__PURE__ */ getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_PER_LINK_COUNT_LIMIT") ?? 128
+		}
+	};
+}
+/**
+* Based on environment, builds a sampler, complies with specification.
+*/
+function buildSamplerFromEnv() {
+	const sampler = /* @__PURE__ */ getStringFromEnv("OTEL_TRACES_SAMPLER") ?? TracesSamplerValues.ParentBasedAlwaysOn;
+	switch (sampler) {
+		case TracesSamplerValues.AlwaysOn: return new AlwaysOnSampler();
+		case TracesSamplerValues.AlwaysOff: return new AlwaysOffSampler();
+		case TracesSamplerValues.ParentBasedAlwaysOn: return new ParentBasedSampler({ root: new AlwaysOnSampler() });
+		case TracesSamplerValues.ParentBasedAlwaysOff: return new ParentBasedSampler({ root: new AlwaysOffSampler() });
+		case TracesSamplerValues.TraceIdRatio: return new TraceIdRatioBasedSampler(getSamplerProbabilityFromEnv());
+		case TracesSamplerValues.ParentBasedTraceIdRatio: return new ParentBasedSampler({ root: new TraceIdRatioBasedSampler(getSamplerProbabilityFromEnv()) });
+		default:
+			diag$1.error(`OTEL_TRACES_SAMPLER value "${sampler}" invalid, defaulting to "${TracesSamplerValues.ParentBasedAlwaysOn}".`);
+			return new ParentBasedSampler({ root: new AlwaysOnSampler() });
+	}
+}
+function getSamplerProbabilityFromEnv() {
+	const probability = /* @__PURE__ */ getNumberFromEnv("OTEL_TRACES_SAMPLER_ARG");
+	if (probability == null) {
+		diag$1.error(`OTEL_TRACES_SAMPLER_ARG is blank, defaulting to ${DEFAULT_RATIO}.`);
+		return DEFAULT_RATIO;
+	}
+	if (probability < 0 || probability > 1) {
+		diag$1.error(`OTEL_TRACES_SAMPLER_ARG=${probability} was given, but it is out of range ([0..1]), defaulting to ${DEFAULT_RATIO}.`);
+		return DEFAULT_RATIO;
+	}
+	return probability;
+}
+/**
+* Function to merge Default configuration (as specified in './config') with
+* user provided configurations.
+*/
+function mergeConfig(userConfig) {
+	const perInstanceDefaults = { sampler: buildSamplerFromEnv() };
+	const DEFAULT_CONFIG = loadDefaultConfig();
+	const target = Object.assign({}, DEFAULT_CONFIG, perInstanceDefaults, userConfig);
+	target.generalLimits = Object.assign({}, DEFAULT_CONFIG.generalLimits, userConfig.generalLimits || {});
+	target.spanLimits = Object.assign({}, DEFAULT_CONFIG.spanLimits, userConfig.spanLimits || {});
+	return target;
+}
+/**
+* When general limits are provided and model specific limits are not,
+* configures the model specific limits by using the values from the general ones.
+* @param userConfig User provided tracer configuration
+*/
+function reconfigureLimits(userConfig) {
+	const spanLimits = Object.assign({}, userConfig.spanLimits);
+	/**
+	* Reassign span attribute count limit to use first non null value defined by user or use default value
+	*/
+	spanLimits.attributeCountLimit = userConfig.spanLimits?.attributeCountLimit ?? userConfig.generalLimits?.attributeCountLimit ?? /* @__PURE__ */ getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT") ?? /* @__PURE__ */ getNumberFromEnv("OTEL_ATTRIBUTE_COUNT_LIMIT") ?? 128;
+	/**
+	* Reassign span attribute value length limit to use first non null value defined by user or use default value
+	*/
+	spanLimits.attributeValueLengthLimit = userConfig.spanLimits?.attributeValueLengthLimit ?? userConfig.generalLimits?.attributeValueLengthLimit ?? /* @__PURE__ */ getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT") ?? /* @__PURE__ */ getNumberFromEnv("OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT") ?? Infinity;
+	return Object.assign({}, userConfig, { spanLimits });
+}
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/BatchSpanProcessorBase.js
+/**
+* Implementation of the {@link SpanProcessor} that batches spans exported by
+* the SDK then pushes them to the exporter pipeline.
+*/
+var BatchSpanProcessorBase = class {
+	_maxExportBatchSize;
+	_maxQueueSize;
+	_scheduledDelayMillis;
+	_exportTimeoutMillis;
+	_exporter;
+	_isExporting = false;
+	_finishedSpans = [];
+	_timer;
+	_shutdownOnce;
+	_droppedSpansCount = 0;
+	constructor(exporter, config) {
+		this._exporter = exporter;
+		this._maxExportBatchSize = typeof config?.maxExportBatchSize === "number" ? config.maxExportBatchSize : /* @__PURE__ */ getNumberFromEnv("OTEL_BSP_MAX_EXPORT_BATCH_SIZE") ?? 512;
+		this._maxQueueSize = typeof config?.maxQueueSize === "number" ? config.maxQueueSize : /* @__PURE__ */ getNumberFromEnv("OTEL_BSP_MAX_QUEUE_SIZE") ?? 2048;
+		this._scheduledDelayMillis = typeof config?.scheduledDelayMillis === "number" ? config.scheduledDelayMillis : /* @__PURE__ */ getNumberFromEnv("OTEL_BSP_SCHEDULE_DELAY") ?? 5e3;
+		this._exportTimeoutMillis = typeof config?.exportTimeoutMillis === "number" ? config.exportTimeoutMillis : /* @__PURE__ */ getNumberFromEnv("OTEL_BSP_EXPORT_TIMEOUT") ?? 3e4;
+		this._shutdownOnce = new BindOnceFuture(this._shutdown, this);
+		if (this._maxExportBatchSize > this._maxQueueSize) {
+			diag$1.warn("BatchSpanProcessor: maxExportBatchSize must be smaller or equal to maxQueueSize, setting maxExportBatchSize to match maxQueueSize");
+			this._maxExportBatchSize = this._maxQueueSize;
+		}
+	}
+	forceFlush() {
+		if (this._shutdownOnce.isCalled) return this._shutdownOnce.promise;
+		return this._flushAll();
+	}
+	onStart(_span, _parentContext) {}
+	onEnd(span) {
+		if (this._shutdownOnce.isCalled) return;
+		if ((span.spanContext().traceFlags & TraceFlags.SAMPLED) === 0) return;
+		this._addToBuffer(span);
+	}
+	shutdown() {
+		return this._shutdownOnce.call();
+	}
+	_shutdown() {
+		return Promise.resolve().then(() => {
+			return this.onShutdown();
+		}).then(() => {
+			return this._flushAll();
+		}).then(() => {
+			return this._exporter.shutdown();
+		});
+	}
+	/** Add a span in the buffer. */
+	_addToBuffer(span) {
+		if (this._finishedSpans.length >= this._maxQueueSize) {
+			if (this._droppedSpansCount === 0) diag$1.debug("maxQueueSize reached, dropping spans");
+			this._droppedSpansCount++;
+			return;
+		}
+		if (this._droppedSpansCount > 0) {
+			diag$1.warn(`Dropped ${this._droppedSpansCount} spans because maxQueueSize reached`);
+			this._droppedSpansCount = 0;
+		}
+		this._finishedSpans.push(span);
+		this._maybeStartTimer();
+	}
+	/**
+	* Send all spans to the exporter respecting the batch size limit
+	* This function is used only on forceFlush or shutdown,
+	* for all other cases _flush should be used
+	* */
+	_flushAll() {
+		return new Promise((resolve, reject) => {
+			const promises = [];
+			const count = Math.ceil(this._finishedSpans.length / this._maxExportBatchSize);
+			for (let i = 0, j = count; i < j; i++) promises.push(this._flushOneBatch());
+			Promise.all(promises).then(() => {
+				resolve();
+			}).catch(reject);
+		});
+	}
+	_flushOneBatch() {
+		this._clearTimer();
+		if (this._finishedSpans.length === 0) return Promise.resolve();
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error("Timeout"));
+			}, this._exportTimeoutMillis);
+			context.with(suppressTracing(context.active()), () => {
+				let spans;
+				if (this._finishedSpans.length <= this._maxExportBatchSize) {
+					spans = this._finishedSpans;
+					this._finishedSpans = [];
+				} else spans = this._finishedSpans.splice(0, this._maxExportBatchSize);
+				const doExport = () => this._exporter.export(spans, (result) => {
+					clearTimeout(timer);
+					if (result.code === ExportResultCode.SUCCESS) resolve();
+					else reject(result.error ?? /* @__PURE__ */ new Error("BatchSpanProcessor: span export failed"));
+				});
+				let pendingResources = null;
+				for (let i = 0, len = spans.length; i < len; i++) {
+					const span = spans[i];
+					if (span.resource.asyncAttributesPending && span.resource.waitForAsyncAttributes) {
+						pendingResources ??= [];
+						pendingResources.push(span.resource.waitForAsyncAttributes());
+					}
+				}
+				if (pendingResources === null) doExport();
+				else Promise.all(pendingResources).then(doExport, (err) => {
+					globalErrorHandler(err);
+					reject(err);
+				});
+			});
+		});
+	}
+	_maybeStartTimer() {
+		if (this._isExporting) return;
+		const flush = () => {
+			this._isExporting = true;
+			this._flushOneBatch().finally(() => {
+				this._isExporting = false;
+				if (this._finishedSpans.length > 0) {
+					this._clearTimer();
+					this._maybeStartTimer();
+				}
+			}).catch((e) => {
+				this._isExporting = false;
+				globalErrorHandler(e);
+			});
+		};
+		if (this._finishedSpans.length >= this._maxExportBatchSize) return flush();
+		if (this._timer !== void 0) return;
+		this._timer = setTimeout(() => flush(), this._scheduledDelayMillis);
+		if (typeof this._timer !== "number") this._timer.unref();
+	}
+	_clearTimer() {
+		if (this._timer !== void 0) {
+			clearTimeout(this._timer);
+			this._timer = void 0;
+		}
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/browser/export/BatchSpanProcessor.js
+var BatchSpanProcessor = class extends BatchSpanProcessorBase {
+	_visibilityChangeListener;
+	_pageHideListener;
+	constructor(_exporter, config) {
+		super(_exporter, config);
+		this.onInit(config);
+	}
+	onInit(config) {
+		if (config?.disableAutoFlushOnDocumentHide !== true && typeof document !== "undefined") {
+			this._visibilityChangeListener = () => {
+				if (document.visibilityState === "hidden") this.forceFlush().catch((error) => {
+					globalErrorHandler(error);
+				});
+			};
+			this._pageHideListener = () => {
+				this.forceFlush().catch((error) => {
+					globalErrorHandler(error);
+				});
+			};
+			document.addEventListener("visibilitychange", this._visibilityChangeListener);
+			document.addEventListener("pagehide", this._pageHideListener);
+		}
+	}
+	onShutdown() {
+		if (typeof document !== "undefined") {
+			if (this._visibilityChangeListener) document.removeEventListener("visibilitychange", this._visibilityChangeListener);
+			if (this._pageHideListener) document.removeEventListener("pagehide", this._pageHideListener);
+		}
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/browser/RandomIdGenerator.js
+var TRACE_ID_BYTES = 16;
+var SPAN_ID_BYTES = 8;
+var TRACE_BUFFER = new Uint8Array(TRACE_ID_BYTES);
+var SPAN_BUFFER = new Uint8Array(SPAN_ID_BYTES);
+var HEX = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+/**
+* Fills buffer with random bytes, ensuring at least one is non-zero
+* per W3C Trace Context spec.
+*/
+function randomFill(buf) {
+	for (let i = 0; i < buf.length; i++) buf[i] = Math.random() * 256 >>> 0;
+	for (let i = 0; i < buf.length; i++) if (buf[i] > 0) return;
+	buf[buf.length - 1] = 1;
+}
+function toHex(buf) {
+	let hex = "";
+	for (let i = 0; i < buf.length; i++) hex += HEX[buf[i]];
+	return hex;
+}
+var RandomIdGenerator = class {
+	/**
+	* Returns a random 16-byte trace ID formatted/encoded as a 32 lowercase hex
+	* characters corresponding to 128 bits.
+	*/
+	generateTraceId() {
+		randomFill(TRACE_BUFFER);
+		return toHex(TRACE_BUFFER);
+	}
+	/**
+	* Returns a random 8-byte span ID formatted/encoded as a 16 lowercase hex
+	* characters corresponding to 64 bits.
+	*/
+	generateSpanId() {
+		randomFill(SPAN_BUFFER);
+		return toHex(SPAN_BUFFER);
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/esm/semconv.js
+/**
+* Determines whether the span has a parent span, and if so, [whether it is a remote parent](https://opentelemetry.io/docs/specs/otel/trace/api/#isremote)
+*
+* @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+*/
+var ATTR_OTEL_SPAN_PARENT_ORIGIN = "otel.span.parent.origin";
+/**
+* The result value of the sampler for this span
+*
+* @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+*/
+var ATTR_OTEL_SPAN_SAMPLING_RESULT = "otel.span.sampling_result";
+/**
+* The number of created spans with `recording=true` for which the end operation has not been called yet.
+*
+* @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+*/
+var METRIC_OTEL_SDK_SPAN_LIVE = "otel.sdk.span.live";
+/**
+* The number of created spans.
+*
+* @note Implementations **MUST** record this metric for all spans, even for non-recording ones.
+*
+* @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+*/
+var METRIC_OTEL_SDK_SPAN_STARTED = "otel.sdk.span.started";
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/esm/TracerMetrics.js
+/**
+* Generates `otel.sdk.span.*` metrics.
+* https://opentelemetry.io/docs/specs/semconv/otel/sdk-metrics/#span-metrics
+*/
+var TracerMetrics = class {
+	startedSpans;
+	liveSpans;
+	constructor(meter) {
+		this.startedSpans = meter.createCounter(METRIC_OTEL_SDK_SPAN_STARTED, {
+			unit: "{span}",
+			description: "The number of created spans."
+		});
+		this.liveSpans = meter.createUpDownCounter(METRIC_OTEL_SDK_SPAN_LIVE, {
+			unit: "{span}",
+			description: "The number of currently live spans."
+		});
+	}
+	startSpan(parentSpanCtx, samplingDecision) {
+		const samplingDecisionStr = samplingDecisionToString(samplingDecision);
+		this.startedSpans.add(1, {
+			[ATTR_OTEL_SPAN_PARENT_ORIGIN]: parentOrigin(parentSpanCtx),
+			[ATTR_OTEL_SPAN_SAMPLING_RESULT]: samplingDecisionStr
+		});
+		if (samplingDecision === SamplingDecision.NOT_RECORD) return () => {};
+		const liveSpanAttributes = { [ATTR_OTEL_SPAN_SAMPLING_RESULT]: samplingDecisionStr };
+		this.liveSpans.add(1, liveSpanAttributes);
+		return () => {
+			this.liveSpans.add(-1, liveSpanAttributes);
+		};
+	}
+};
+function parentOrigin(parentSpanContext) {
+	if (!parentSpanContext) return "none";
+	if (parentSpanContext.isRemote) return "remote";
+	return "local";
+}
+function samplingDecisionToString(decision) {
+	switch (decision) {
+		case SamplingDecision.RECORD_AND_SAMPLED: return "RECORD_AND_SAMPLE";
+		case SamplingDecision.RECORD: return "RECORD_ONLY";
+		case SamplingDecision.NOT_RECORD: return "DROP";
+	}
+}
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/esm/version.js
+var VERSION = "2.7.1";
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/esm/Tracer.js
+/**
+* This class represents a basic tracer.
+*/
+var Tracer = class {
+	_sampler;
+	_generalLimits;
+	_spanLimits;
+	_idGenerator;
+	instrumentationScope;
+	_resource;
+	_spanProcessor;
+	_tracerMetrics;
+	/**
+	* Constructs a new Tracer instance.
+	*/
+	constructor(instrumentationScope, config, resource, spanProcessor) {
+		const localConfig = mergeConfig(config);
+		this._sampler = localConfig.sampler;
+		this._generalLimits = localConfig.generalLimits;
+		this._spanLimits = localConfig.spanLimits;
+		this._idGenerator = config.idGenerator || new RandomIdGenerator();
+		this._resource = resource;
+		this._spanProcessor = spanProcessor;
+		this.instrumentationScope = instrumentationScope;
+		const meter = localConfig.meterProvider ? localConfig.meterProvider.getMeter("@opentelemetry/sdk-trace", VERSION) : createNoopMeter();
+		this._tracerMetrics = new TracerMetrics(meter);
+	}
+	/**
+	* Starts a new Span or returns the default NoopSpan based on the sampling
+	* decision.
+	*/
+	startSpan(name, options = {}, context$1 = context.active()) {
+		if (options.root) context$1 = trace.deleteSpan(context$1);
+		const parentSpan = trace.getSpan(context$1);
+		if (isTracingSuppressed(context$1)) {
+			diag$1.debug("Instrumentation suppressed, returning Noop Span");
+			return trace.wrapSpanContext(INVALID_SPAN_CONTEXT);
+		}
+		const parentSpanContext = parentSpan?.spanContext();
+		const spanId = this._idGenerator.generateSpanId();
+		let validParentSpanContext;
+		let traceId;
+		let traceState;
+		if (!parentSpanContext || !trace.isSpanContextValid(parentSpanContext)) traceId = this._idGenerator.generateTraceId();
+		else {
+			traceId = parentSpanContext.traceId;
+			traceState = parentSpanContext.traceState;
+			validParentSpanContext = parentSpanContext;
+		}
+		const spanKind = options.kind ?? SpanKind.INTERNAL;
+		const links = (options.links ?? []).map((link) => {
+			return {
+				context: link.context,
+				attributes: sanitizeAttributes(link.attributes)
+			};
+		});
+		const attributes = sanitizeAttributes(options.attributes);
+		const samplingResult = this._sampler.shouldSample(context$1, traceId, name, spanKind, attributes, links);
+		const recordEndMetrics = this._tracerMetrics.startSpan(parentSpanContext, samplingResult.decision);
+		traceState = samplingResult.traceState ?? traceState;
+		const spanContext = {
+			traceId,
+			spanId,
+			traceFlags: samplingResult.decision === SamplingDecision$1.RECORD_AND_SAMPLED ? TraceFlags.SAMPLED : TraceFlags.NONE,
+			traceState
+		};
+		if (samplingResult.decision === SamplingDecision$1.NOT_RECORD) {
+			diag$1.debug("Recording is off, propagating context in a non-recording span");
+			return trace.wrapSpanContext(spanContext);
+		}
+		const initAttributes = sanitizeAttributes(Object.assign(attributes, samplingResult.attributes));
+		return new SpanImpl({
+			resource: this._resource,
+			scope: this.instrumentationScope,
+			context: context$1,
+			spanContext,
+			name,
+			kind: spanKind,
+			links,
+			parentSpanContext: validParentSpanContext,
+			attributes: initAttributes,
+			startTime: options.startTime,
+			spanProcessor: this._spanProcessor,
+			spanLimits: this._spanLimits,
+			recordEndMetrics
+		});
+	}
+	startActiveSpan(name, arg2, arg3, arg4) {
+		let opts;
+		let ctx;
+		let fn;
+		if (arguments.length < 2) return;
+		else if (arguments.length === 2) fn = arg2;
+		else if (arguments.length === 3) {
+			opts = arg2;
+			fn = arg3;
+		} else {
+			opts = arg2;
+			ctx = arg3;
+			fn = arg4;
+		}
+		const parentContext = ctx ?? context.active();
+		const span = this.startSpan(name, opts, parentContext);
+		const contextWithSpanSet = trace.setSpan(parentContext, span);
+		return context.with(contextWithSpanSet, fn, void 0, span);
+	}
+	/** Returns the active {@link GeneralLimits}. */
+	getGeneralLimits() {
+		return this._generalLimits;
+	}
+	/** Returns the active {@link SpanLimits}. */
+	getSpanLimits() {
+		return this._spanLimits;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/esm/MultiSpanProcessor.js
+/**
+* Implementation of the {@link SpanProcessor} that simply forwards all
+* received events to a list of {@link SpanProcessor}s.
+*/
+var MultiSpanProcessor = class {
+	_spanProcessors;
+	constructor(spanProcessors) {
+		this._spanProcessors = spanProcessors;
+	}
+	forceFlush() {
+		const promises = [];
+		for (const spanProcessor of this._spanProcessors) promises.push(spanProcessor.forceFlush());
+		return new Promise((resolve) => {
+			Promise.all(promises).then(() => {
+				resolve();
+			}).catch((error) => {
+				globalErrorHandler(error || /* @__PURE__ */ new Error("MultiSpanProcessor: forceFlush failed"));
+				resolve();
+			});
+		});
+	}
+	onStart(span, context) {
+		for (const spanProcessor of this._spanProcessors) spanProcessor.onStart(span, context);
+	}
+	onEnding(span) {
+		for (const spanProcessor of this._spanProcessors) if (spanProcessor.onEnding) spanProcessor.onEnding(span);
+	}
+	onEnd(span) {
+		for (const spanProcessor of this._spanProcessors) spanProcessor.onEnd(span);
+	}
+	shutdown() {
+		const promises = [];
+		for (const spanProcessor of this._spanProcessors) promises.push(spanProcessor.shutdown());
+		return new Promise((resolve, reject) => {
+			Promise.all(promises).then(() => {
+				resolve();
+			}, reject);
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/esm/BasicTracerProvider.js
+var ForceFlushState;
+(function(ForceFlushState) {
+	ForceFlushState[ForceFlushState["resolved"] = 0] = "resolved";
+	ForceFlushState[ForceFlushState["timeout"] = 1] = "timeout";
+	ForceFlushState[ForceFlushState["error"] = 2] = "error";
+	ForceFlushState[ForceFlushState["unresolved"] = 3] = "unresolved";
+})(ForceFlushState || (ForceFlushState = {}));
+/**
+* This class represents a basic tracer provider which platform libraries can extend
+*/
+var BasicTracerProvider = class {
+	_config;
+	_tracers = /* @__PURE__ */ new Map();
+	_resource;
+	_activeSpanProcessor;
+	constructor(config = {}) {
+		const mergedConfig = merge({}, loadDefaultConfig(), reconfigureLimits(config));
+		this._resource = mergedConfig.resource ?? defaultResource();
+		this._config = Object.assign({}, mergedConfig, { resource: this._resource });
+		const spanProcessors = [];
+		if (config.spanProcessors?.length) spanProcessors.push(...config.spanProcessors);
+		this._activeSpanProcessor = new MultiSpanProcessor(spanProcessors);
+	}
+	getTracer(name, version, options) {
+		const key = `${name}@${version || ""}:${options?.schemaUrl || ""}`;
+		if (!this._tracers.has(key)) this._tracers.set(key, new Tracer({
+			name,
+			version,
+			schemaUrl: options?.schemaUrl
+		}, this._config, this._resource, this._activeSpanProcessor));
+		return this._tracers.get(key);
+	}
+	forceFlush() {
+		const timeout = this._config.forceFlushTimeoutMillis;
+		const promises = this._activeSpanProcessor["_spanProcessors"].map((spanProcessor) => {
+			return new Promise((resolve) => {
+				let state;
+				const timeoutInterval = setTimeout(() => {
+					resolve(/* @__PURE__ */ new Error(`Span processor did not completed within timeout period of ${timeout} ms`));
+					state = ForceFlushState.timeout;
+				}, timeout);
+				spanProcessor.forceFlush().then(() => {
+					clearTimeout(timeoutInterval);
+					if (state !== ForceFlushState.timeout) {
+						state = ForceFlushState.resolved;
+						resolve(state);
+					}
+				}).catch((error) => {
+					clearTimeout(timeoutInterval);
+					state = ForceFlushState.error;
+					resolve(error);
+				});
+			});
+		});
+		return new Promise((resolve, reject) => {
+			Promise.all(promises).then((results) => {
+				const errors = results.filter((result) => result !== ForceFlushState.resolved);
+				if (errors.length > 0) reject(errors);
+				else resolve();
+			}).catch((error) => reject([error]));
+		});
+	}
+	shutdown() {
+		return this._activeSpanProcessor.shutdown();
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-web@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-web/build/esm/StackContextManager.js
+/**
+* Stack Context Manager for managing the state in web
+* it doesn't fully support the async calls though
+*/
+var StackContextManager = class {
+	/**
+	* whether the context manager is enabled or not
+	*/
+	_enabled = false;
+	/**
+	* Keeps the reference to current context
+	*/
+	_currentContext = ROOT_CONTEXT;
+	/**
+	*
+	* @param context
+	* @param target Function to be executed within the context
+	*/
+	_bindFunction(context = ROOT_CONTEXT, target) {
+		const manager = this;
+		const contextWrapper = function(...args) {
+			return manager.with(context, () => target.apply(this, args));
+		};
+		Object.defineProperty(contextWrapper, "length", {
+			enumerable: false,
+			configurable: true,
+			writable: false,
+			value: target.length
+		});
+		return contextWrapper;
+	}
+	/**
+	* Returns the active context
+	*/
+	active() {
+		return this._currentContext;
+	}
+	/**
+	* Binds a the certain context or the active one to the target function and then returns the target
+	* @param context A context (span) to be bind to target
+	* @param target a function or event emitter. When target or one of its callbacks is called,
+	*  the provided context will be used as the active context for the duration of the call.
+	*/
+	bind(context, target) {
+		if (context === void 0) context = this.active();
+		if (typeof target === "function") return this._bindFunction(context, target);
+		return target;
+	}
+	/**
+	* Disable the context manager (clears the current context)
+	*/
+	disable() {
+		this._currentContext = ROOT_CONTEXT;
+		this._enabled = false;
+		return this;
+	}
+	/**
+	* Enables the context manager and creates a default(root) context
+	*/
+	enable() {
+		if (this._enabled) return this;
+		this._enabled = true;
+		this._currentContext = ROOT_CONTEXT;
+		return this;
+	}
+	/**
+	* Calls the callback function [fn] with the provided [context]. If [context] is undefined then it will use the window.
+	* The context will be set as active
+	* @param context
+	* @param fn Callback function
+	* @param thisArg optional receiver to be used for calling fn
+	* @param args optional arguments forwarded to fn
+	*/
+	with(context, fn, thisArg, ...args) {
+		const previousContext = this._currentContext;
+		this._currentContext = context || ROOT_CONTEXT;
+		try {
+			return fn.call(thisArg, ...args);
+		} finally {
+			this._currentContext = previousContext;
+		}
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+sdk-trace-web@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-web/build/esm/WebTracerProvider.js
+function setupContextManager(contextManager) {
+	if (contextManager === null) return;
+	if (contextManager === void 0) {
+		const defaultContextManager = new StackContextManager();
+		defaultContextManager.enable();
+		context.setGlobalContextManager(defaultContextManager);
+		return;
+	}
+	contextManager.enable();
+	context.setGlobalContextManager(contextManager);
+}
+function setupPropagator(propagator) {
+	if (propagator === null) return;
+	if (propagator === void 0) {
+		propagation.setGlobalPropagator(new CompositePropagator({ propagators: [new W3CTraceContextPropagator(), new W3CBaggagePropagator()] }));
+		return;
+	}
+	propagation.setGlobalPropagator(propagator);
+}
+/**
+* This class represents a web tracer with {@link StackContextManager}
+*/
+var WebTracerProvider = class extends BasicTracerProvider {
+	/**
+	* Constructs a new Tracer instance.
+	* @param config Web Tracer config
+	*/
+	constructor(config = {}) {
+		super(config);
+	}
+	/**
+	* Register this TracerProvider for use with the OpenTelemetry API.
+	* Undefined values may be replaced with defaults, and
+	* null values will be skipped.
+	*
+	* @param config Configuration object for SDK registration
+	*/
+	register(config = {}) {
+		trace.setGlobalTracerProvider(this);
+		setupPropagator(config.propagator);
+		setupContextManager(config.contextManager);
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@opentelemetry+exporter-trace-otlp-http@0.218.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/platform/browser/OTLPTraceExporter.js
+/**
+* Collector Trace Exporter for Web
+*/
+var OTLPTraceExporter = class extends OTLPExporterBase {
+	constructor(config = {}) {
+		super(createLegacyOtlpBrowserExportDelegate(config, JsonTraceSerializer, "v1/traces", { "Content-Type": "application/json" }));
+	}
+};
+//#endregion
+//#region utils/trace-id.ts
+/**
+* W3C trace-id / traceparent derivation for the driving-service upstream.
+*
+* Kept apart from `otel-trace.ts` so it pulls in no `@opentelemetry` packages:
+* the WebSocket client stamps a traceparent on every first audio chunk, and it
+* should not drag the tracer SDK into that path (nor into the unit tests, where
+* the otel-api ESM build does not resolve cleanly).
+*
+* @internal
+*/
+/**
+* 把 conversation_id 确定性映射成合法的 W3C trace_id（16 字节 / 32 位十六进制）。
+*
+* W3C/OTel 规定 trace_id 必须是 32 hex，而 conversation_id（形如
+* `20260718110509_4xz9iyH8F3Gi`）不是合法格式，不能直接用。这里用 FNV-1a 以 4 个不同
+* 初始种子各算一个 32bit 哈希，拼成 128bit —— 同步、确定性（同一 conversation_id 永远
+* 得同一 trace_id）、无外部依赖，后端可用同一算法复现以串成同一条 trace。
+* @internal
+*/
+/** FNV-1a 32-bit with a variable seed, so one string yields several independent hashes. */
+function fnv1a(str, seed) {
+	let h = seed >>> 0;
+	for (let i = 0; i < str.length; i++) {
+		h ^= str.charCodeAt(i);
+		h = Math.imul(h, 16777619) >>> 0;
+	}
+	return h >>> 0;
+}
+function conversationIdToTraceId(conversationId) {
+	const seeds = [
+		2166136261,
+		16777619,
+		3735928559,
+		2654435769
+	];
+	let hex = "";
+	for (const s of seeds) hex += fnv1a(conversationId, s).toString(16).padStart(8, "0");
+	return /^0+$/.test(hex) ? "0".repeat(31) + "1" : hex;
+}
+/**
+* Derive the driven.request span_id (8 bytes / 16 hex) deterministically from
+* the conversation_id.
+*
+* The server needs traceparent's parent span_id on the FIRST ClientAudioInput —
+* before the SDK has built the driven.request span, which only happens when
+* playback ends and the timeline is known. Deriving it means both moments can
+* compute the same span_id independently, so the traceparent the server sees and
+* the span the SDK later reports carry the identical id, with no state threaded
+* between "audio sent" and "playback ended". Uses seeds distinct from the
+* trace_id ones so the span_id is not a slice of the trace_id.
+* @internal
+*/
+function conversationIdToDrivenSpanId(conversationId) {
+	const hex = fnv1a(conversationId, 3421674724).toString(16).padStart(8, "0") + fnv1a(conversationId, 4294967297).toString(16).padStart(8, "0");
+	return /^0+$/.test(hex) ? "0".repeat(15) + "1" : hex;
+}
+/**
+* Monotonic counter mixed into every generated id. performance.now() barely moves
+* between spans built in the same millisecond, so on its own it produced COLLIDING
+* span ids (several recv spans shared one id, breaking the trace tree). The counter
+* guarantees a distinct seed per call and per hex chunk.
+*/
+var idCounter = 0;
+/** A random lowercase-hex string of `len` chars, non-zero. Not for ids that must be reproducible. */
+function randomHex(len) {
+	let out = "";
+	while (out.length < len) {
+		idCounter = idCounter + 1 >>> 0;
+		const seed = ((performance.now() * 1e6 | 0) ^ Math.imul(idCounter, 2654435769)) >>> 0;
+		const n = Math.imul(seed, 2246822507) >>> 0;
+		out += n.toString(16).padStart(8, "0");
+	}
+	const hex = out.slice(0, len);
+	return /^0+$/.test(hex) ? "0".repeat(len - 1) + "1" : hex;
+}
+/**
+* OTel IdGenerator that lets one span be given a specific id — the officially
+* supported way to control a span_id, versus reaching into span internals.
+*
+* driven.request must carry the exact span_id already placed in the first
+* ClientAudioInput's traceparent, so the server's audio.process (parent = that
+* id) hangs under the SDK's real span. Set `nextSpanId` right before startSpan;
+* the generator hands it out once, then falls back to random for every other
+* span (whose ids need not be predictable).
+*
+* Deliberately dependency-free (no `implements IdGenerator`) so this module pulls
+* in no @opentelemetry package; it duck-types the two-method interface.
+* @internal
+*/
+var PinnableIdGenerator = class {
+	nextSpanId = null;
+	generateTraceId() {
+		return randomHex(32);
+	}
+	generateSpanId() {
+		if (this.nextSpanId) {
+			const id = this.nextSpanId;
+			this.nextSpanId = null;
+			return id;
+		}
+		return randomHex(16);
+	}
+};
+/**
+* Build the W3C `traceparent` for a conversation's upstream audio, to hand the
+* driving service on the first ClientAudioInput of each req_id so its trace
+* continues this SDK's rather than starting a fresh root.
+*
+* Both ids are DERIVED from the conversation_id, matching what the playback
+* trace builds when it ends: the trace_id so the server's trace and the SDK's
+* spans share one trace, and the span_id so it equals the driven.request span's
+* id — which the server hangs audio.process under. Deriving both means the
+* traceparent sent now and the span reported later carry the identical ids with
+* no state threaded between them.
+*
+* Returns null when tracing is disabled or filtered, so callers simply omit the
+* field — matching the proto's "absent → server starts a new root" contract.
+*
+* @internal
+*/
+function buildTraceparent(conversationId) {
+	if (!conversationId) return null;
+	return `00-${conversationIdToTraceId(conversationId)}-${conversationIdToDrivenSpanId(conversationId)}-01`;
+}
+//#endregion
+//#region utils/otel-trace.ts
+/**
+* OpenTelemetry Trace Tracker (Browser Version)
+*
+* 独立于 logs / metrics 的第三条 OTel 通道——**Trace 信号**（OTLP `/v1/traces`），
+* 目标后端 OpenObserve。与另两条通道分离：各自 provider、各自 exporter、各自清理。
+*
+* 用途：一轮播放 = 一条 trace。root span 覆盖整轮，子 span 标记关键时刻
+* （首包音频到达 / 首组动画到达 / 播放结束）。trace_id 由 conversation_id 确定性
+* 派生（见 conversationIdToTraceId），使 SDK 与后端能以同一 conversation_id 关联/串联。
+* @internal
+*/
+var OTEL_TRACER_NAME = "spatius-avatarkit";
+var sdkVersion = "1.0.0";
+var isInitialized = false;
+var tracerProvider = null;
+var tracer = null;
+var idGenerator = new PinnableIdGenerator();
+function buildBasicAuthHeader() {
+	const credentials = `${OTEL_USERNAME}:${OTEL_PASSWORD}`;
+	return `Basic ${btoa(credentials)}`;
+}
+/**
+* Initialize OTel TracerProvider.
+* 与 logs / metrics 平行：同一份 resource 语义、同一套门禁与鉴权。
+* @internal
+*/
+function initializeOtelTrace(version, resourceAttrs) {
+	if (isInitialized) {
+		logger.log("[OTel-Trace] Already initialized, skipping");
+		return;
+	}
+	if ("wangruizhen@spatialwalk.net".startsWith("<TODO"), "spatialwalk".startsWith("<TODO"));
+	sdkVersion = version;
+	try {
+		tracerProvider = new WebTracerProvider({
+			resource: resourceFromAttributes({
+				[ATTR_SERVICE_NAME]: "avatarkit",
+				"sdk.version": sdkVersion,
+				"sdk.platform": "web",
+				"sdk.package": "spatius-web-sdk",
+				"app_id": resourceAttrs.appId || "",
+				"region": resourceAttrs.region,
+				"dsm": resourceAttrs.dsm,
+				...clientContextFields()
+			}),
+			spanProcessors: [new BatchSpanProcessor(observeExporter(new OTLPTraceExporter({
+				url: OTEL_TRACES_ENDPOINT,
+				headers: {
+					"Authorization": buildBasicAuthHeader(),
+					"stream-name": OTEL_TRACES_STREAM_NAME
+				}
+			}), "/v1/traces", OTEL_TRACES_ENDPOINT))],
+			idGenerator
+		});
+		trace.setGlobalTracerProvider(tracerProvider);
+		tracer = trace.getTracer(OTEL_TRACER_NAME, sdkVersion);
+		isInitialized = true;
+		logger.log(`[OTel-Trace] Initialized - endpoint: ${OTEL_TRACES_ENDPOINT}, stream: ${OTEL_TRACES_STREAM_NAME}`);
+	} catch (error) {
+		logger.warn("[OTel-Trace] Failed to initialize:", error instanceof Error ? error.message : String(error));
+	}
+}
+/** 空实现：未初始化 / 被门禁拦截时返回，调用方无需判空。 */
+var NOOP_GROUP = {
+	span: () => {},
+	end: () => {}
+};
+var NOOP_TRACE = {
+	span: () => {},
+	group: () => NOOP_GROUP,
+	end: () => {}
+};
+/**
+* 开一条**加载角色**的 trace。root span 名 `load_avatar`，覆盖 `AvatarManager` 加载
+* 全过程，内部按四段切子 span（见调用处）。
+*
+* 与播放 trace 的两点不同：
+* - **trace_id 随机**，不从业务 id 派生。加载链路上后端只参与元数据接口一处，串联需求
+*   弱；而按 avatar_id 派生会让同一角色的多次加载撞进同一条 trace，在 viewer 里叠成
+*   一条、时间轴错乱。avatar_id 作 span 属性照样能筛。
+* - **无 anchor / 不钉 span_id**：那两样是为了匹配已在线上的 traceparent，加载没有这个约束。
+*
+* 量级上远小于播放 trace：一次会话通常只加载一次角色，而对话是几十轮。
+* @internal
+*/
+/**
+* 开一条 **SDK 初始化** 的 trace。root span 名 `sdk_init`。
+*
+* 与 load / playback 是三条**独立** trace：它们本就是独立流程（初始化一次、加载可多次、
+* 对话更多次），硬串成一条会得到横跨整个 app 生命周期的怪 waterfall。三者靠 `session_id`
+* 关联——后台按它一查就能还原「这次启动做了什么」。
+*
+* 注意调用时机：trace 通道本身要到 `initializeOtelTrace` 之后才就绪，所以初始化早期
+* 阶段（region 解析等）只能先记时刻、等通道起来再用历史时间戳补发 span。
+* @internal
+*/
+function startInitTrace(sessionId, startTimeMs, attrs = {}) {
+	if (!tracer || !tracerProvider) return NOOP_TRACE;
+	try {
+		const root = tracer.startSpan("sdk_init", {
+			startTime: startTimeMs,
+			attributes: {
+				session_id: sessionId,
+				...attrs
+			}
+		}, ROOT_CONTEXT);
+		const rootCtx = trace.setSpan(ROOT_CONTEXT, root);
+		return {
+			span(name, startMs, endMs, spanAttrs = {}, isError = false) {
+				try {
+					const sp = tracer.startSpan(name, {
+						startTime: startMs,
+						attributes: spanAttrs
+					}, rootCtx);
+					if (isError) sp.setStatus({ code: SpanStatusCode.ERROR });
+					sp.end(endMs);
+				} catch {}
+			},
+			group: () => NOOP_GROUP,
+			end(ok = true, endTimeMs, endAttrs = {}) {
+				try {
+					for (const [k, v] of Object.entries(endAttrs)) root.setAttribute(k, v);
+					root.setStatus({ code: ok ? SpanStatusCode.OK : SpanStatusCode.ERROR });
+					root.end(endTimeMs);
+				} catch {}
+			}
+		};
+	} catch (error) {
+		logger.warn("[OTel-Trace] Failed to start init trace:", error instanceof Error ? error.message : String(error));
+		return NOOP_TRACE;
+	}
+}
+function startLoadTrace(avatarId, startTimeMs, attrs = {}) {
+	if (!tracer || !tracerProvider) return NOOP_TRACE;
+	try {
+		const root = tracer.startSpan("load_avatar", {
+			startTime: startTimeMs,
+			attributes: {
+				avatar_id: avatarId,
+				session_id: idManager.getSessionId(),
+				...attrs
+			}
+		}, ROOT_CONTEXT);
+		const rootCtx = trace.setSpan(ROOT_CONTEXT, root);
+		return {
+			span(name, startMs, endMs, spanAttrs = {}, isError = false) {
+				try {
+					const s = tracer.startSpan(name, {
+						startTime: startMs,
+						attributes: spanAttrs
+					}, rootCtx);
+					if (isError) s.setStatus({ code: SpanStatusCode.ERROR });
+					s.end(endMs);
+				} catch {}
+			},
+			group: () => NOOP_GROUP,
+			end(ok = true, endTimeMs, endAttrs = {}) {
+				try {
+					for (const [k, v] of Object.entries(endAttrs)) root.setAttribute(k, v);
+					root.setStatus({ code: ok ? SpanStatusCode.OK : SpanStatusCode.ERROR });
+					root.end(endTimeMs);
+				} catch {}
+			}
+		};
+	} catch (error) {
+		logger.warn("[OTel-Trace] Failed to start load trace:", error instanceof Error ? error.message : String(error));
+		return NOOP_TRACE;
+	}
+}
+/**
+* 开一条播放 trace。root span 名 `playback`，trace_id 由 conversation_id 确定性派生，
+* conversation_id 同时作为 span 属性（无论是否与后端串成一条 trace，都能按它关联查询）。
+* @param startTimeMs root span 起点（首包音频 tap_0 的真实时刻，epoch ms）；省略则用当前时刻。
+* @internal
+*/
+function startPlaybackTrace(conversationId, startTimeMs, attrs = {}) {
+	if (!tracer || !tracerProvider) return NOOP_TRACE;
+	if (!conversationId) return NOOP_TRACE;
+	try {
+		const traceId = conversationIdToTraceId(conversationId);
+		const drivenSpanId = conversationIdToDrivenSpanId(conversationId);
+		const traceRootCtx = trace.setSpanContext(ROOT_CONTEXT, {
+			traceId,
+			spanId: randomHex(16),
+			traceFlags: 1,
+			isRemote: true
+		});
+		idGenerator.nextSpanId = drivenSpanId;
+		const drivenRequest = tracer.startSpan("driven.request", {
+			attributes: {
+				conversation_id: conversationId,
+				session_id: idManager.getSessionId(),
+				...attrs
+			},
+			...typeof startTimeMs === "number" ? { startTime: startTimeMs } : {}
+		}, traceRootCtx);
+		const drivenCtx = trace.setSpan(traceRootCtx, drivenRequest);
+		const root = tracer.startSpan("playback", {
+			attributes: {
+				conversation_id: conversationId,
+				session_id: idManager.getSessionId(),
+				...attrs
+			},
+			...typeof startTimeMs === "number" ? { startTime: startTimeMs } : {}
+		}, drivenCtx);
+		const rootCtx = trace.setSpan(drivenCtx, root);
+		const emitSpan = (ctx, name, startMs, endMs, attrs, isError = false) => {
+			try {
+				const s = tracer.startSpan(name, {
+					attributes: attrs,
+					startTime: startMs
+				}, ctx);
+				if (isError) s.setStatus({ code: SpanStatusCode.ERROR });
+				s.end(endMs);
+			} catch {}
+		};
+		return {
+			span(name, startMs, endMs, spanAttrs = {}, isError = false) {
+				emitSpan(rootCtx, name, startMs, endMs, spanAttrs, isError);
+			},
+			group(name, startMs, groupAttrs = {}) {
+				try {
+					const container = tracer.startSpan(name, {
+						attributes: groupAttrs,
+						startTime: startMs
+					}, rootCtx);
+					const groupCtx = trace.setSpan(rootCtx, container);
+					return {
+						span(spanName, s, e, attrs = {}, isError = false) {
+							emitSpan(groupCtx, spanName, s, e, attrs, isError);
+						},
+						end(endMs) {
+							try {
+								container.end(endMs);
+							} catch {}
+						}
+					};
+				} catch {
+					return NOOP_GROUP;
+				}
+			},
+			end(ok = true, endTimeMs, endAttrs = {}) {
+				try {
+					for (const [k, v] of Object.entries(endAttrs)) root.setAttribute(k, v);
+					const status = { code: ok ? SpanStatusCode.OK : SpanStatusCode.ERROR };
+					root.setStatus(status);
+					root.end(endTimeMs);
+					drivenRequest.setStatus(status);
+					drivenRequest.end(endTimeMs);
+					tracerProvider?.forceFlush().catch(() => {});
+				} catch {}
+			}
+		};
+	} catch (error) {
+		logger.warn("[OTel-Trace] Failed to start playback trace:", error instanceof Error ? error.message : String(error));
+		return NOOP_TRACE;
+	}
+}
+/**
+* Cleanup：flush 剩余 span 并关闭 provider。
+* @internal
+*/
+function cleanupOtelTrace() {
+	if (!isInitialized || !tracerProvider) return;
+	try {
+		tracerProvider.forceFlush().catch(() => {});
+		tracerProvider.shutdown().catch((error) => {
+			logger.warn("[OTel-Trace] Shutdown error:", error instanceof Error ? error.message : String(error));
+		});
+	} catch (error) {
+		logger.warn("[OTel-Trace] Failed to cleanup:", error instanceof Error ? error.message : String(error));
+	} finally {
+		isInitialized = false;
+		tracerProvider = null;
+		tracer = null;
+	}
+}
+//#endregion
+export { startPlaybackTrace as a, startLoadTrace as i, initializeOtelTrace as n, buildTraceparent as o, startInitTrace as r, cleanupOtelTrace as t };