@ikonai/sdk 1.0.79 → 1.1.0

package/ikon-media-zqob_QeE.js

@@ -0,0 +1,3160 @@
+import { a as e, f as t, i as n, l as r, n as i, o as a, r as o, t as s, u as c, v as l } from "./capabilities-BtJblfdG.js";
+//#region \0rolldown/runtime.js
+var u = Object.defineProperty, d = (e, t) => {
+	let n = {};
+	for (var r in e) u(n, r, {
+		get: e[r],
+		enumerable: !0
+	});
+	return t || u(n, Symbol.toStringTag, { value: "Module" }), n;
+}, f = {
+	None: 0,
+	SendBackToSender: 1,
+	Delayable: 2,
+	SendToUser: 4,
+	Compressed: 8,
+	Unreliable: 16
+};
+function p(e) {
+	return e;
+}
+function m(e) {
+	if (e.length < 8) throw Error("Protocol message too short");
+	return (e[4] | e[5] << 8 | e[6] << 16 | e[7] << 24) >>> 0;
+}
+function h(e) {
+	return m(e) & 4294901760;
+}
+function g(e) {
+	let t = R(e), n = new DataView(t.buffer, t.byteOffset, t.byteLength);
+	if (t.length < 27) throw Error("Protocol payload too short");
+	let r = n.getUint32(0, !0), i = n.getUint32(4, !0), a = n.getUint32(8, !0), o = n.getUint32(12, !0), s = n.getUint32(16, !0), c = n.getUint32(20, !0), l = n.getUint8(24), u = n.getUint8(25), d = n.getUint8(26);
+	if (27 + c * 4 > t.length) throw Error("Protocol header exceeds payload length");
+	let f = [], p = 27;
+	for (let e = 0; e < c; e++) f.push(n.getUint32(p, !0)), p += 4;
+	return {
+		length: r,
+		opcode: i,
+		senderId: a,
+		trackId: o,
+		sequenceId: s,
+		targetIds: f,
+		payloadVersion: l,
+		payloadType: u,
+		flags: d
+	};
+}
+function ee(e, t, n) {
+	let r = R(e), i = g(r);
+	if (t !== void 0 && i.opcode !== t) throw Error(`Unexpected opcode ${i.opcode}`);
+	if (i.payloadType !== 8) throw Error(`Unexpected payload type ${i.payloadType}`);
+	let a = 27 + i.targetIds.length * 4;
+	return r.subarray(a, i.length);
+}
+async function te(e, t, n) {
+	let r = R(e), i = g(r);
+	if (t !== void 0 && i.opcode !== t) throw Error(`Unexpected opcode ${i.opcode}`);
+	if (i.payloadType !== 8) throw Error(`Unexpected payload type ${i.payloadType}`);
+	let a = 27 + i.targetIds.length * 4, o = r.subarray(a, i.length);
+	return (i.flags & f.Compressed) !== 0 && (o = await ne(o)), o;
+}
+function _(e, t, n, r, i) {
+	let a = i?.trackId ?? 0, o = i?.sequenceId ?? 0, s = i?.flags ?? 0, c = i?.targetIds ?? [], l = i?.payloadType ?? 8, u = 27 + c.length * 4, d = u + t.length, f = new Uint8Array(d), m = new DataView(f.buffer);
+	m.setUint32(0, d, !0), m.setUint32(4, e >>> 0, !0), m.setUint32(8, r >>> 0, !0), m.setUint32(12, a >>> 0, !0), m.setUint32(16, o >>> 0, !0), m.setUint32(20, c.length >>> 0, !0), m.setUint8(24, n & 255), m.setUint8(25, l & 255), m.setUint8(26, s & 255);
+	let h = 27;
+	for (let e = 0; e < c.length; e++) m.setUint32(h, c[e] >>> 0, !0), h += 4;
+	return f.set(t, u), p(f);
+}
+async function ne(e) {
+	if (typeof DecompressionStream > "u") throw Error("DecompressionStream not supported");
+	let t = new DecompressionStream("gzip"), n = t.writable.getWriter(), r = new Uint8Array(e);
+	n.write(r).then(() => n.close()).catch(() => void 0);
+	let i = t.readable.getReader(), a = [], o = 0;
+	for (;;) {
+		let { done: e, value: t } = await i.read();
+		if (e) break;
+		a.push(t), o += t.length;
+	}
+	let s = new Uint8Array(o), c = 0;
+	for (let e = 0; e < a.length; e++) s.set(a[e], c), c += a[e].length;
+	return s;
+}
+var v = /* @__PURE__ */ function(e) {
+	return e[e.Null = 1] = "Null", e[e.Bool = 2] = "Bool", e[e.Int32 = 3] = "Int32", e[e.Int64 = 4] = "Int64", e[e.UInt32 = 5] = "UInt32", e[e.UInt64 = 6] = "UInt64", e[e.Float32 = 7] = "Float32", e[e.Float64 = 8] = "Float64", e[e.Array = 9] = "Array", e[e.Dict = 10] = "Dict", e[e.Object = 11] = "Object", e[e.String = 12] = "String", e[e.Binary = 13] = "Binary", e[e.Guid = 14] = "Guid", e;
+}({}), y = 161, b = 162, x = new TextEncoder(), re = new TextDecoder("utf-8", { fatal: !0 }), S = class e {
+	buffer = new O();
+	cached;
+	constructor(e = 1) {
+		this.buffer.writeByte(y), this.buffer.writeVarUInt(e >>> 0);
+	}
+	writeInt32Field(e, t) {
+		this.writeFixedField(e, 3, () => this.buffer.writeInt32(t | 0));
+	}
+	writeUInt32Field(e, t) {
+		this.writeFixedField(e, 5, () => this.buffer.writeUInt32(t >>> 0));
+	}
+	writeInt64Field(e, t) {
+		this.writeFixedField(e, 4, () => this.buffer.writeBigInt64(t));
+	}
+	writeUInt64Field(e, t) {
+		this.writeFixedField(e, 6, () => this.buffer.writeBigUInt64(t));
+	}
+	writeFloat32Field(e, t) {
+		this.writeFixedField(e, 7, () => this.buffer.writeFloat32(t));
+	}
+	writeFloat64Field(e, t) {
+		this.writeFixedField(e, 8, () => this.buffer.writeFloat64(t));
+	}
+	writeBoolField(e, t) {
+		this.writeFixedField(e, 2, () => this.buffer.writeByte(+!!t));
+	}
+	writeGuidField(e, t) {
+		let n = t instanceof D ? t.asBytes() : t;
+		if (n.length !== 16) throw Error("Guid payload must be 16 bytes");
+		this.writeFixedField(e, 14, () => this.buffer.writeBytes(n));
+	}
+	writeStringField(e, t) {
+		let n = x.encode(t ?? "");
+		this.writeVariableField(e, 12, n);
+	}
+	writeBinaryField(e, t) {
+		this.writeVariableField(e, 13, t);
+	}
+	writeObjectField(t, n, r) {
+		let i = new e(n);
+		r(i);
+		let a = i.finish();
+		this.writeVariableField(t, 11, a);
+	}
+	writeArrayField(e, t, n) {
+		let r = new ie(t);
+		n(r);
+		let i = r.finish();
+		this.writeVariableField(e, 9, i);
+	}
+	writeDictionaryField(e, t, n, r) {
+		let i = new C(t, n);
+		r(i);
+		let a = i.finish();
+		this.writeVariableField(e, 10, a);
+	}
+	finish() {
+		return this.cached ||= (this.buffer.writeByte(b), this.buffer.toUint8Array()), this.cached;
+	}
+	writeFixedField(e, t, n) {
+		this.writeFieldHeader(e, t, 0), n();
+	}
+	writeVariableField(e, t, n) {
+		this.writeFieldHeader(e, t, n.length), this.buffer.writeBytes(n);
+	}
+	writeFieldHeader(e, t, n) {
+		this.buffer.writeUInt32(e >>> 0), this.buffer.writeByte(A(t)), de(t) && this.buffer.writeVarUInt(n >>> 0);
+	}
+}, ie = class e {
+	elementType;
+	payload = new O();
+	count = 0;
+	constructor(e) {
+		this.elementType = e;
+	}
+	writeInt32(e) {
+		this.ensureElementType(3), this.count++, this.payload.writeInt32(e | 0);
+	}
+	writeUInt32(e) {
+		this.ensureElementType(5), this.count++, this.payload.writeUInt32(e >>> 0);
+	}
+	writeInt64(e) {
+		this.ensureElementType(4), this.count++, this.payload.writeBigInt64(e);
+	}
+	writeUInt64(e) {
+		this.ensureElementType(6), this.count++, this.payload.writeBigUInt64(e);
+	}
+	writeFloat32(e) {
+		this.ensureElementType(7), this.count++, this.payload.writeFloat32(e);
+	}
+	writeFloat64(e) {
+		this.ensureElementType(8), this.count++, this.payload.writeFloat64(e);
+	}
+	writeBool(e) {
+		this.ensureElementType(2), this.count++, this.payload.writeByte(+!!e);
+	}
+	writeGuid(e) {
+		this.ensureElementType(14), this.count++;
+		let t = e instanceof D ? e.asBytes() : e;
+		if (t.length !== 16) throw Error("Guid payload must be 16 bytes");
+		this.payload.writeBytes(t);
+	}
+	writeString(e) {
+		this.ensureElementType(12), this.count++;
+		let t = x.encode(e ?? "");
+		this.payload.writeVarUInt(t.length), this.payload.writeBytes(t);
+	}
+	writeBinary(e) {
+		this.ensureElementType(13), this.count++, this.payload.writeVarUInt(e.length), this.payload.writeBytes(e);
+	}
+	writeObject(e, t) {
+		this.ensureElementType(11), this.count++;
+		let n = new S(e);
+		t(n);
+		let r = n.finish();
+		this.payload.writeVarUInt(r.length), this.payload.writeBytes(r);
+	}
+	writeArray(t, n) {
+		this.ensureElementType(9), this.count++;
+		let r = new e(t);
+		n(r);
+		let i = r.finish();
+		this.payload.writeBytes(i);
+	}
+	writeDictionary(e, t, n) {
+		this.ensureElementType(10), this.count++;
+		let r = new C(e, t);
+		n(r);
+		let i = r.finish();
+		this.payload.writeBytes(i);
+	}
+	finish() {
+		let e = new O();
+		return e.writeByte(A(this.elementType)), e.writeVarUInt(this.count), e.writeBytes(this.payload.toUint8Array()), e.toUint8Array();
+	}
+	ensureElementType(e) {
+		if (this.elementType !== e) throw Error(`Array element type is ${v[this.elementType]}, expected ${v[e]}`);
+	}
+}, C = class {
+	keyType;
+	valueType;
+	payload = new O();
+	count = 0;
+	entryOpen = !1;
+	constructor(e, t) {
+		this.keyType = e, this.valueType = t, M(e);
+	}
+	beginEntry() {
+		if (this.entryOpen) throw Error("Previous dictionary entry not completed");
+		return this.count++, this.entryOpen = !0, new ae(this.keyType, this.valueType, this.payload, () => {
+			this.entryOpen = !1;
+		});
+	}
+	finish() {
+		if (this.entryOpen) throw Error("Dictionary entry not completed");
+		let e = new O();
+		return e.writeByte(A(this.keyType)), e.writeByte(A(this.valueType)), e.writeVarUInt(this.count), e.writeBytes(this.payload.toUint8Array()), e.toUint8Array();
+	}
+}, ae = class {
+	keyType;
+	valueType;
+	payload;
+	onComplete;
+	keyWritten = !1;
+	valueWritten = !1;
+	completed = !1;
+	constructor(e, t, n, r) {
+		this.keyType = e, this.valueType = t, this.payload = n, this.onComplete = r;
+	}
+	writeKeyInt32(e) {
+		this.ensureKeyType(3), this.payload.writeInt32(e | 0), this.keyWritten = !0;
+	}
+	writeKeyUInt32(e) {
+		this.ensureKeyType(5), this.payload.writeUInt32(e >>> 0), this.keyWritten = !0;
+	}
+	writeKeyInt64(e) {
+		this.ensureKeyType(4), this.payload.writeBigInt64(e), this.keyWritten = !0;
+	}
+	writeKeyUInt64(e) {
+		this.ensureKeyType(6), this.payload.writeBigUInt64(e), this.keyWritten = !0;
+	}
+	writeKeyFloat32(e) {
+		this.ensureKeyType(7), this.payload.writeFloat32(e), this.keyWritten = !0;
+	}
+	writeKeyFloat64(e) {
+		this.ensureKeyType(8), this.payload.writeFloat64(e), this.keyWritten = !0;
+	}
+	writeKeyBool(e) {
+		this.ensureKeyType(2), this.payload.writeByte(+!!e), this.keyWritten = !0;
+	}
+	writeKeyGuid(e) {
+		this.ensureKeyType(14);
+		let t = e instanceof D ? e.asBytes() : e;
+		if (t.length !== 16) throw Error("Guid payload must be 16 bytes");
+		this.payload.writeBytes(t), this.keyWritten = !0;
+	}
+	writeKeyString(e) {
+		this.ensureKeyType(12);
+		let t = x.encode(e ?? "");
+		this.payload.writeVarUInt(t.length), this.payload.writeBytes(t), this.keyWritten = !0;
+	}
+	writeKeyBinary(e) {
+		this.ensureKeyType(13), this.payload.writeVarUInt(e.length), this.payload.writeBytes(e), this.keyWritten = !0;
+	}
+	writeValueInt32(e) {
+		this.ensureValueType(3), this.payload.writeInt32(e | 0), this.valueWritten = !0;
+	}
+	writeValueUInt32(e) {
+		this.ensureValueType(5), this.payload.writeUInt32(e >>> 0), this.valueWritten = !0;
+	}
+	writeValueInt64(e) {
+		this.ensureValueType(4), this.payload.writeBigInt64(e), this.valueWritten = !0;
+	}
+	writeValueUInt64(e) {
+		this.ensureValueType(6), this.payload.writeBigUInt64(e), this.valueWritten = !0;
+	}
+	writeValueFloat32(e) {
+		this.ensureValueType(7), this.payload.writeFloat32(e), this.valueWritten = !0;
+	}
+	writeValueFloat64(e) {
+		this.ensureValueType(8), this.payload.writeFloat64(e), this.valueWritten = !0;
+	}
+	writeValueBool(e) {
+		this.ensureValueType(2), this.payload.writeByte(+!!e), this.valueWritten = !0;
+	}
+	writeValueGuid(e) {
+		this.ensureValueType(14);
+		let t = e instanceof D ? e.asBytes() : e;
+		if (t.length !== 16) throw Error("Guid payload must be 16 bytes");
+		this.payload.writeBytes(t), this.valueWritten = !0;
+	}
+	writeNullValue() {
+		this.ensureValueType(1), this.valueWritten = !0;
+	}
+	writeValueBinary(e) {
+		this.ensureValueType(13), this.payload.writeVarUInt(e.length), this.payload.writeBytes(e), this.valueWritten = !0;
+	}
+	writeValueString(e) {
+		this.ensureValueType(12);
+		let t = x.encode(e ?? "");
+		this.payload.writeVarUInt(t.length), this.payload.writeBytes(t), this.valueWritten = !0;
+	}
+	writeValueObject(e, t) {
+		this.ensureValueType(11);
+		let n = new S(e);
+		t(n);
+		let r = n.finish();
+		this.payload.writeVarUInt(r.length), this.payload.writeBytes(r), this.valueWritten = !0;
+	}
+	writeValueArray(e, t) {
+		this.ensureValueType(9);
+		let n = new ie(e);
+		t(n);
+		let r = n.finish();
+		this.payload.writeBytes(r), this.valueWritten = !0;
+	}
+	writeValueDictionary(e, t, n) {
+		this.ensureValueType(10);
+		let r = new C(e, t);
+		n(r);
+		let i = r.finish();
+		this.payload.writeBytes(i), this.valueWritten = !0;
+	}
+	complete() {
+		if (!this.completed) {
+			if (!this.keyWritten || !this.valueWritten) throw Error("Dictionary entry must write both key and value");
+			this.completed = !0, this.onComplete();
+		}
+	}
+	ensureKeyType(e) {
+		if (this.keyType !== e) throw Error(`Dictionary key type is ${v[this.keyType]}, expected ${v[e]}`);
+	}
+	ensureValueType(e) {
+		if (this.valueType !== e) throw Error(`Dictionary value type is ${v[this.valueType]}, expected ${v[e]}`);
+	}
+}, w = class e {
+	buffer;
+	version;
+	offset;
+	end;
+	constructor(e, t, n) {
+		this.buffer = e, this.version = t, this.offset = n, this.end = e.length - 1;
+	}
+	static create(t) {
+		let n = R(t);
+		if (n.length < 2) throw Error("Teleport payload too short");
+		if (n[0] !== y || n[n.length - 1] !== b) throw Error("Teleport object missing markers");
+		let r = { offset: 1 }, i = k(n, r, "InvalidLength");
+		return new e(n, i, r.offset);
+	}
+	next() {
+		if (this.offset >= this.end) return null;
+		if (this.offset + 5 > this.buffer.length) throw Error("Teleport object truncated");
+		let e = fe(this.buffer, this.offset);
+		this.offset += 4;
+		let t = this.buffer[this.offset++], n = t >> 4 & 15;
+		if (t & 15) throw Error("Teleport field flags must be zero");
+		let r = j(n), i;
+		if (r >= 0) N(this.buffer, this.offset, r), i = this.buffer.subarray(this.offset, this.offset + r), this.offset += r;
+		else {
+			let e = { offset: this.offset }, t = k(this.buffer, e, "InvalidLength");
+			N(this.buffer, e.offset, t), i = this.buffer.subarray(e.offset, e.offset + t), this.offset = e.offset + t;
+		}
+		return new oe(e, n, i);
+	}
+}, T = class {
+	type;
+	payload;
+	constructor(e, t) {
+		this.type = e, this.payload = t;
+	}
+	asInt32() {
+		return this.ensureType(3), new DataView(this.payload.buffer, this.payload.byteOffset, 4).getInt32(0, !0);
+	}
+	asUInt32() {
+		return this.ensureType(5), new DataView(this.payload.buffer, this.payload.byteOffset, 4).getUint32(0, !0);
+	}
+	asInt64() {
+		return this.ensureType(4), new DataView(this.payload.buffer, this.payload.byteOffset, 8).getBigInt64(0, !0);
+	}
+	asUInt64() {
+		return this.ensureType(6), new DataView(this.payload.buffer, this.payload.byteOffset, 8).getBigUint64(0, !0);
+	}
+	asFloat32() {
+		return this.ensureType(7), new DataView(this.payload.buffer, this.payload.byteOffset, 4).getFloat32(0, !0);
+	}
+	asFloat64() {
+		return this.ensureType(8), new DataView(this.payload.buffer, this.payload.byteOffset, 8).getFloat64(0, !0);
+	}
+	asBool() {
+		return this.ensureType(2), this.payload.length > 0 && this.payload[0] !== 0;
+	}
+	asBinary() {
+		return this.ensureType(13), this.payload;
+	}
+	asUtf8() {
+		return this.ensureType(12), this.payload;
+	}
+	asString() {
+		return this.ensureType(12), re.decode(this.payload);
+	}
+	asGuid() {
+		return this.ensureType(14), D.fromBytes(this.payload);
+	}
+	asObject() {
+		return this.ensureType(11), w.create(this.payload);
+	}
+	asArray() {
+		return this.ensureType(9), se.create(this.payload);
+	}
+	asDictionary() {
+		return this.ensureType(10), ce.create(this.payload);
+	}
+	ensureType(e) {
+		if (this.type !== e) throw Error(`Teleport value has type ${v[this.type]}, expected ${v[e]}`);
+	}
+}, oe = class extends T {
+	fieldId;
+	constructor(e, t, n) {
+		super(t, n), this.fieldId = e;
+	}
+	get isNull() {
+		return this.type === 1;
+	}
+}, se = class e {
+	payload;
+	elementType;
+	count;
+	offset;
+	index = 0;
+	constructor(e) {
+		if (this.payload = e, e.length === 0) throw Error("Array payload too short");
+		let t = e[0];
+		if (this.elementType = t >> 4 & 15, t & 15) throw Error("Array flags must be zero");
+		let n = { offset: 1 };
+		this.count = k(e, n, "ArrayMalformed"), this.offset = n.offset;
+	}
+	static create(t) {
+		return new e(R(t));
+	}
+	next() {
+		if (this.index >= this.count) {
+			if (this.offset !== this.payload.length) throw Error("Array payload contains trailing data");
+			return null;
+		}
+		let e = this.readValue();
+		return this.index++, e;
+	}
+	readValue() {
+		switch (this.elementType) {
+			case 3:
+			case 5:
+			case 7:
+			case 8:
+			case 2:
+			case 4:
+			case 6:
+			case 14: {
+				let e = j(this.elementType);
+				N(this.payload, this.offset, e);
+				let t = this.payload.subarray(this.offset, this.offset + e);
+				return this.offset += e, new E(this.elementType, t);
+			}
+			case 12:
+			case 13: {
+				let e = { offset: this.offset }, t = k(this.payload, e, "ArrayMalformed");
+				N(this.payload, e.offset, t);
+				let n = this.payload.subarray(e.offset, e.offset + t);
+				return this.offset = e.offset + t, new E(this.elementType, n);
+			}
+			case 11: {
+				let e = { offset: this.offset }, t = k(this.payload, e, "ArrayMalformed");
+				N(this.payload, e.offset, t);
+				let n = this.payload.subarray(e.offset, e.offset + t);
+				return this.offset = e.offset + t, new E(11, n);
+			}
+			case 9: {
+				let e = P(this.payload, this.offset), t = this.payload.subarray(this.offset, this.offset + e);
+				return this.offset += e, new E(9, t);
+			}
+			case 10: {
+				let e = F(this.payload, this.offset), t = this.payload.subarray(this.offset, this.offset + e);
+				return this.offset += e, new E(10, t);
+			}
+			default: throw Error(`Unsupported array element type ${v[this.elementType]}`);
+		}
+	}
+}, E = class extends T {
+	constructor(e, t) {
+		super(e, t);
+	}
+}, ce = class e {
+	payload;
+	keyType;
+	valueType;
+	count;
+	offset;
+	index = 0;
+	constructor(e) {
+		if (this.payload = e, e.length < 2) throw Error("Dictionary payload too short");
+		if (this.keyType = e[0] >> 4 & 15, this.valueType = e[1] >> 4 & 15, e[0] & 15 || e[1] & 15) throw Error("Dictionary key/value flags must be zero");
+		M(this.keyType);
+		let t = { offset: 2 };
+		this.count = k(e, t, "DictMalformed"), this.offset = t.offset;
+	}
+	static create(t) {
+		return new e(R(t));
+	}
+	next() {
+		if (this.index >= this.count) {
+			if (this.offset !== this.payload.length) throw Error("Dictionary payload contains trailing data");
+			return null;
+		}
+		let e = this.readKey(), t = this.readValue();
+		return this.index++, new le(e, t);
+	}
+	readKey() {
+		let e = j(this.keyType);
+		if (e >= 0) {
+			N(this.payload, this.offset, e);
+			let t = this.payload.subarray(this.offset, this.offset + e);
+			return this.offset += e, new T(this.keyType, t);
+		}
+		if (this.keyType === 12 || this.keyType === 13) {
+			let e = { offset: this.offset }, t = k(this.payload, e, "DictMalformed");
+			N(this.payload, e.offset, t);
+			let n = this.payload.subarray(e.offset, e.offset + t);
+			return this.offset = e.offset + t, new T(this.keyType, n);
+		}
+		throw Error("Unsupported dictionary key type");
+	}
+	readValue() {
+		switch (this.valueType) {
+			case 12:
+			case 13: {
+				let e = { offset: this.offset }, t = k(this.payload, e, "DictMalformed");
+				N(this.payload, e.offset, t);
+				let n = this.payload.subarray(e.offset, e.offset + t);
+				return this.offset = e.offset + t, new T(this.valueType, n);
+			}
+			case 11: {
+				let e = { offset: this.offset }, t = k(this.payload, e, "DictMalformed");
+				N(this.payload, e.offset, t);
+				let n = this.payload.subarray(e.offset, e.offset + t);
+				return this.offset = e.offset + t, new T(11, n);
+			}
+			case 9: {
+				let e = P(this.payload, this.offset), t = this.payload.subarray(this.offset, this.offset + e);
+				return this.offset += e, new T(9, t);
+			}
+			case 10: {
+				let e = F(this.payload, this.offset), t = this.payload.subarray(this.offset, this.offset + e);
+				return this.offset += e, new T(10, t);
+			}
+			case 3:
+			case 5:
+			case 7:
+			case 8:
+			case 2:
+			case 4:
+			case 6:
+			case 14:
+			case 1: {
+				let e = j(this.valueType);
+				N(this.payload, this.offset, e);
+				let t = this.payload.subarray(this.offset, this.offset + e);
+				return this.offset += e, new T(this.valueType, t);
+			}
+			default: throw Error(`Unsupported dictionary value type ${v[this.valueType]}`);
+		}
+	}
+}, le = class {
+	key;
+	value;
+	constructor(e, t) {
+		this.key = e, this.value = t;
+	}
+}, D = class e {
+	bytes;
+	constructor(e) {
+		this.bytes = e;
+	}
+	static fromString(t) {
+		if (!t) throw Error("Guid string is empty");
+		let n = t.replace(/-/g, "");
+		if (n.length !== 32) throw Error("Guid string must be 32 hex characters");
+		let r = /* @__PURE__ */ new Uint8Array(16), i = e.parseHexSlice(n, 0, 8), a = e.parseHexSlice(n, 8, 4), o = e.parseHexSlice(n, 12, 4);
+		e.writeUInt32LE(r, 0, i), e.writeUInt16LE(r, 4, a), e.writeUInt16LE(r, 6, o);
+		for (let t = 0; t < 8; t++) r[8 + t] = e.parseHexSlice(n, 16 + t * 2, 2);
+		return new e(r);
+	}
+	static fromBytes(t) {
+		if (t.length !== 16) throw Error("Guid byte array must be 16 bytes");
+		return new e(Uint8Array.from(t));
+	}
+	static createZero() {
+		return new e(/* @__PURE__ */ new Uint8Array(16));
+	}
+	static createRandom() {
+		let t = /* @__PURE__ */ new Uint8Array(16), n = globalThis.crypto;
+		if (n?.getRandomValues) n.getRandomValues(t);
+		else for (let e = 0; e < t.length; e++) t[e] = Math.floor(Math.random() * 256);
+		return t[6] = t[6] & 15 | 64, t[8] = t[8] & 63 | 128, new e(t);
+	}
+	toString() {
+		let t = this.bytes;
+		return [
+			e.toHex(e.readUInt32LE(t, 0), 8),
+			e.toHex(e.readUInt16LE(t, 4), 4),
+			e.toHex(e.readUInt16LE(t, 6), 4),
+			L(t.subarray(8, 10)),
+			L(t.subarray(10, 16))
+		].join("-");
+	}
+	asBytes() {
+		return this.bytes.slice();
+	}
+	static parseHexSlice(e, t, n) {
+		let r = e.substr(t, n), i = Number.parseInt(r, 16);
+		if (Number.isNaN(i)) throw Error("Guid string contains invalid characters");
+		return i >>> 0;
+	}
+	static writeUInt32LE(e, t, n) {
+		let r = n >>> 0;
+		e[t] = r & 255, e[t + 1] = r >>> 8 & 255, e[t + 2] = r >>> 16 & 255, e[t + 3] = r >>> 24 & 255;
+	}
+	static writeUInt16LE(e, t, n) {
+		let r = n & 65535;
+		e[t] = r & 255, e[t + 1] = r >>> 8 & 255;
+	}
+	static readUInt32LE(e, t) {
+		return (e[t] | e[t + 1] << 8 | e[t + 2] << 16 | e[t + 3] << 24) >>> 0;
+	}
+	static readUInt16LE(e, t) {
+		return (e[t] | e[t + 1] << 8) & 65535;
+	}
+	static toHex(e, t) {
+		return (e >>> 0).toString(16).padStart(t, "0");
+	}
+}, O = class e {
+	static INITIAL_CAPACITY = 256;
+	buffer;
+	dataView;
+	length = 0;
+	constructor() {
+		this.buffer = new Uint8Array(e.INITIAL_CAPACITY), this.dataView = new DataView(this.buffer.buffer);
+	}
+	ensureCapacity(e) {
+		let t = this.length + e;
+		if (t <= this.buffer.length) return;
+		let n = this.buffer.length;
+		for (; n < t;) n *= 2;
+		let r = new Uint8Array(n);
+		r.set(this.buffer.subarray(0, this.length)), this.buffer = r, this.dataView = new DataView(this.buffer.buffer);
+	}
+	writeByte(e) {
+		this.ensureCapacity(1), this.buffer[this.length++] = e & 255;
+	}
+	writeBytes(e) {
+		this.ensureCapacity(e.length), this.buffer.set(e, this.length), this.length += e.length;
+	}
+	writeUInt32(e) {
+		this.ensureCapacity(4), this.dataView.setUint32(this.length, e >>> 0, !0), this.length += 4;
+	}
+	writeInt32(e) {
+		this.ensureCapacity(4), this.dataView.setInt32(this.length, e | 0, !0), this.length += 4;
+	}
+	writeFloat32(e) {
+		this.ensureCapacity(4), this.dataView.setFloat32(this.length, e, !0), this.length += 4;
+	}
+	writeFloat64(e) {
+		this.ensureCapacity(8), this.dataView.setFloat64(this.length, e, !0), this.length += 8;
+	}
+	writeBigInt64(e) {
+		this.ensureCapacity(8), this.dataView.setBigInt64(this.length, e, !0), this.length += 8;
+	}
+	writeBigUInt64(e) {
+		this.ensureCapacity(8), this.dataView.setBigUint64(this.length, e, !0), this.length += 8;
+	}
+	writeVarUInt(e) {
+		let t = e >>> 0;
+		for (; t >= 128;) this.ensureCapacity(1), this.buffer[this.length++] = t & 127 | 128, t >>>= 7;
+		this.ensureCapacity(1), this.buffer[this.length++] = t & 127;
+	}
+	toUint8Array() {
+		return this.buffer.slice(0, this.length);
+	}
+};
+function k(e, t, n) {
+	if (t.offset >= e.length) throw Error(n);
+	let r = 0, i = 0, a = 0;
+	for (; t.offset < e.length;) {
+		let n = e[t.offset++];
+		if (a++, r |= (n & 127) << i, !(n & 128)) {
+			if (a !== ue(r)) throw Error("Teleport VarUInt is not canonical");
+			return r >>> 0;
+		}
+		if (i += 7, i >= 35) throw Error("Teleport VarUInt exceeds 32-bit range");
+	}
+	throw Error(n);
+}
+function ue(e) {
+	return e < 128 ? 1 : e < 16384 ? 2 : e < 2097152 ? 3 : e < 268435456 ? 4 : 5;
+}
+function A(e, t = 0) {
+	if (t & 240) throw Error("Teleport flags must fit into 4 bits");
+	return (e & 15) << 4 | t & 15;
+}
+function de(e) {
+	return e === 12 || e === 13 || e === 9 || e === 11 || e === 10;
+}
+function j(e) {
+	switch (e) {
+		case 3:
+		case 5:
+		case 7: return 4;
+		case 4:
+		case 6:
+		case 8: return 8;
+		case 14: return 16;
+		case 2: return 1;
+		case 1: return 0;
+		default: return -1;
+	}
+}
+function M(e) {
+	if (e === 9 || e === 11 || e === 10 || e === 1) throw Error("Dictionary keys must be primitive Teleport types");
+}
+function N(e, t, n) {
+	if (t < 0 || n < 0 || t + n > e.length) throw Error("Teleport payload exceeds bounds");
+}
+function fe(e, t) {
+	return (e[t] | e[t + 1] << 8 | e[t + 2] << 16 | e[t + 3] << 24) >>> 0;
+}
+function P(e, t) {
+	if (t >= e.length) throw Error("Array payload exceeds bounds");
+	let n = e[t], r = n >> 4 & 15;
+	if (n & 15) throw Error("Array flags must be zero");
+	let i = { offset: t + 1 }, a = k(e, i, "ArrayMalformed"), o = j(r);
+	if (o >= 0) {
+		let n = o * a;
+		return N(e, i.offset, n), i.offset + n - t;
+	}
+	let s = i.offset;
+	for (let t = 0; t < a; t++) s = I(r, e, s, "ArrayMalformed");
+	return s - t;
+}
+function F(e, t) {
+	if (t + 2 > e.length) throw Error("Dictionary payload too short");
+	let n = e[t] >> 4 & 15, r = e[t + 1] >> 4 & 15;
+	if (e[t] & 15 || e[t + 1] & 15) throw Error("Dictionary key/value flags must be zero");
+	M(n);
+	let i = { offset: t + 2 }, a = k(e, i, "DictMalformed"), o = i.offset;
+	for (let t = 0; t < a; t++) o = I(n, e, o, "DictMalformed"), o = I(r, e, o, "DictMalformed");
+	return o - t;
+}
+function I(e, t, n, r) {
+	let i = j(e);
+	if (i >= 0) return N(t, n, i), n + i;
+	switch (e) {
+		case 12:
+		case 13: {
+			let e = { offset: n }, i = k(t, e, r);
+			return N(t, e.offset, i), e.offset + i;
+		}
+		case 11: {
+			let e = { offset: n }, i = k(t, e, r);
+			return N(t, e.offset, i), e.offset + i;
+		}
+		case 9: return n + P(t, n);
+		case 10: return n + F(t, n);
+		default: throw Error(`Unsupported Teleport type ${v[e]}`);
+	}
+}
+function L(e) {
+	return Array.from(e).map((e) => e.toString(16).padStart(2, "0")).join("");
+}
+function R(e) {
+	return e instanceof Uint8Array ? e : new Uint8Array(e);
+}
+//#endregion
+//#region ../../shared/protocol/src/enums/log-type.ts
+var pe = /* @__PURE__ */ function(e) {
+	return e[e.None = 0] = "None", e[e.Trace = 1] = "Trace", e[e.Debug = 2] = "Debug", e[e.Info = 4] = "Info", e[e.Warning = 8] = "Warning", e[e.Error = 16] = "Error", e[e.Critical = 32] = "Critical", e[e.Event = 64] = "Event", e[e.Usage = 128] = "Usage", e[e.Exception = 256] = "Exception", e;
+}({}), z = /* @__PURE__ */ function(e) {
+	return e[e.Unknown = 0] = "Unknown", e[e.Playing = 1] = "Playing", e[e.Blocked = 2] = "Blocked", e[e.Hidden = 3] = "Hidden", e;
+}({}), me = /* @__PURE__ */ function(e) {
+	return e[e.Unknown = 0] = "Unknown", e[e.Opus = 1] = "Opus", e[e.Mp3 = 2] = "Mp3", e[e.RawPcm16 = 3] = "RawPcm16", e;
+}({}), he = /* @__PURE__ */ function(e) {
+	return e[e.Unknown = 0] = "Unknown", e[e.MobileWeb = 1] = "MobileWeb", e[e.MobileApp = 2] = "MobileApp", e[e.DesktopWeb = 3] = "DesktopWeb", e[e.DesktopApp = 4] = "DesktopApp", e;
+}({}), ge = /* @__PURE__ */ function(e) {
+	return e[e.Unknown = 0] = "Unknown", e[e.Backend = 2] = "Backend", e[e.Server = 4] = "Server", e[e.Plugin = 8] = "Plugin", e[e.Browser = 16] = "Browser", e[e.Native = 32] = "Native", e;
+}({}), _e = /* @__PURE__ */ function(e) {
+	return e[e.None = 0] = "None", e[e.WebSocket = 1] = "WebSocket", e[e.WebSocketProxy = 2] = "WebSocketProxy", e[e.WebTransport = 4] = "WebTransport", e[e.WebTransportProxy = 8] = "WebTransportProxy", e[e.Tcp = 16] = "Tcp", e[e.TcpProxy = 32] = "TcpProxy", e[e.Https = 64] = "Https", e[e.WebRTC = 128] = "WebRTC", e[e.TcpTls = 256] = "TcpTls", e[e.Udp = 512] = "Udp", e[e.UdpDtls = 1024] = "UdpDtls", e;
+}({}), ve = /* @__PURE__ */ function(e) {
+	return e[e.None = 0] = "None", e[e.SendBackToSender = 1] = "SendBackToSender", e[e.Delayable = 2] = "Delayable", e[e.SendToUser = 4] = "SendToUser", e[e.Compressed = 8] = "Compressed", e[e.Unreliable = 16] = "Unreliable", e;
+}({}), ye = /* @__PURE__ */ function(e) {
+	return e[e.Unknown = 0] = "Unknown", e[e.MessagePack = 1] = "MessagePack", e[e.MemoryPack = 2] = "MemoryPack", e[e.Json = 4] = "Json", e[e.Teleport = 8] = "Teleport", e[e.All = 15] = "All", e;
+}({}), be = /* @__PURE__ */ function(e) {
+	return e[e.Css = 0] = "Css", e[e.Flutter = 1] = "Flutter", e;
+}({}), xe = /* @__PURE__ */ function(e) {
+	return e[e.Unknown = 0] = "Unknown", e[e.Machine = 1] = "Machine", e[e.Human = 2] = "Human", e;
+}({}), B = /* @__PURE__ */ function(e) {
+	return e[e.Unknown = 0] = "Unknown", e[e.H264 = 1] = "H264", e[e.Vp8 = 2] = "Vp8", e[e.Vp9 = 3] = "Vp9", e[e.Av1 = 4] = "Av1", e;
+}({}), Se = /* @__PURE__ */ function(e) {
+	return e[e.Unknown = 0] = "Unknown", e[e.DotNet = 1] = "DotNet", e[e.TypeScript = 2] = "TypeScript", e[e.Cpp = 3] = "Cpp", e[e.Dart = 4] = "Dart", e[e.Rust = 5] = "Rust", e;
+}({}), Ce = /* @__PURE__ */ function(e) {
+	return e[e.Local = 0] = "Local", e[e.Cloud = 1] = "Cloud", e;
+}({}), we = 4194311, Te = 112206629, Ee = 420935914, De = 4086360332, Oe = 4253308507;
+function V(e) {
+	let t = {};
+	return ke(t), e && Object.assign(t, e), t;
+}
+function ke(e) {
+	return e.Epoch = 0, e.PlayedSeconds = 0, e.BufferedMs = 0, e.State = z.Unknown, e;
+}
+function Ae(e) {
+	let t = new S(1);
+	return je(e, t), t.finish();
+}
+function je(e, t) {
+	t.writeFloat32Field(Te, e.BufferedMs), t.writeInt32Field(Ee, e.State), t.writeUInt32Field(De, e.Epoch >>> 0), t.writeFloat64Field(Oe, e.PlayedSeconds);
+}
+function H(e, t, n) {
+	return _(we, Ae(e), 1, t, n);
+}
+var Me = 161083277, Ne = 265814330, Pe = 1368629611, Fe = 2431514951, Ie = 2514959030, Le = 2745379226, Re = 3282782683, ze = 3284746250, Be = 4101844078;
+function U(e) {
+	let t = {};
+	return W(t), e && Object.assign(t, e), t;
+}
+function W(e) {
+	return e.StreamId = "", e.Description = "", e.SourceType = "", e.Codec = me.Unknown, e.CodecDetails = "", e.SampleRate = 0, e.Channels = 0, e.ShapeSets = void 0, e.CorrelationId = void 0, e;
+}
+function Ve(e, t) {
+	let n = t ?? U();
+	return W(n), He(e, n), n;
+}
+function He(e, t) {
+	let n;
+	for (; (n = e.next()) !== null;) switch (n.fieldId) {
+		case Me:
+			if (n.isNull) throw Error();
+			t.StreamId = n.asString();
+			break;
+		case Ne:
+			if (n.isNull) {
+				t.ShapeSets = void 0;
+				break;
+			}
+			t.ShapeSets = Ue(n.asArray());
+			break;
+		case Pe:
+			if (n.isNull) throw Error();
+			t.Description = n.asString();
+			break;
+		case Fe:
+			if (n.isNull) throw Error();
+			t.Channels = n.asInt32();
+			break;
+		case Ie:
+			if (n.isNull) {
+				t.CorrelationId = void 0;
+				break;
+			}
+			t.CorrelationId = n.asString();
+			break;
+		case Le:
+			if (n.isNull) throw Error();
+			t.CodecDetails = n.asString();
+			break;
+		case Re:
+			if (n.isNull) throw Error();
+			t.SourceType = n.asString();
+			break;
+		case ze:
+			if (n.isNull) throw Error();
+			t.Codec = n.asInt32();
+			break;
+		case Be:
+			if (n.isNull) throw Error();
+			t.SampleRate = n.asInt32();
+			break;
+		default: break;
+	}
+}
+function Ue(e) {
+	let t = [], n;
+	for (; (n = e.next()) !== null;) t.push(Je(n.asObject()));
+	return t;
+}
+var We = 1107713536, Ge = 1154362099, Ke = 1185721362;
+function qe(e) {
+	let t = {};
+	return G(t), e && Object.assign(t, e), t;
+}
+function G(e) {
+	return e.SetId = 0, e.Name = "", e.ShapeNames = [], e;
+}
+function Je(e, t) {
+	let n = t ?? qe();
+	return G(n), Ye(e, n), n;
+}
+function Ye(e, t) {
+	let n;
+	for (; (n = e.next()) !== null;) switch (n.fieldId) {
+		case We:
+			if (n.isNull) throw Error();
+			t.Name = n.asString();
+			break;
+		case Ge:
+			if (n.isNull) throw Error();
+			t.SetId = n.asUInt32();
+			break;
+		case Ke:
+			if (n.isNull) throw Error();
+			t.ShapeNames = Xe(n.asArray());
+			break;
+		default: break;
+	}
+}
+function Xe(e) {
+	let t = [], n;
+	for (; (n = e.next()) !== null;) t.push(n.asString());
+	return t;
+}
+var Ze = 8388612;
+function Qe(e) {
+	let t = {};
+	return e && Object.assign(t, e), t;
+}
+function $e(e) {
+	return new S(1).finish();
+}
+function et(e, t, n) {
+	return _(Ze, $e(e), 1, t, n);
+}
+var tt = 8388609, K = 161083277, q = 164808083, nt = 1368629611, rt = 2514959030, it = 2745379226, at = 2950031986, ot = 3282782683, st = 3284746250, ct = 4065070594;
+function lt(e) {
+	let t = {};
+	return ut(t), e && Object.assign(t, e), t;
+}
+function ut(e) {
+	return e.StreamId = "", e.Description = "", e.SourceType = "", e.Codec = B.H264, e.CodecDetails = "", e.Width = 0, e.Height = 0, e.Framerate = 30, e.CorrelationId = void 0, e;
+}
+function dt(e) {
+	let t = new S(6);
+	return ft(e, t), t.finish();
+}
+function ft(e, t) {
+	t.writeStringField(K, e.StreamId), t.writeFloat64Field(q, e.Framerate), t.writeStringField(nt, e.Description);
+	let n = e.CorrelationId;
+	n != null && t.writeStringField(rt, n), t.writeStringField(it, e.CodecDetails), t.writeInt32Field(at, e.Height | 0), t.writeStringField(ot, e.SourceType), t.writeInt32Field(st, e.Codec), t.writeInt32Field(ct, e.Width | 0);
+}
+function pt(e, t) {
+	let n = t ?? lt();
+	return ut(n), mt(e, n), n;
+}
+function mt(e, t) {
+	let n;
+	for (; (n = e.next()) !== null;) switch (n.fieldId) {
+		case K:
+			if (n.isNull) throw Error();
+			t.StreamId = n.asString();
+			break;
+		case q:
+			if (n.isNull) throw Error();
+			t.Framerate = n.asFloat64();
+			break;
+		case nt:
+			if (n.isNull) throw Error();
+			t.Description = n.asString();
+			break;
+		case rt:
+			if (n.isNull) {
+				t.CorrelationId = void 0;
+				break;
+			}
+			t.CorrelationId = n.asString();
+			break;
+		case it:
+			if (n.isNull) throw Error();
+			t.CodecDetails = n.asString();
+			break;
+		case at:
+			if (n.isNull) throw Error();
+			t.Height = n.asInt32();
+			break;
+		case ot:
+			if (n.isNull) throw Error();
+			t.SourceType = n.asString();
+			break;
+		case st:
+			if (n.isNull) throw Error();
+			t.Codec = n.asInt32();
+			break;
+		case ct:
+			if (n.isNull) throw Error();
+			t.Width = n.asInt32();
+			break;
+		default: break;
+	}
+}
+function ht(e, t, n) {
+	return _(tt, dt(e), 6, t, n);
+}
+var gt = 8388610;
+function _t(e) {
+	let t = {};
+	return e && Object.assign(t, e), t;
+}
+function vt(e) {
+	return new S(1).finish();
+}
+function yt(e, t, n) {
+	return _(gt, vt(e), 1, t, n);
+}
+//#endregion
+//#region src/media/media-session-helper.ts
+function bt() {
+	let e = 44100, t = /* @__PURE__ */ new ArrayBuffer(882044), n = new DataView(t), r = (e, t) => {
+		for (let r = 0; r < t.length; r++) n.setUint8(e + r, t.charCodeAt(r));
+	};
+	r(0, "RIFF"), n.setUint32(4, 882036, !0), r(8, "WAVE"), r(12, "fmt "), n.setUint32(16, 16, !0), n.setUint16(20, 1, !0), n.setUint16(22, 1, !0), n.setUint32(24, e, !0), n.setUint32(28, e * 2, !0), n.setUint16(32, 2, !0), n.setUint16(34, 16, !0), r(36, "data"), n.setUint32(40, 441e3 * 2, !0);
+	let i = new Blob([t], { type: "audio/wav" });
+	return URL.createObjectURL(i);
+}
+var xt = class {
+	_silentAudioElement = null;
+	get silentAudioElement() {
+		return this._silentAudioElement;
+	}
+	ensureSilentPlaybackElement() {
+		typeof document > "u" || (this._silentAudioElement || (this._silentAudioElement = document.createElement("audio"), this._silentAudioElement.src = bt(), this._silentAudioElement.loop = !0, this._silentAudioElement.volume = .01), this._silentAudioElement.paused && this._silentAudioElement.play().catch(() => {}));
+	}
+	setup(e, t) {
+		if (!(typeof document > "u") && (this.ensureSilentPlaybackElement(), typeof navigator < "u" && "mediaSession" in navigator)) {
+			let n = e ?? {};
+			navigator.mediaSession.metadata = new MediaMetadata({
+				title: n.title || "Audio",
+				artist: n.artist || "Ikon AI App"
+			}), navigator.mediaSession.playbackState = "playing";
+			try {
+				navigator.mediaSession.setPositionState({
+					duration: 86400,
+					playbackRate: 1,
+					position: 0
+				});
+			} catch {}
+			navigator.mediaSession.setActionHandler("play", () => {
+				t.onPlay(), this._silentAudioElement?.play().catch(() => {}), navigator.mediaSession.playbackState = "playing";
+			}), navigator.mediaSession.setActionHandler("pause", () => {
+				t.onPause(), this._silentAudioElement?.pause(), navigator.mediaSession.playbackState = "paused";
+			});
+		}
+	}
+	cleanup() {
+		if (this._silentAudioElement) try {
+			this._silentAudioElement.pause();
+			let e = this._silentAudioElement.src;
+			this._silentAudioElement.src = "", e.startsWith("blob:") && URL.revokeObjectURL(e), this._silentAudioElement = null;
+		} catch {}
+		if (typeof navigator < "u" && "mediaSession" in navigator) try {
+			navigator.mediaSession.setActionHandler("play", null), navigator.mediaSession.setActionHandler("pause", null);
+		} catch {}
+	}
+};
+//#endregion
+//#region src/worker/audio-playback-worker.ts?worker
+function St(e) {
+	return new Worker("" + new URL("assets/audio-playback-worker-DivBZPfS.js", import.meta.url).href, {
+		type: "module",
+		name: e?.name
+	});
+}
+//#endregion
+//#region src/media/ikon-audio-playback.ts
+var J = t("IkonAudioPlayback"), Ct = {
+	enabled: !1,
+	statusIntervalMs: 1e3
+};
+function Y(e) {
+	return e instanceof Error ? `${e.name}: ${e.message}` : String(e);
+}
+function wt(e) {
+	return `
+// Audio buffer constants
+const OUTPUT_SAMPLE_RATE_HZ = ${e.outputSampleRateHz};
+const DEFAULT_FRAME_SAMPLES_PER_CHANNEL = Math.max(1, Math.round(OUTPUT_SAMPLE_RATE_HZ * 0.02));
+const BUFFER_TARGET_MIN_MS = 120;
+const BUFFER_TARGET_MAX_MS = 300;
+const JITTER_MULTIPLIER = 4;
+const LOCAL_BUFFER_MAX_MS = ${o};
+const CONTROL_PERIOD_MS = 200;
+const UNDERRUN_JUMP_MS = 100;
+const STABLE_TIME_TO_DECREASE_MS = ${a};
+const DECREASE_STEP_MS = 10;
+const DEFAULT_STATS_INTERVAL_SAMPLES = OUTPUT_SAMPLE_RATE_HZ;
+const PLAYBACK_REPORT_INTERVAL_SAMPLES = Math.round(OUTPUT_SAMPLE_RATE_HZ / 2);
+
+// Pre-computed reciprocals for division-free calculations
+const INV_OUTPUT_SAMPLE_RATE_HZ = 1 / OUTPUT_SAMPLE_RATE_HZ;
+const MS_PER_SAMPLE = 1000 * INV_OUTPUT_SAMPLE_RATE_HZ;
+
+// Fade envelope constants
+const FADE_IN_DURATION_MS = 100;
+const FADE_OUT_DURATION_MS = 50;
+const FADE_IN_DURATION_SAMPLES = Math.round(OUTPUT_SAMPLE_RATE_HZ * FADE_IN_DURATION_MS / 1000);
+const FADE_OUT_DURATION_SAMPLES = Math.round(OUTPUT_SAMPLE_RATE_HZ * FADE_OUT_DURATION_MS / 1000);
+const FADE_IN_INCREMENT = 1.0 / FADE_IN_DURATION_SAMPLES;
+const FADE_OUT_INCREMENT = 1.0 / FADE_OUT_DURATION_SAMPLES;
+
+// Render quantum size (standard Web Audio API value)
+const RENDER_QUANTUM_SIZE = 128;
+
+// Buffer reduction crossfade constants (align to quantum boundary to avoid partial quanta)
+const BUFFER_REDUCTION_CROSSFADE_MS = 20;
+const BUFFER_REDUCTION_CROSSFADE_SAMPLES_RAW = Math.round(OUTPUT_SAMPLE_RATE_HZ * BUFFER_REDUCTION_CROSSFADE_MS / 1000);
+const BUFFER_REDUCTION_CROSSFADE_SAMPLES = Math.ceil(BUFFER_REDUCTION_CROSSFADE_SAMPLES_RAW / RENDER_QUANTUM_SIZE) * RENDER_QUANTUM_SIZE;
+
+class RingBuffer {
+  static getStorageForCapacity(capacity, type) {
+    const indexBytes = Int32Array.BYTES_PER_ELEMENT * 2;
+    const dataBytes = type.BYTES_PER_ELEMENT * capacity;
+    return new SharedArrayBuffer(indexBytes + dataBytes);
+  }
+
+  constructor(sharedArrayBuffer, type, channels = 1) {
+    this.buf = sharedArrayBuffer;
+    this.readWrite = new Int32Array(sharedArrayBuffer, 0, 2);
+    const dataOffset = Int32Array.BYTES_PER_ELEMENT * 2;
+    const dataLength = (sharedArrayBuffer.byteLength - dataOffset) / Float32Array.BYTES_PER_ELEMENT;
+    this.storage = new type(sharedArrayBuffer, dataOffset, dataLength);
+    this.channels = channels;
+  }
+
+  get capacity() {
+    return this.storage.length;
+  }
+
+  availableRead() {
+    const read = Atomics.load(this.readWrite, 0);
+    const write = Atomics.load(this.readWrite, 1);
+    if (write >= read) return write - read;
+    return this.capacity - (read - write);
+  }
+
+  pop(target) {
+    const rawReadable = Math.min(this.availableRead(), target.length);
+    const readable = Math.floor(rawReadable / this.channels) * this.channels;
+    if (readable <= 0) {
+      target.fill(0);
+      return 0;
+    }
+
+    let read = Atomics.load(this.readWrite, 0);
+    const firstPart = Math.min(readable, this.capacity - read);
+    for (let i = 0; i < firstPart; i++) {
+      target[i] = this.storage[read + i];
+    }
+    const remaining = readable - firstPart;
+    if (remaining > 0) {
+      for (let i = 0; i < remaining; i++) {
+        target[firstPart + i] = this.storage[i];
+      }
+    }
+    if (readable < target.length) {
+      target.fill(0, readable);
+    }
+    read = (read + readable) % this.capacity;
+    Atomics.store(this.readWrite, 0, read);
+    return readable;
+  }
+
+  skip(count) {
+    const rawReadable = Math.min(this.availableRead(), count);
+    const readable = Math.floor(rawReadable / this.channels) * this.channels;
+    if (readable <= 0) return 0;
+
+    let read = Atomics.load(this.readWrite, 0);
+    read = (read + readable) % this.capacity;
+    Atomics.store(this.readWrite, 0, read);
+    return readable;
+  }
+
+  flush() {
+    Atomics.store(this.readWrite, 0, 0);
+    Atomics.store(this.readWrite, 1, 0);
+  }
+}
+
+// Simple queue buffer for non-SAB fallback
+class QueueBuffer {
+  constructor(maxSamples, channels = 1) {
+    this.chunks = [];
+    this.headIndex = 0;
+    this.offset = 0;
+    this.maxSamples = maxSamples;
+    this.totalSamples = 0;
+    this.channels = channels;
+    this.needsCompaction = false;
+  }
+
+  available() {
+    return this.totalSamples;
+  }
+
+  availableRead() {
+    return this.totalSamples;
+  }
+
+  compact() {
+    if (!this.needsCompaction || this.headIndex === 0) return;
+    const activeCount = this.chunks.length - this.headIndex;
+    for (let i = 0; i < activeCount; i++) {
+      this.chunks[i] = this.chunks[this.headIndex + i];
+    }
+    this.chunks.length = activeCount;
+    this.headIndex = 0;
+    this.needsCompaction = false;
+  }
+
+  push(chunk) {
+    this.chunks.push(chunk);
+    this.totalSamples += chunk.length;
+    if (typeof this.maxSamples === 'number' && this.maxSamples > 0) {
+      if (this.totalSamples > this.maxSamples) {
+        this.skip(this.totalSamples - this.maxSamples);
+      }
+    }
+  }
+
+  pop(target) {
+    if (this.totalSamples <= 0) {
+      target.fill(0);
+      return 0;
+    }
+
+    const rawRequired = Math.min(target.length, this.totalSamples);
+    const required = Math.floor(rawRequired / this.channels) * this.channels;
+    if (required <= 0) {
+      target.fill(0);
+      return 0;
+    }
+
+    let written = 0;
+    while (written < required && this.headIndex < this.chunks.length) {
+      const current = this.chunks[this.headIndex];
+      const available = current.length - this.offset;
+      const toCopy = Math.min(available, required - written);
+      for (let i = 0; i < toCopy; i++) {
+        target[written + i] = current[this.offset + i];
+      }
+      written += toCopy;
+      this.offset += toCopy;
+      this.totalSamples -= toCopy;
+      if (this.offset >= current.length) {
+        this.headIndex += 1;
+        this.offset = 0;
+      }
+    }
+
+    if (written < target.length) {
+      target.fill(0, written);
+    }
+
+    if (this.headIndex > 32 && this.headIndex > this.chunks.length / 2) {
+      this.needsCompaction = true;
+    }
+
+    return written;
+  }
+
+  skip(count) {
+    if (this.totalSamples <= 0 || count <= 0) return 0;
+
+    const alignedCount = Math.floor(count / this.channels) * this.channels;
+    if (alignedCount <= 0) return 0;
+
+    let remaining = alignedCount;
+    while (remaining > 0 && this.headIndex < this.chunks.length) {
+      const current = this.chunks[this.headIndex];
+      const available = current.length - this.offset;
+      if (remaining < available) {
+        this.offset += remaining;
+        this.totalSamples -= remaining;
+        return alignedCount;
+      }
+      remaining -= available;
+      this.totalSamples -= available;
+      this.headIndex += 1;
+      this.offset = 0;
+    }
+
+    if (this.headIndex > 32 && this.headIndex > this.chunks.length / 2) {
+      this.needsCompaction = true;
+    }
+    return alignedCount - remaining;
+  }
+
+  flush() {
+    this.chunks.length = 0;
+    this.headIndex = 0;
+    this.offset = 0;
+    this.totalSamples = 0;
+    this.needsCompaction = false;
+  }
+}
+
+class IkonAudioPlayerProcessor extends AudioWorkletProcessor {
+  constructor(options) {
+    super();
+    const cfg = options?.processorOptions?.outputAudioConfig || {};
+    const outputChannels = options?.processorOptions?.outputChannels;
+    this.channels = typeof outputChannels === 'number' && outputChannels > 0 ? outputChannels : ${e.outputChannels};
+    this.useSharedArrayBuffer = options?.processorOptions?.useSharedArrayBuffer !== false;
+    this.queueMaxSamples = Math.floor((OUTPUT_SAMPLE_RATE_HZ * this.channels * LOCAL_BUFFER_MAX_MS) / 1000);
+    this.suspendedMaxSamples = Math.floor((OUTPUT_SAMPLE_RATE_HZ * this.channels * BUFFER_TARGET_MIN_MS) / 1000);
+    this.isPlaybackActive = false;
+
+    // Diagnostics config
+    const diagCfg = cfg.diagnostics || {};
+    this.diagnosticsEnabled = diagCfg.enabled === true;
+    const statusIntervalMs = typeof diagCfg.statusIntervalMs === 'number' && diagCfg.statusIntervalMs > 0 ? diagCfg.statusIntervalMs : 1000;
+    this.statsIntervalSamples = Math.max(1, Math.round((OUTPUT_SAMPLE_RATE_HZ * statusIntervalMs) / 1000));
+
+    // Normalization config (hardcoded)
+    this.normalizationEnabled = true;
+
+    // Stream states for audio buffer
+    this.streams = new Map();
+    this.ringBuffers = new Map();
+    this.queueBuffers = new Map();
+    this.tempInterleaved = new Float32Array(RENDER_QUANTUM_SIZE * this.channels);
+
+    // Pre-allocated crossfade buffers for buffer reduction (no allocations in render path)
+    const crossfadeSamples = BUFFER_REDUCTION_CROSSFADE_SAMPLES * this.channels;
+    this.crossfadePreSkip = new Float32Array(crossfadeSamples);
+    this.crossfadePostSkip = new Float32Array(crossfadeSamples);
+    this.crossfadeResult = new Float32Array(crossfadeSamples);
+    this.crossfadeOffset = 0;
+    this.crossfadeRemaining = 0;
+
+    // Stats reporting
+    this.samplesSinceLastStats = 0;
+    this.lastControlTime = 0;
+    this.drainedStreamIds = [];
+    this.activeStreamIds = [];
+    this.activeStreams = [];
+    this.activeStreamIdIndices = new Map();
+
+    // Pre-allocated message objects to avoid allocation in hot path
+    this._drainedMsg = { type: 'streamDrained', streamId: '' };
+    this._statsMsg = { type: 'stats', streamId: '', bufferMs: 0, targetMs: 0, state: '', inputDrained: false, jitterMs: 0, underrunCount: 0, dropCount: 0 };
+    this._playbackMsg = { type: 'playback', streamId: '', epoch: 0, playedSeconds: 0, bufferMs: 0 };
+    this.samplesSincePlaybackReport = 0;
+
+    this.port.onmessage = (event) => {
+      const data = event.data;
+      if (!data || typeof data !== 'object') return;
+
+      if (data.type === 'streamBegin') {
+        const streamId = data.streamId;
+        const sab = data.sharedArrayBuffer;
+        const useSab = this.useSharedArrayBuffer && sab;
+
+        let buffer;
+        if (useSab) {
+          buffer = new RingBuffer(sab, Float32Array, this.channels);
+          this.ringBuffers.set(streamId, buffer);
+          this.queueBuffers.delete(streamId);
+        } else {
+          buffer = new QueueBuffer(this.queueMaxSamples, this.channels);
+          this.queueBuffers.set(streamId, buffer);
+          this.ringBuffers.delete(streamId);
+        }
+
+        // Initialize audio buffer stream state
+        const stream = {
+          buffer,
+          state: 'BUFFERING',
+          currentEpoch: -1,
+          streamEnding: false,
+          inputDrained: false,
+          epochSet: false,
+          epochTimestampInterleavedSamples: 0,
+          playoutInterleavedSamples: 0,
+          jitterMs: 0,
+          bufferTargetMs: BUFFER_TARGET_MIN_MS,
+          stableDurationMs: 0,
+          totalUnderrunCount: 0,
+          totalDropCount: 0,
+          frameSamplesPerChannel: DEFAULT_FRAME_SAMPLES_PER_CHANNEL,
+          lastOut: new Float32Array(RENDER_QUANTUM_SIZE * this.channels),
+          hasLastOut: false,
+          transport: useSab ? 'sab' : 'queue',
+          // Fade envelope state
+          fadeGain: 0.0,
+          fadeDirection: 'none',
+          needsFadeIn: true,
+          needsFadeOut: false,
+          underrunPending: false,
+          // Diagnostic logging counter
+          bufferingLogCounter: 0
+        };
+        this.streams.set(streamId, stream);
+        this.activeStreamIdIndices.set(streamId, this.activeStreamIds.length);
+        this.activeStreamIds.push(streamId);
+        this.activeStreams.push(stream);
+        return;
+      }
+
+      if (data.type === 'streamEnd') {
+        const streamId = data.streamId;
+        const stream = this.streams.get(streamId);
+        if (stream) {
+          stream.streamEnding = true;
+        }
+        return;
+      }
+
+      if (data.type === 'pcm') {
+        const q = this.queueBuffers.get(data.streamId);
+        if (!q) return;
+        q.compact();
+        if (data.pcm instanceof Float32Array) {
+          q.push(data.pcm);
+          // Apply buffer limit based on playback state
+          const maxSamples = this.isPlaybackActive ? this.queueMaxSamples : this.suspendedMaxSamples;
+          if (q.totalSamples > maxSamples) {
+            q.skip(q.totalSamples - maxSamples);
+          }
+        }
+        return;
+      }
+
+      if (data.type === 'frame') {
+        const stream = this.streams.get(data.streamId);
+        if (!stream) return;
+
+        const epoch = data.epoch;
+        const timestampInterleavedSamples = data.timestampInterleavedSamples;
+
+        // Epoch change → reset stream state
+        if (stream.currentEpoch !== epoch) {
+          this.port.postMessage({
+            type: 'log',
+            level: 'info',
+            message: 'Epoch change ' + stream.currentEpoch + '->' + epoch + ', bufferTargetMs=' + stream.bufferTargetMs.toFixed(0) + 'ms (not reset)',
+            streamId: data.streamId
+          });
+          stream.currentEpoch = epoch;
+          stream.epochSet = false;
+          stream.playoutInterleavedSamples = 0;
+          stream.streamEnding = false;
+          stream.inputDrained = false;
+          stream.state = 'BUFFERING';
+          stream.frameSamplesPerChannel = DEFAULT_FRAME_SAMPLES_PER_CHANNEL;
+          stream.hasLastOut = false;
+          // Reset fade state for new epoch
+          stream.fadeGain = 0.0;
+          stream.fadeDirection = 'none';
+          stream.needsFadeIn = true;
+          stream.needsFadeOut = false;
+          stream.underrunPending = false;
+
+          const ring = this.ringBuffers.get(data.streamId);
+          if (ring) ring.flush();
+          const q = this.queueBuffers.get(data.streamId);
+          if (q) q.flush();
+        }
+
+        // Establish initial timestamp mapping
+        if (!stream.epochSet) {
+          stream.epochSet = true;
+          stream.epochTimestampInterleavedSamples = timestampInterleavedSamples;
+        }
+
+        // Update jitter estimate
+        stream.jitterMs = data.jitterMs;
+        if (typeof data.frameSizeInterleavedSamples === 'number' && data.frameSizeInterleavedSamples > 0) {
+          stream.frameSamplesPerChannel = Math.max(1, Math.round(data.frameSizeInterleavedSamples / this.channels));
+        }
+
+        // Trigger fade-in if receiving audio on a drained stream (even without isFirst)
+        if (stream.inputDrained && !data.isFirst) {
+          stream.needsFadeIn = true;
+          stream.needsFadeOut = false;
+          stream.fadeGain = 0.0;
+          stream.fadeDirection = 'in';
+          stream.inputDrained = false;
+          stream.underrunPending = false;
+        }
+
+        // Track isFirst/isLast for fade triggers
+        if (data.isFirst) {
+          // New audio segment starting - fade in from silence
+          stream.needsFadeIn = true;
+          stream.needsFadeOut = false;
+          stream.fadeGain = 0.0;
+          stream.fadeDirection = 'in';
+          stream.inputDrained = false;
+          stream.underrunPending = false;
+        }
+        if (data.isLast) {
+          // Audio segment ending - schedule fade out
+          stream.needsFadeOut = true;
+          stream.inputDrained = true;
+          this.port.postMessage({
+            type: 'log',
+            level: 'info',
+            message: 'Received isLast=true, setting inputDrained=true',
+            streamId: data.streamId
+          });
+        }
+
+        // Enforce buffer limit when not actively playing (for SAB mode)
+        if (!this.isPlaybackActive) {
+          const maxSamples = this.suspendedMaxSamples;
+          const ring = this.ringBuffers.get(data.streamId);
+          if (ring) {
+            const available = ring.availableRead();
+            if (available > maxSamples) {
+              ring.skip(available - maxSamples);
+            }
+          }
+        }
+        return;
+      }
+
+      if (data.type === 'playbackActive') {
+        const wasActive = this.isPlaybackActive;
+        this.isPlaybackActive = data.active;
+
+        // When switching to inactive, trim all buffers to suspended limit
+        if (wasActive && !data.active) {
+          const maxSamples = this.suspendedMaxSamples;
+          for (const q of this.queueBuffers.values()) {
+            if (q.totalSamples > maxSamples) {
+              q.skip(q.totalSamples - maxSamples);
+            }
+          }
+          for (const ring of this.ringBuffers.values()) {
+            const available = ring.availableRead();
+            if (available > maxSamples) {
+              ring.skip(available - maxSamples);
+            }
+          }
+        }
+        return;
+      }
+    };
+  }
+
+  availableSamples(stream) {
+    const buf = stream.buffer;
+    return buf ? buf.availableRead() : 0;
+  }
+
+  skipSamples(stream, count) {
+    const buf = stream.buffer;
+    return buf ? buf.skip(count) : 0;
+  }
+
+  readInto(stream, target) {
+    const buf = stream.buffer;
+    if (buf) return buf.pop(target);
+    target.fill(0);
+    return 0;
+  }
+
+  // Crossfade skip for buffer reduction - smoothly skips samples with crossfade to avoid clicks
+  crossfadeSkipSamples(stream, samplesToSkip) {
+    const fadeLen = BUFFER_REDUCTION_CROSSFADE_SAMPLES * this.channels;
+
+    // 1. Read pre-skip tail into pre-allocated buffer
+    const preRead = this.readInto(stream, this.crossfadePreSkip);
+    if (preRead < fadeLen) return 0;
+
+    // 2. Skip the excess (minus crossfade portion)
+    const skipAmount = samplesToSkip - fadeLen;
+    if (skipAmount > 0) {
+      this.skipSamples(stream, skipAmount);
+    }
+
+    // 3. Read post-skip head into pre-allocated buffer
+    const postRead = this.readInto(stream, this.crossfadePostSkip);
+    if (postRead < fadeLen) {
+      // Copy pre-skip to result buffer, output what we have
+      for (let i = 0; i < fadeLen; i++) {
+        this.crossfadeResult[i] = this.crossfadePreSkip[i];
+      }
+      this.crossfadeOffset = 0;
+      this.crossfadeRemaining = postRead > 0 ? fadeLen : 0;
+      return samplesToSkip;
+    }
+
+    // 4. Linear crossfade in-place to pre-allocated result buffer
+    const invFadeLen = 1.0 / fadeLen;
+    for (let i = 0; i < fadeLen; i++) {
+      const t = i * invFadeLen;
+      this.crossfadeResult[i] = this.crossfadePreSkip[i] * (1 - t) + this.crossfadePostSkip[i] * t;
+    }
+
+    this.crossfadeOffset = 0;
+    this.crossfadeRemaining = fadeLen;
+
+    return samplesToSkip;
+  }
+
+  // Returns the minimum safe audio buffer target based on jitter
+  getBufferFloorMs(stream) {
+    return BUFFER_TARGET_MIN_MS + JITTER_MULTIPLIER * stream.jitterMs;
+  }
+
+  // ALL buffer target changes go through this function
+  updateBufferTarget(stream, action) {
+    const floorMs = this.getBufferFloorMs(stream);
+    let target = Math.max(stream.bufferTargetMs, floorMs);
+
+    if (action === 'underrun') {
+      // Simple: every underrun adds a fixed amount
+      target += UNDERRUN_JUMP_MS;
+      stream.stableDurationMs = 0;
+    } else if (action === 'stable-decrease') {
+      // Decrease: gradual, never below floor
+      target = Math.max(floorMs, target - DECREASE_STEP_MS);
+    }
+    // action === 'enforce-floor' just enforces floor, no other changes
+
+    stream.bufferTargetMs = Math.min(BUFFER_TARGET_MAX_MS, target);
+  }
+
+  // Immediate response to underrun - called from process() after fade-out completes
+  handleUnderrun(streamId, stream) {
+    stream.totalUnderrunCount++;
+    stream.state = 'BUFFERING';
+    stream.needsFadeIn = true;
+    stream.underrunPending = false;
+    // Note: fadeGain/fadeDirection not reset here - fade-out has already completed
+    this.updateBufferTarget(stream, 'underrun');
+
+    this.port.postMessage({
+      type: 'log',
+      level: 'warn',
+      message: 'Buffer underrun, count=' + stream.totalUnderrunCount + ', newTarget=' + stream.bufferTargetMs.toFixed(0) + 'ms',
+      streamId
+    });
+  }
+
+  controlTick(streamId, stream, nowMs) {
+    if (!stream.epochSet || stream.state === 'ENDED') return;
+
+    // Always enforce buffer floor
+    this.updateBufferTarget(stream, 'enforce-floor');
+
+    // Stability tracking and gradual decrease (only when playing, not ending)
+    if (stream.state === 'PLAYING' && !stream.streamEnding) {
+      stream.stableDurationMs += CONTROL_PERIOD_MS;
+
+      if (stream.stableDurationMs >= STABLE_TIME_TO_DECREASE_MS) {
+        this.updateBufferTarget(stream, 'stable-decrease');
+        stream.stableDurationMs = 0;
+      }
+    }
+  }
+
+  process(_inputs, outputs) {
+    const output = outputs[0];
+    if (!output || output.length === 0) {
+      return true;
+    }
+
+    const now = currentTime;
+    const nowMs = now * 1000;
+    const outputChannels = output.length;
+    const requestSamples = RENDER_QUANTUM_SIZE * this.channels;
+
+    for (let ch = 0; ch < outputChannels; ch++) {
+      output[ch].fill(0);
+    }
+
+    // Run control loop periodically
+    if (nowMs - this.lastControlTime >= CONTROL_PERIOD_MS) {
+      for (let i = 0; i < this.activeStreamIds.length; i++) {
+        const streamId = this.activeStreamIds[i];
+        const stream = this.activeStreams[i];
+        if (stream) this.controlTick(streamId, stream, nowMs);
+      }
+      this.lastControlTime = nowMs;
+    }
+
+    let activeStreamCount = 0;
+    const drainedStreamIds = this.drainedStreamIds;
+    drainedStreamIds.length = 0;
+
+    for (let i = 0; i < this.activeStreamIds.length; i++) {
+      const streamId = this.activeStreamIds[i];
+      const stream = this.activeStreams[i];
+      if (!stream || stream.state === 'ENDED') {
+        continue;
+      }
+
+      const available = this.availableSamples(stream);
+
+      if (stream.state === 'BUFFERING') {
+        if (stream.streamEnding) {
+          if (available <= 0) {
+            stream.state = 'ENDED';
+            drainedStreamIds.push(streamId);
+            continue;
+          }
+          this.port.postMessage({
+            type: 'log',
+            level: 'info',
+            message: 'BUFFERING->PLAYING (streamEnding)',
+            streamId
+          });
+          stream.state = 'PLAYING';
+        } else {
+          const bufferSamples = available / this.channels;
+          const bufferLevelMs = bufferSamples * MS_PER_SAMPLE;
+          if (bufferLevelMs >= stream.bufferTargetMs) {
+            this.port.postMessage({
+              type: 'log',
+              level: 'info',
+              message: 'BUFFERING->PLAYING, buffer=' + bufferLevelMs.toFixed(0) + 'ms, target=' + stream.bufferTargetMs.toFixed(0) + 'ms',
+              streamId
+            });
+            stream.state = 'PLAYING';
+            stream.bufferingLogCounter = 0;
+            if (stream.needsFadeIn) {
+              stream.fadeDirection = 'in';
+            } else {
+              stream.fadeGain = 1.0;
+            }
+          } else {
+            // Log periodically when stuck in BUFFERING with data available
+            if (available > 0) {
+              stream.bufferingLogCounter = (stream.bufferingLogCounter || 0) + 1;
+              // Log every ~1 second (approximately 43 calls at 128 samples / 48kHz)
+              if (stream.bufferingLogCounter >= 43) {
+                this.port.postMessage({
+                  type: 'log',
+                  level: 'info',
+                  message: 'BUFFERING: buffer=' + bufferLevelMs.toFixed(0) + 'ms, target=' + stream.bufferTargetMs.toFixed(0) + 'ms, waiting...',
+                  streamId
+                });
+                stream.bufferingLogCounter = 0;
+              }
+            }
+            continue;
+          }
+        }
+      }
+
+      // Buffer reduction: if buffer exceeds target max, drain with crossfade
+      // Skip if we're still outputting a previous crossfade
+      const bufferSamplesForReduction = available / this.channels;
+      const bufferLevelMsForReduction = bufferSamplesForReduction * MS_PER_SAMPLE;
+      if (this.crossfadeRemaining <= 0 && bufferLevelMsForReduction > BUFFER_TARGET_MAX_MS && stream.state === 'PLAYING' && !stream.streamEnding) {
+        const excessMs = bufferLevelMsForReduction - BUFFER_TARGET_MAX_MS;
+        const fadeLen = BUFFER_REDUCTION_CROSSFADE_SAMPLES * this.channels;
+        // Need: fadeLen (pre-skip read) + skip amount + fadeLen (post-skip read)
+        // Skip amount must be > fadeLen for crossfade to make sense
+        // Cap at ~2x speed: skip up to 1 quantum worth per render, but at least fadeLen + 1
+        const excessSamples = Math.round((excessMs * OUTPUT_SAMPLE_RATE_HZ * this.channels) / 1000);
+        const samplesToSkip = Math.min(
+          Math.max(fadeLen + RENDER_QUANTUM_SIZE, RENDER_QUANTUM_SIZE * this.channels * 2),
+          excessSamples
+        );
+        // Check we have enough buffer: need fadeLen + samplesToSkip for the operation
+        if (samplesToSkip > fadeLen && available >= fadeLen + samplesToSkip) {
+          this.crossfadeSkipSamples(stream, samplesToSkip);
+          stream.totalDropCount++;
+        }
+      }
+
+      // Output pending crossfade samples first (from processor-level pre-allocated buffer)
+      if (this.crossfadeRemaining > 0) {
+        const framesToOutput = Math.min(Math.floor(this.crossfadeRemaining / this.channels), RENDER_QUANTUM_SIZE);
+        let idx = this.crossfadeOffset;
+        for (let frame = 0; frame < framesToOutput; frame++) {
+          // Update fade envelope during crossfade output (critical for initial unlock scenario)
+          if (stream.fadeDirection === 'in') {
+            stream.fadeGain = Math.min(1.0, stream.fadeGain + FADE_IN_INCREMENT);
+            if (stream.fadeGain >= 1.0) {
+              stream.fadeDirection = 'none';
+              stream.needsFadeIn = false;
+            }
+          } else if (stream.fadeDirection === 'out') {
+            stream.fadeGain = Math.max(0.0, stream.fadeGain - FADE_OUT_INCREMENT);
+            if (stream.fadeGain <= 0.0) {
+              stream.fadeDirection = 'none';
+              stream.needsFadeOut = false;
+            }
+          }
+          for (let ch = 0; ch < this.channels && ch < outputChannels; ch++) {
+            output[ch][frame] += this.crossfadeResult[idx++] * stream.fadeGain;
+          }
+        }
+        this.crossfadeOffset += framesToOutput * this.channels;
+        this.crossfadeRemaining -= framesToOutput * this.channels;
+        // Always continue after crossfade output to avoid overlapping with normal playback
+        activeStreamCount++;
+        continue;
+      }
+
+      const bufferMs = (available / this.channels) * MS_PER_SAMPLE;
+
+      // Start fade-out when buffer is low and isLast was received
+      if (stream.needsFadeOut && stream.fadeDirection !== 'out' && bufferMs <= FADE_OUT_DURATION_MS * 2.0) {
+        stream.fadeDirection = 'out';
+      }
+
+      const countRead = this.readInto(stream, this.tempInterleaved);
+      const framesRead = Math.floor(countRead / this.channels);
+
+      if (countRead >= requestSamples) {
+        stream.lastOut.set(this.tempInterleaved);
+        stream.hasLastOut = true;
+
+        // Apply per-sample fade envelope
+        let sampleIdx = 0;
+        for (let frame = 0; frame < RENDER_QUANTUM_SIZE; frame++) {
+          // Update fade envelope
+          if (stream.fadeDirection === 'in') {
+            stream.fadeGain = Math.min(1.0, stream.fadeGain + FADE_IN_INCREMENT);
+            if (stream.fadeGain >= 1.0) {
+              stream.fadeDirection = 'none';
+              stream.needsFadeIn = false;
+            }
+          } else if (stream.fadeDirection === 'out') {
+            stream.fadeGain = Math.max(0.0, stream.fadeGain - FADE_OUT_INCREMENT);
+            if (stream.fadeGain <= 0.0) {
+              stream.fadeDirection = 'none';
+              stream.needsFadeOut = false;
+            }
+          }
+          for (let ch = 0; ch < this.channels && ch < outputChannels; ch++) {
+            output[ch][frame] += this.tempInterleaved[sampleIdx++] * stream.fadeGain;
+          }
+        }
+        stream.playoutInterleavedSamples += countRead;
+        activeStreamCount++;
+      } else if (countRead > 0) {
+        // Partial data: smooth tail to avoid hard discontinuities
+        const endingOrDrained = stream.streamEnding || stream.inputDrained;
+
+        const holdFrameIndex = Math.max(0, framesRead - 1);
+        const holdBaseIdx = holdFrameIndex * this.channels;
+        let fillIdx = framesRead * this.channels;
+        for (let frame = framesRead; frame < RENDER_QUANTUM_SIZE; frame++) {
+          for (let ch = 0; ch < this.channels; ch++) {
+            this.tempInterleaved[fillIdx++] = this.tempInterleaved[holdBaseIdx + ch];
+          }
+        }
+
+        stream.lastOut.set(this.tempInterleaved);
+        stream.hasLastOut = true;
+
+        // Render valid frames first with the current fade state
+        let sampleIdx = 0;
+        for (let frame = 0; frame < framesRead; frame++) {
+          if (stream.fadeDirection === 'in') {
+            stream.fadeGain = Math.min(1.0, stream.fadeGain + FADE_IN_INCREMENT);
+            if (stream.fadeGain >= 1.0) {
+              stream.fadeDirection = 'none';
+              stream.needsFadeIn = false;
+            }
+          } else if (stream.fadeDirection === 'out') {
+            stream.fadeGain = Math.max(0.0, stream.fadeGain - FADE_OUT_INCREMENT);
+            if (stream.fadeGain <= 0.0) {
+              stream.fadeDirection = 'none';
+              stream.needsFadeOut = false;
+            }
+          }
+          for (let ch = 0; ch < this.channels && ch < outputChannels; ch++) {
+            output[ch][frame] += this.tempInterleaved[sampleIdx++] * stream.fadeGain;
+          }
+        }
+
+        // Tail: force fade-out so the transition remains bounded
+        if (stream.fadeGain > 0.001) {
+          stream.fadeDirection = 'out';
+          sampleIdx = framesRead * this.channels;
+          for (let frame = framesRead; frame < RENDER_QUANTUM_SIZE; frame++) {
+            stream.fadeGain = Math.max(0.0, stream.fadeGain - FADE_OUT_INCREMENT);
+            if (stream.fadeGain <= 0.0) {
+              stream.fadeDirection = 'none';
+              stream.needsFadeOut = false;
+            }
+            for (let ch = 0; ch < this.channels && ch < outputChannels; ch++) {
+              output[ch][frame] += this.tempInterleaved[sampleIdx++] * stream.fadeGain;
+            }
+          }
+        }
+
+        stream.playoutInterleavedSamples += countRead;
+
+        if (endingOrDrained) {
+          if (stream.fadeGain <= 0.001 && stream.streamEnding) {
+            stream.state = 'ENDED';
+            drainedStreamIds.push(streamId);
+          }
+        } else {
+          // Mark underrun pending - will transition to BUFFERING after fade-out completes
+          stream.underrunPending = true;
+          if (stream.fadeGain <= 0.001) {
+            this.handleUnderrun(streamId, stream);
+          }
+        }
+        activeStreamCount++;
+      } else {
+        // No data available
+        const endingOrDrained = stream.streamEnding || stream.inputDrained;
+
+        if (stream.hasLastOut && stream.fadeGain > 0.001) {
+          // Continue fade-out using sample-hold from lastOut
+          stream.fadeDirection = 'out';
+          if (!endingOrDrained) {
+            stream.underrunPending = true;
+          }
+          // Hold the LAST sample constant (not cycling through the buffer)
+          const holdBaseIdx = (RENDER_QUANTUM_SIZE - 1) * this.channels;
+          for (let frame = 0; frame < RENDER_QUANTUM_SIZE; frame++) {
+            stream.fadeGain = Math.max(0.0, stream.fadeGain - FADE_OUT_INCREMENT);
+            if (stream.fadeGain <= 0.0) {
+              stream.fadeDirection = 'none';
+              stream.needsFadeOut = false;
+            }
+            for (let ch = 0; ch < this.channels && ch < outputChannels; ch++) {
+              output[ch][frame] += stream.lastOut[holdBaseIdx + ch] * stream.fadeGain;
+            }
+          }
+        } else if (endingOrDrained && stream.fadeDirection === 'out' && stream.fadeGain > 0.001) {
+          for (let frame = 0; frame < RENDER_QUANTUM_SIZE; frame++) {
+            stream.fadeGain = Math.max(0.0, stream.fadeGain - FADE_OUT_INCREMENT);
+            if (stream.fadeGain <= 0.001) {
+              stream.fadeGain = 0;
+              stream.fadeDirection = 'none';
+              stream.needsFadeOut = false;
+              break;
+            }
+          }
+        }
+
+        if (endingOrDrained) {
+          if (stream.fadeGain <= 0.001) {
+            if (stream.streamEnding) {
+              stream.state = 'ENDED';
+              drainedStreamIds.push(streamId);
+            } else if (stream.inputDrained) {
+              this.port.postMessage({
+                type: 'log',
+                level: 'info',
+                message: 'PLAYING->BUFFERING (inputDrained), bufferTargetMs=' + stream.bufferTargetMs.toFixed(0) + 'ms',
+                streamId
+              });
+              stream.state = 'BUFFERING';
+              stream.needsFadeIn = true;
+            }
+          }
+        } else if (stream.underrunPending && stream.fadeGain <= 0.001) {
+          // Fade-out complete, now transition to BUFFERING
+          this.handleUnderrun(streamId, stream);
+        } else if (!stream.underrunPending && !stream.hasLastOut) {
+          // No lastOut to fade from, immediate underrun
+          stream.underrunPending = true;
+          this.handleUnderrun(streamId, stream);
+        }
+      }
+    }
+
+    // Cleanup drained streams
+    if (drainedStreamIds.length > 0) {
+      for (let i = 0; i < drainedStreamIds.length; i++) {
+        const streamId = drainedStreamIds[i];
+        // Remove from activeStreamIds/activeStreams using O(1) index lookup + swap-remove
+        const idx = this.activeStreamIdIndices.get(streamId);
+        if (idx !== undefined) {
+          const lastIdx = this.activeStreamIds.length - 1;
+          if (idx !== lastIdx) {
+            const lastStreamId = this.activeStreamIds[lastIdx];
+            this.activeStreamIds[idx] = lastStreamId;
+            this.activeStreams[idx] = this.activeStreams[lastIdx];
+            this.activeStreamIdIndices.set(lastStreamId, idx);
+          }
+          this.activeStreamIds.length--;
+          this.activeStreams.length--;
+          this.activeStreamIdIndices.delete(streamId);
+        }
+        this.ringBuffers.delete(streamId);
+        this.queueBuffers.delete(streamId);
+        this.streams.delete(streamId);
+        try {
+          this._drainedMsg.streamId = streamId;
+          this.port.postMessage(this._drainedMsg);
+        } catch {
+          // ignore
+        }
+      }
+    }
+
+    // Combined normalization + soft clipping (single pass)
+    const needsNormalization = this.normalizationEnabled && activeStreamCount > 1;
+    const normFactor = needsNormalization ? 1.0 / Math.sqrt(activeStreamCount) : 1.0;
+    for (let frame = 0; frame < RENDER_QUANTUM_SIZE; frame++) {
+      for (let ch = 0; ch < outputChannels; ch++) {
+        let v = output[ch][frame];
+        if (needsNormalization) {
+          v *= normFactor;
+        }
+        // NaN check: v !== v is true only for NaN; clipping handles ±Infinity
+        if (v !== v) v = 0;
+        output[ch][frame] = v > 1 ? 1 : v < -1 ? -1 : v;
+      }
+    }
+
+    // Periodic playback-position reports (always on — feeds client->server audibility
+    // reporting, which apps use to pace speech to what listeners actually heard)
+    this.samplesSincePlaybackReport += RENDER_QUANTUM_SIZE;
+    if (this.samplesSincePlaybackReport >= PLAYBACK_REPORT_INTERVAL_SAMPLES) {
+      this.samplesSincePlaybackReport = 0;
+
+      for (let i = 0; i < this.activeStreamIds.length; i++) {
+        const stream = this.activeStreams[i];
+        if (!stream || !stream.epochSet) continue;
+
+        this._playbackMsg.streamId = this.activeStreamIds[i];
+        this._playbackMsg.epoch = stream.currentEpoch;
+        this._playbackMsg.playedSeconds = stream.playoutInterleavedSamples / (OUTPUT_SAMPLE_RATE_HZ * this.channels);
+        this._playbackMsg.bufferMs = (this.availableSamples(stream) / this.channels) * MS_PER_SAMPLE;
+        this.port.postMessage(this._playbackMsg);
+      }
+    }
+
+    // Stats reporting
+    if (!this.diagnosticsEnabled) {
+      return true;
+    }
+
+    this.samplesSinceLastStats += RENDER_QUANTUM_SIZE;
+    if (this.samplesSinceLastStats >= this.statsIntervalSamples) {
+      this.samplesSinceLastStats = 0;
+
+      for (let i = 0; i < this.activeStreamIds.length; i++) {
+        const streamId = this.activeStreamIds[i];
+        const stream = this.activeStreams[i];
+        if (!stream) continue;
+        const bufferSamples = this.availableSamples(stream) / this.channels;
+        const bufferMs = bufferSamples * MS_PER_SAMPLE;
+
+        this._statsMsg.streamId = streamId;
+        this._statsMsg.bufferMs = bufferMs;
+        this._statsMsg.targetMs = stream.bufferTargetMs;
+        this._statsMsg.state = stream.state;
+        this._statsMsg.inputDrained = stream.inputDrained;
+        this._statsMsg.jitterMs = stream.jitterMs;
+        this._statsMsg.underrunCount = stream.totalUnderrunCount;
+        this._statsMsg.dropCount = stream.totalDropCount;
+        this.port.postMessage(this._statsMsg);
+      }
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('ikon-audio-player', IkonAudioPlayerProcessor);
+`;
+}
+var Tt = class t {
+	client;
+	config;
+	enabled = !1;
+	stateUnsubscribe = null;
+	isMobile = c();
+	boundVisibilityChange = null;
+	boundPageHide = null;
+	unlockHandler = null;
+	awaitingUnlock = !1;
+	recoveryTask = null;
+	static RESUME_TIMEOUT_MS = 100;
+	static MAX_WORKER_REBUILD_ATTEMPTS = 3;
+	workerRebuildAttempts = 0;
+	audioContext = null;
+	outputSampleRateHz = e;
+	audioWorkletNode = null;
+	scriptProcessorNode = null;
+	scriptDiagnosticsTimer = null;
+	workletModuleUrl = null;
+	workletModuleKey = null;
+	workletReady = null;
+	pendingWorkletMessages = [];
+	audioWorker = null;
+	protocolPort = null;
+	mediaSessionHelper = new xt();
+	hiddenMuted = !1;
+	lastReportedPlaybackState = null;
+	lastPlaybackByStream = /* @__PURE__ */ new Map();
+	fallbackQueues = /* @__PURE__ */ new Map();
+	activeStreams = /* @__PURE__ */ new Set();
+	mediaSessionConfig = null;
+	constructor(e, t) {
+		this.client = e, this.config = t ?? {}, J.debug(`Audio playback initialized, isMobile=${this.isMobile}`);
+	}
+	setMediaSession(e) {
+		this.mediaSessionConfig = e;
+	}
+	async setEnabled(e, t) {
+		if (e && t?.userGesture && this.audioContext) try {
+			await this.resumeWithTimeout(this.audioContext), this.audioContext.state === "running" && this.removeUnlockHandler();
+		} catch {}
+		if (e === this.enabled) {
+			e && (await this.ensureAudioGraph(t, { promptForUnlock: !0 }), await this.ensureWorkers());
+			return;
+		}
+		if (this.enabled = e, this.ensureStateSubscription(), !e) {
+			this.stopAudioGraph(), this.stopWorkers();
+			return;
+		}
+		await this.ensureAudioGraph(t, { promptForUnlock: !0 }), await this.ensureWorkers();
+	}
+	enable(e) {
+		return this.setEnabled(!0, e);
+	}
+	disable() {
+		return this.setEnabled(!1);
+	}
+	pause() {
+		if (this.audioContext) {
+			this.notifyPlaybackActive(!1);
+			try {
+				this.audioWorkletNode && this.audioWorkletNode.disconnect(), this.scriptProcessorNode && this.scriptProcessorNode.disconnect();
+			} catch {}
+		}
+	}
+	resume() {
+		if (!this.audioContext) return;
+		try {
+			this.audioWorkletNode && this.audioWorkletNode.connect(this.audioContext.destination), this.scriptProcessorNode && this.scriptProcessorNode.connect(this.audioContext.destination);
+		} catch {}
+		let e = this.getContextState(this.audioContext) === "running";
+		this.notifyPlaybackActive(e);
+	}
+	requestRecovery() {
+		if (this.enabled && r() && this.audioContext) {
+			this.stopAudioGraph();
+			try {
+				let t = new AudioContext({
+					sampleRate: e,
+					latencyHint: n
+				});
+				this.audioContext = t, this.outputSampleRateHz = t.sampleRate, t.resume().catch(() => void 0), this.setupAudioGraphAfterRecreate();
+			} catch (e) {
+				J.error(`iOS audio recovery failed: ${Y(e)}`), this.addUnlockHandler();
+			}
+			return;
+		}
+	}
+	async setupAudioGraphAfterRecreate() {
+		if (!this.audioContext) return;
+		let e = this.audioContext, t = this.resolveDiagnosticsConfig();
+		try {
+			await this.ensureAudioWorklet(e, t, void 0, { promptForUnlock: !1 });
+		} catch {
+			this.ensureScriptProcessor(e, t);
+		}
+	}
+	syncStreamsFromGlobalState(e) {
+		if (!this.audioWorker) return;
+		let t = Object.values(e.AudioStreams ?? {}).map((e) => ({
+			senderId: e.ClientSessionId,
+			trackId: e.TrackId,
+			info: e.Info
+		}));
+		if (t.length !== 0) try {
+			this.audioWorker.postMessage({
+				type: "syncStreams",
+				streams: t
+			});
+		} catch {}
+	}
+	setWebRtcActive(e) {
+		if (this.audioWorker) try {
+			this.audioWorker.postMessage({
+				type: "setWebRtcEnabled",
+				enabled: e
+			});
+		} catch {}
+	}
+	handleProtocolTransportLost() {
+		this.audioWorker && this.stopWorkers();
+	}
+	dispose() {
+		this.enabled = !1, this.activeStreams.clear(), this.removeUnlockHandler(), this.removeVisibilityHandler(), this.stateUnsubscribe?.(), this.stateUnsubscribe = null, this.stopAudioGraph(), this.stopWorkers();
+	}
+	resolveDiagnosticsConfig() {
+		let e = this.config.diagnostics ?? {};
+		return {
+			enabled: e.enabled ?? Ct.enabled,
+			statusIntervalMs: e.statusIntervalMs ?? Ct.statusIntervalMs
+		};
+	}
+	resolveBackgroundConfig() {
+		let e = this.config.background ?? {};
+		return {
+			allowOnDesktop: e.allowOnDesktop ?? !0,
+			allowOnMobile: e.allowOnMobile ?? !1
+		};
+	}
+	async ensureAudioGraph(t, i) {
+		if (typeof window > "u") return;
+		if (!this.audioContext) {
+			let t = e, r = n;
+			try {
+				this.audioContext = new AudioContext({
+					sampleRate: t,
+					latencyHint: r
+				});
+			} catch (e) {
+				try {
+					this.audioContext = new AudioContext({ latencyHint: r });
+				} catch (e) {
+					try {
+						this.audioContext = new AudioContext();
+					} catch (e) {
+						J.warn(`Failed to create AudioContext: ${Y(e)}`), this.audioContext = null;
+						return;
+					}
+					J.debug(`AudioContext latencyHint unsupported: ${Y(e)}`);
+				}
+				J.debug(`AudioContext sample rate request unsupported: ${Y(e)}`);
+			}
+			this.outputSampleRateHz = this.audioContext.sampleRate || 48e3, this.outputSampleRateHz !== t && J.debug(`AudioContext running at ${this.outputSampleRateHz}Hz (requested ${t}Hz)`), this.attachAudioContextHealthHandlers(this.audioContext);
+		}
+		r() && this.mediaSessionHelper.ensureSilentPlaybackElement();
+		let a = this.audioContext, o = this.resolveDiagnosticsConfig();
+		if ((this.config.performance?.preferAudioWorklet ?? !0) && s(a)) {
+			await this.ensureAudioWorklet(a, o, t, i);
+			return;
+		}
+		this.ensureScriptProcessor(a, o), await this.resumeAudioContextIfPossible(a, t, i), this.rebindWorkerTransportIfNeeded();
+	}
+	attachAudioContextHealthHandlers(e) {
+		e.__ikonAudioHealthAttached !== !0 && (Object.defineProperty(e, "__ikonAudioHealthAttached", {
+			value: !0,
+			enumerable: !1
+		}), e.onstatechange = () => {
+			let t = this.getContextState(e), n = t === "running";
+			this.notifyPlaybackActive(n), this.enabled && !n && (J.warn(`AudioContext state changed to '${t}', attempting recovery`), this.recoverAudioContext({ reason: "statechange" }));
+		}, this.attachVisibilityHandler());
+	}
+	attachVisibilityHandler() {
+		if (this.boundVisibilityChange || typeof document > "u") return;
+		let e = this.resolveBackgroundConfig(), t = this.isMobile ? e.allowOnMobile : e.allowOnDesktop;
+		t && this.setupMediaSession();
+		let n = () => {
+			if (!(!this.enabled || !this.audioContext || t)) {
+				this.hiddenMuted = !0, this.notifyPlaybackActive(!1);
+				try {
+					this.audioWorkletNode && this.audioWorkletNode.disconnect(), this.scriptProcessorNode && this.scriptProcessorNode.disconnect();
+				} catch {}
+			}
+		}, r = () => {
+			if (!this.enabled || !this.audioContext) return;
+			this.hiddenMuted = !1;
+			try {
+				this.audioWorkletNode && this.audioWorkletNode.connect(this.audioContext.destination), this.scriptProcessorNode && this.scriptProcessorNode.connect(this.audioContext.destination);
+			} catch {}
+			let e = this.getContextState(this.audioContext) === "running";
+			this.notifyPlaybackActive(e);
+		}, i = () => {
+			if (this.enabled) {
+				if (document.visibilityState === "visible") {
+					r(), this.audioContext && this.getContextState(this.audioContext) !== "running" && this.recoverAudioContext({ reason: "visibilityVisible" });
+					return;
+				}
+				n();
+			}
+		}, a = () => {
+			n();
+		};
+		this.boundVisibilityChange = i, this.boundPageHide = a, document.addEventListener("visibilitychange", i), t || window.addEventListener("pagehide", a);
+	}
+	setupMediaSession() {
+		this.mediaSessionHelper.setup(this.mediaSessionConfig ?? void 0, {
+			onPlay: () => this.resume(),
+			onPause: () => this.pause()
+		});
+	}
+	cleanupMediaSession() {
+		this.mediaSessionHelper.cleanup();
+	}
+	removeVisibilityHandler() {
+		typeof document < "u" && this.boundVisibilityChange && document.removeEventListener("visibilitychange", this.boundVisibilityChange), typeof window < "u" && this.boundPageHide && (window.removeEventListener("pagehide", this.boundPageHide), window.removeEventListener("blur", this.boundPageHide)), this.boundVisibilityChange = null, this.boundPageHide = null, this.cleanupMediaSession();
+	}
+	getContextState(e) {
+		return e?.state ?? "suspended";
+	}
+	addUnlockHandler() {
+		if (this.enabled && !this.awaitingUnlock && !(typeof document > "u")) {
+			this.awaitingUnlock = !0, this.unlockHandler = () => {
+				let e = this.audioContext;
+				if (e && this.getContextState(e) !== "running") try {
+					e.resume().catch(() => void 0);
+				} catch {}
+				let t = this.mediaSessionHelper.silentAudioElement;
+				if (t && t.paused) try {
+					t.play().catch(() => void 0);
+				} catch {}
+				if ((e ? this.getContextState(e) : "suspended") === "running") {
+					this.removeUnlockHandler();
+					return;
+				}
+				this.recoveryTask || this.recoverAudioContext({
+					reason: "gesture",
+					fromUserGesture: !0
+				}).finally(() => {
+					let e = this.audioContext;
+					e && this.getContextState(e) === "running" && this.removeUnlockHandler();
+				});
+			};
+			for (let e of [
+				"touchstart",
+				"touchend",
+				"click",
+				"pointerdown",
+				"pointerup",
+				"keydown",
+				"mouseup"
+			]) document.addEventListener(e, this.unlockHandler, { capture: !0 });
+		}
+	}
+	removeUnlockHandler() {
+		if (!this.unlockHandler) {
+			this.awaitingUnlock = !1;
+			return;
+		}
+		if (typeof document < "u") for (let e of [
+			"touchstart",
+			"touchend",
+			"click",
+			"pointerdown",
+			"pointerup",
+			"keydown",
+			"mouseup"
+		]) document.removeEventListener(e, this.unlockHandler, { capture: !0 });
+		this.unlockHandler = null, this.awaitingUnlock = !1, this.reportPlaybackStateIfChanged();
+	}
+	async resumeWithTimeout(e) {
+		let n = e.resume(), r = new Promise((e, n) => {
+			setTimeout(() => n(/* @__PURE__ */ Error("AudioContext.resume() timed out")), t.RESUME_TIMEOUT_MS);
+		});
+		await Promise.race([n, r]);
+	}
+	async ensureAudioWorklet(e, t, n, r) {
+		if (this.audioWorkletNode) {
+			await this.resumeAudioContextIfPossible(e, n, r);
+			return;
+		}
+		if (n?.userGesture && this.getContextState(e) !== "running") try {
+			await this.resumeWithTimeout(e), this.getContextState(e) === "running" && this.removeUnlockHandler();
+		} catch {}
+		let a = `${this.outputSampleRateHz}_2`;
+		if (!this.workletModuleUrl || this.workletModuleKey !== a) {
+			if (this.workletModuleUrl) try {
+				URL.revokeObjectURL(this.workletModuleUrl);
+			} catch {}
+			this.workletModuleKey = a, this.workletReady = null, this.workletModuleUrl = URL.createObjectURL(new Blob([wt({
+				outputSampleRateHz: this.outputSampleRateHz,
+				outputChannels: 2
+			})], { type: "text/javascript" }));
+		}
+		this.workletReady ||= e.audioWorklet.addModule(this.workletModuleUrl).catch((e) => {
+			throw J.warn(`Failed to load AudioWorklet module, falling back: ${Y(e)}`), e;
+		});
+		try {
+			await this.workletReady;
+		} catch {
+			this.workletReady = null, this.ensureScriptProcessor(e, t);
+			return;
+		}
+		this.stopScriptProcessor();
+		let o = (this.config.performance?.preferSharedArrayBuffer ?? !0) && i();
+		this.audioWorkletNode = new AudioWorkletNode(e, "ikon-audio-player", {
+			numberOfInputs: 0,
+			numberOfOutputs: 1,
+			outputChannelCount: [2],
+			processorOptions: {
+				outputAudioConfig: { diagnostics: t },
+				useSharedArrayBuffer: o,
+				outputChannels: 2
+			}
+		}), this.audioWorkletNode.onprocessorerror = () => {
+			J.error("Audio playback worklet processor crashed, rebuilding audio pipeline"), this.stopAudioWorklet(), this.setupAudioGraphAfterRecreate();
+		}, this.audioWorkletNode.port.onmessage = (e) => {
+			let n = e.data;
+			if (!(!n || typeof n != "object")) {
+				if (n.type === "log") {
+					let e = n, t = e.streamId ? ` [stream=${e.streamId.substring(0, 8)}]` : "";
+					e.level === "error" ? J.error(`[Worklet]${t} ${e.message}`) : e.level === "warn" ? J.warn(`[Worklet]${t} ${e.message}`) : J.info(`[Worklet]${t} ${e.message}`);
+					return;
+				}
+				if (n.type === "stats") {
+					if (!t.enabled) return;
+					let e = n;
+					J.debug(`[Audio] stream=${e.streamId.substring(0, 8)} state=${e.state} buffer=${e.bufferMs.toFixed(0)}ms target=${e.targetMs.toFixed(0)}ms jitter=${e.jitterMs.toFixed(1)}ms underrun=${e.underrunCount} drop=${e.dropCount}`);
+					return;
+				}
+				if (n.type === "playback") {
+					let e = n;
+					this.lastPlaybackByStream.set(e.streamId, {
+						epoch: e.epoch,
+						playedSeconds: e.playedSeconds,
+						bufferMs: e.bufferMs
+					}), this.sendPlaybackReport(e.streamId, e.epoch, e.playedSeconds, e.bufferMs);
+					return;
+				}
+				if (n.type === "streamDrained" && "streamId" in n && typeof n.streamId == "string") {
+					let e = n.streamId;
+					this.activeStreams.delete(e), this.lastPlaybackByStream.delete(e), this.activeStreams.size === 0 && this.removeUnlockHandler();
+					return;
+				}
+			}
+		}, this.audioWorkletNode.connect(e.destination), this.stopScriptProcessorDiagnostics(), await this.resumeAudioContextIfPossible(e, n, r), this.rebindWorkerTransportIfNeeded();
+		let s = this.pendingWorkletMessages.splice(0);
+		for (let e of s) this.postToWorklet(e);
+		let c = this.getContextState(e) === "running";
+		this.notifyPlaybackActive(c);
+	}
+	ensureScriptProcessor(e, t) {
+		if (this.scriptProcessorNode) return;
+		this.stopAudioWorklet(), this.pendingWorkletMessages = [];
+		let n = 1024, r = new Float32Array(n * 2), i = Math.round(this.outputSampleRateHz * 100 / 1e3), a = Math.round(this.outputSampleRateHz * 50 / 1e3), o = 1 / i, s = 1 / a, c = [, ,], l = [], u = e.createScriptProcessor(n, 0, 2);
+		u.onaudioprocess = (e) => {
+			let t = e.outputBuffer, n = t.numberOfChannels, i = t.length;
+			for (let e = 0; e < n; e++) {
+				let n = t.getChannelData(e);
+				n.fill(0), c[e] = n;
+			}
+			let a = 0;
+			l.length = 0;
+			for (let [e, t] of this.fallbackQueues.entries()) {
+				t.totalSamples > 0 && (a += 1), (t.ending || t.inputDrained) && t.fadeDirection !== "out" && t.totalSamples / n * 1e3 / this.outputSampleRateHz <= 100 && (t.fadeDirection = "out"), this.readFromFallbackQueue(t, r), (t.totalSamples > 0 || !t.hasLastOut) && ((!t.lastOut || t.lastOut.length !== r.length) && (t.lastOut = new Float32Array(r.length)), t.lastOut.set(r), t.hasLastOut = !0);
+				for (let e = 0; e < i; e++) {
+					t.fadeDirection === "in" ? (t.fadeGain = Math.min(1, t.fadeGain + o), t.fadeGain >= 1 && (t.fadeDirection = "none")) : t.fadeDirection === "out" && (t.fadeGain = Math.max(0, t.fadeGain - s), t.fadeGain <= 0 && (t.fadeDirection = "none"));
+					for (let i = 0; i < n; i++) {
+						let a = r[e * n + i];
+						c[i][e] += a * t.fadeGain;
+					}
+				}
+				let u = t.ending || t.inputDrained;
+				if (u && t.totalSamples <= 0) {
+					if (t.fadeDirection === "out" && t.fadeGain > .001) {
+						for (let e = 0; e < i; e++) if (t.fadeGain = Math.max(0, t.fadeGain - s), t.fadeGain <= .001) {
+							t.fadeGain = 0, t.fadeDirection = "none";
+							break;
+						}
+					}
+					t.fadeGain <= .001 && t.ending && l.push(e);
+				} else if (!u && t.totalSamples <= 0 && t.hasLastOut && t.lastOut && t.fadeGain > .001) {
+					t.fadeDirection = "out", t.underrunPending = !0;
+					let e = t.lastOut, r = i - 1;
+					for (let a = 0; a < i; a++) {
+						t.fadeGain = Math.max(0, t.fadeGain - s), t.fadeGain <= 0 && (t.fadeDirection = "none");
+						for (let i = 0; i < n; i++) {
+							let o = e[r * n + i];
+							c[i][a] += o * t.fadeGain;
+						}
+					}
+				}
+			}
+			if (l.length > 0) {
+				for (let e of l) this.fallbackQueues.delete(e), this.activeStreams.delete(e);
+				this.activeStreams.size === 0 && this.removeUnlockHandler();
+			}
+			if (a > 1) {
+				let e = 1 / Math.sqrt(a);
+				for (let t = 0; t < i; t++) for (let r = 0; r < n; r++) c[r][t] *= e;
+			}
+			for (let e = 0; e < i; e++) for (let t = 0; t < n; t++) {
+				let n = c[t][e];
+				c[t][e] = n > 1 ? 1 : n < -1 ? -1 : n;
+			}
+		}, u.connect(e.destination), this.scriptProcessorNode = u, this.ensureScriptProcessorDiagnostics(t);
+	}
+	compactFallbackQueue(e) {
+		if (e.headIndex <= 32 || e.headIndex <= e.chunks.length / 2) return;
+		let t = e.chunks.length - e.headIndex;
+		for (let n = 0; n < t; n++) e.chunks[n] = e.chunks[e.headIndex + n];
+		e.chunks.length = t, e.headIndex = 0;
+	}
+	skipFromFallbackQueue(e, t) {
+		if (t <= 0) return;
+		let n = t;
+		for (; n > 0 && e.headIndex < e.chunks.length;) {
+			let t = e.chunks[e.headIndex], r = t.length - e.offset, i = Math.min(r, n);
+			e.offset += i, e.totalSamples -= i, n -= i, e.offset >= t.length && (e.headIndex += 1, e.offset = 0);
+		}
+		e.totalSamples < 0 && (e.totalSamples = 0), this.compactFallbackQueue(e);
+	}
+	trimFallbackQueue(e) {
+		let t = Math.floor(this.outputSampleRateHz * 2 * o / 1e3), n = e.totalSamples - t;
+		n <= 0 || this.skipFromFallbackQueue(e, n);
+	}
+	stopScriptProcessorDiagnostics() {
+		this.scriptDiagnosticsTimer &&= (clearInterval(this.scriptDiagnosticsTimer), null);
+	}
+	ensureScriptProcessorDiagnostics(e) {
+		if (!e.enabled) {
+			this.stopScriptProcessorDiagnostics();
+			return;
+		}
+		if (this.scriptDiagnosticsTimer) return;
+		let t = Math.max(250, e.statusIntervalMs);
+		this.scriptDiagnosticsTimer = setInterval(() => {
+			if (this.scriptProcessorNode) for (let [e, t] of this.fallbackQueues.entries()) {
+				if (t.totalSamples <= 0) continue;
+				let n = t.totalSamples / 2 * 1e3 / this.outputSampleRateHz;
+				J.debug(`[Audio] stream=${e.substring(0, 8)} buffer=${n.toFixed(0)}ms renderer=ScriptProcessor`);
+			}
+		}, t);
+	}
+	readFromFallbackQueue(e, t) {
+		let n = 0;
+		for (; n < t.length && e.headIndex < e.chunks.length;) {
+			let r = e.chunks[e.headIndex], i = r.length - e.offset, a = Math.min(i, t.length - n);
+			t.set(r.subarray(e.offset, e.offset + a), n), n += a, e.offset += a, e.totalSamples = Math.max(0, e.totalSamples - a), e.offset >= r.length && (e.headIndex += 1, e.offset = 0);
+		}
+		n < t.length && t.fill(0, n), this.compactFallbackQueue(e);
+	}
+	async resumeAudioContextIfPossible(e, t, n) {
+		if (this.getContextState(e) === "running") {
+			this.removeUnlockHandler();
+			return;
+		}
+		let r = n?.promptForUnlock ?? !0;
+		if (!(t?.userGesture ?? !1)) {
+			if (!r) return;
+			this.addUnlockHandler();
+			return;
+		}
+		try {
+			await this.resumeWithTimeout(e), this.removeUnlockHandler();
+		} catch (e) {
+			J.warn(`Failed to resume AudioContext: ${Y(e)}`), this.addUnlockHandler();
+		}
+	}
+	async recoverAudioContext(e) {
+		if (e.fromUserGesture && this.recoveryTask && this.audioContext) try {
+			if (await this.resumeWithTimeout(this.audioContext), this.audioContext.state === "running") {
+				this.removeUnlockHandler();
+				return;
+			}
+		} catch {}
+		if (this.recoveryTask) {
+			await this.recoveryTask;
+			return;
+		}
+		this.recoveryTask = this.recoverAudioContextInternal(e).finally(() => {
+			this.recoveryTask = null;
+		}), await this.recoveryTask;
+	}
+	async recoverAudioContextInternal(e) {
+		if (!this.enabled) return;
+		let t = this.activeStreams.size > 0, n = this.audioContext;
+		if (!n) {
+			if (!t) return;
+			await this.ensureAudioGraph(void 0, { promptForUnlock: !0 });
+			return;
+		}
+		if (n.sampleRate !== this.outputSampleRateHz) {
+			J.warn(`AudioContext sample rate drifted (${n.sampleRate} Hz vs worklet ${this.outputSampleRateHz} Hz), rebuilding audio graph`), this.stopAudioGraph(), t && await this.ensureAudioGraph(void 0, { promptForUnlock: !0 });
+			return;
+		}
+		if (this.getContextState(n) === "running") {
+			this.removeUnlockHandler();
+			return;
+		}
+		if (t) {
+			try {
+				if (await this.resumeWithTimeout(n), this.getContextState(n) === "running") {
+					this.removeUnlockHandler();
+					return;
+				}
+			} catch (t) {
+				J.debug(`AudioContext resume failed or timed out (${e.reason}): ${t}`);
+			}
+			this.addUnlockHandler();
+		}
+	}
+	rebindWorkerTransportIfNeeded() {
+		if (!this.audioWorker || !this.audioContext) return;
+		let e = (this.config.performance?.preferSharedArrayBuffer ?? !0) && this.audioWorkletNode && i() ? "sab" : "pcm";
+		try {
+			this.audioWorker.postMessage({
+				type: "rebind",
+				transport: e,
+				outputSampleRate: this.outputSampleRateHz,
+				outputChannels: 2
+			});
+		} catch {}
+	}
+	async ensureWorkers() {
+		if (this.audioWorker) return;
+		if (typeof Worker > "u") {
+			J.warn("Audio decode worker unavailable (Workers not supported)");
+			return;
+		}
+		let e = this.client.createProtocolMessagePort({ opcodeGroupsMask: l.GROUP_AUDIO });
+		if (!e) return;
+		this.protocolPort = e;
+		try {
+			this.audioWorker = new St();
+		} catch (e) {
+			J.warn(`Failed to create audio worker: ${Y(e)}`), this.protocolPort.close(), this.protocolPort = null;
+			return;
+		}
+		let t = this.audioWorker;
+		t.addEventListener("message", (e) => this.onAudioWorkerMessage(e.data)), t.addEventListener("error", (e) => {
+			let t = [
+				e.message,
+				e.filename,
+				e.lineno,
+				e.colno
+			].filter((e) => e != null && String(e).length > 0);
+			J.error(`Audio worker failed: ${t.join(" ")}`.trim()), this.handleWorkerCrash();
+		});
+		let n = (this.config.performance?.preferSharedArrayBuffer ?? !0) && !!this.audioWorkletNode && i(), r = this.config.performance?.preferWebCodecs ?? !0, a = this.client.isWebRtcMediaActive, o = {
+			type: "configure",
+			transport: n ? "sab" : "pcm",
+			outputSampleRate: this.outputSampleRateHz,
+			outputChannels: 2,
+			preferWebCodecs: r,
+			webRtcEnabled: a
+		};
+		t.postMessage(o), t.postMessage({
+			type: "attachProtocolPort",
+			port: e.port
+		}, [e.port]);
+		let s = this.client.globalState;
+		s && this.syncStreamsFromGlobalState(s);
+		let c = this.audioWorkletNode ? "AudioWorklet" : "ScriptProcessor", u = n ? "SharedArrayBuffer" : "MessagePort", d = a ? "WebRTC (native)" : r && typeof AudioDecoder < "u" ? "WebCodecs" : "WASM Opus";
+		J.debug(`Audio initialized: renderer=${c}, transport=${u}, decoder=${d}, output=${this.outputSampleRateHz}Hz/2ch`);
+	}
+	onAudioWorkerMessage(e) {
+		if (e.type === "streamBegin") {
+			this.activeStreams.add(e.streamId);
+			let t = this.audioContext;
+			if (this.enabled && t && this.getContextState(t) !== "running" && this.recoverAudioContext({ reason: "streamBegin" }), this.audioWorkletNode) {
+				this.postToWorklet({
+					type: "streamBegin",
+					streamId: e.streamId,
+					sharedArrayBuffer: e.sharedArrayBuffer
+				});
+				return;
+			}
+			this.fallbackQueues.set(e.streamId, {
+				chunks: [],
+				headIndex: 0,
+				offset: 0,
+				totalSamples: 0,
+				ending: !1,
+				inputDrained: !1,
+				fadeGain: 0,
+				fadeDirection: "in",
+				lastOut: null,
+				hasLastOut: !1,
+				underrunPending: !1
+			});
+			return;
+		}
+		if (e.type === "streamEnd") {
+			let t = this.fallbackQueues.get(e.streamId);
+			if (t) {
+				t.ending = !0, t.totalSamples <= 0 && (this.fallbackQueues.delete(e.streamId), this.activeStreams.delete(e.streamId), this.activeStreams.size === 0 && this.removeUnlockHandler());
+				return;
+			}
+			if (this.audioWorkletNode) {
+				this.postToWorklet({
+					type: "streamEnd",
+					streamId: e.streamId
+				});
+				return;
+			}
+			this.activeStreams.delete(e.streamId), this.activeStreams.size === 0 && this.removeUnlockHandler();
+			return;
+		}
+		if (e.type === "pcm") {
+			if (this.audioWorkletNode) {
+				this.postToWorklet({
+					type: "pcm",
+					streamId: e.streamId,
+					pcm: e.pcm
+				}, [e.pcm.buffer]);
+				return;
+			}
+			let t = this.fallbackQueues.get(e.streamId);
+			t && (t.underrunPending && t.totalSamples === 0 && (t.fadeGain = 0, t.fadeDirection = "in", t.underrunPending = !1), t.chunks.push(e.pcm), t.totalSamples += e.pcm.length, this.trimFallbackQueue(t));
+			return;
+		}
+		if (e.type === "frame") {
+			let t = this.fallbackQueues.get(e.streamId);
+			t && (t.inputDrained && !e.isFirst && (t.inputDrained = !1, t.fadeGain = 0, t.fadeDirection = "in", t.underrunPending = !1), e.isFirst && (t.inputDrained = !1, t.fadeGain = 0, t.fadeDirection = "in", t.underrunPending = !1), e.isLast && (t.inputDrained = !0)), this.postToWorklet({
+				type: "frame",
+				streamId: e.streamId,
+				epoch: e.epoch,
+				timestampInterleavedSamples: e.timestampInterleavedSamples,
+				frameSizeInterleavedSamples: e.frameSizeInterleavedSamples,
+				isFirst: e.isFirst,
+				isLast: e.isLast,
+				jitterMs: e.jitterMs
+			});
+			return;
+		}
+		e.type === "error" && J.warn(`Audio worker error${e.streamId ? ` (stream ${e.streamId})` : ""}: ${e.error.message}`);
+	}
+	postToWorklet(e, t) {
+		if (!this.audioWorkletNode) {
+			if (this.scriptProcessorNode) return;
+			this.enqueuePendingWorkletMessage(e);
+			return;
+		}
+		try {
+			this.audioWorkletNode.port.postMessage(e, t ?? []);
+		} catch {
+			this.enqueuePendingWorkletMessage(e);
+		}
+	}
+	notifyPlaybackActive(e) {
+		this.postToWorklet({
+			type: "playbackActive",
+			active: e
+		}), this.reportPlaybackStateIfChanged();
+	}
+	computePlaybackState() {
+		let e = this.audioContext;
+		return !e || this.getContextState(e) !== "running" || this.awaitingUnlock ? z.Blocked : this.hiddenMuted ? z.Hidden : z.Playing;
+	}
+	sendPlaybackReport(e, t, n, r) {
+		let i = e.indexOf("_");
+		if (i <= 0) return;
+		let a = Number(e.substring(0, i)), o = Number(e.substring(i + 1));
+		if (!Number.isFinite(a) || !Number.isFinite(o)) return;
+		let s = this.computePlaybackState();
+		this.lastReportedPlaybackState = s;
+		try {
+			let e = V({
+				Epoch: t,
+				PlayedSeconds: n,
+				BufferedMs: r,
+				State: s
+			});
+			this.client.sendProtocolMessage(H(e, this.client.sessionId ?? 0, {
+				trackId: o,
+				targetIds: [a]
+			}));
+		} catch {}
+	}
+	reportPlaybackStateIfChanged() {
+		let e = this.computePlaybackState();
+		if (e !== this.lastReportedPlaybackState) {
+			for (let [e, t] of this.lastPlaybackByStream) this.sendPlaybackReport(e, t.epoch, t.playedSeconds, t.bufferMs);
+			this.lastReportedPlaybackState = e;
+		}
+	}
+	enqueuePendingWorkletMessage(e) {
+		if (e.type === "streamBegin") {
+			let t = this.pendingWorkletMessages.findIndex((t) => t.type === "streamBegin" && t.streamId === e.streamId);
+			t >= 0 && this.pendingWorkletMessages.splice(t, 1);
+		}
+		if (this.pendingWorkletMessages.push(e), !(this.pendingWorkletMessages.length <= 512)) for (; !(this.pendingWorkletMessages.length <= 512);) {
+			let e = this.pendingWorkletMessages.findIndex((e) => e.type !== "streamBegin");
+			if (e < 0) break;
+			this.pendingWorkletMessages.splice(e, 1);
+		}
+	}
+	stopAudioWorklet() {
+		if (this.audioWorkletNode) {
+			try {
+				this.audioWorkletNode.disconnect();
+			} catch {}
+			this.audioWorkletNode = null;
+		}
+	}
+	stopScriptProcessor() {
+		if (this.scriptProcessorNode) {
+			try {
+				this.scriptProcessorNode.disconnect();
+			} catch {}
+			this.scriptProcessorNode.onaudioprocess = null, this.scriptProcessorNode = null;
+		}
+		this.stopScriptProcessorDiagnostics();
+	}
+	stopAudioGraph() {
+		if (this.stopAudioWorklet(), this.stopScriptProcessor(), this.fallbackQueues.clear(), this.audioContext &&= (this.audioContext.close().catch(() => void 0), null), this.workletModuleUrl) {
+			try {
+				URL.revokeObjectURL(this.workletModuleUrl);
+			} catch {}
+			this.workletModuleUrl = null, this.workletModuleKey = null;
+		}
+		this.workletReady = null, this.pendingWorkletMessages = [];
+	}
+	handleWorkerCrash() {
+		if (this.stopWorkers(), this.workerRebuildAttempts >= t.MAX_WORKER_REBUILD_ATTEMPTS) {
+			J.error("Audio worker crashed repeatedly, giving up on rebuilds");
+			return;
+		}
+		this.workerRebuildAttempts++, this.ensureWorkers().then(() => {
+			let e = this.client.globalState;
+			e && this.syncStreamsFromGlobalState(e);
+		});
+	}
+	stopWorkers() {
+		let e = Array.from(this.activeStreams);
+		if (this.audioWorker) {
+			try {
+				this.audioWorker.postMessage({ type: "dispose" });
+			} catch {}
+			try {
+				this.audioWorker.terminate();
+			} catch {}
+			this.audioWorker = null;
+		}
+		if (this.protocolPort &&= (this.protocolPort.close(), null), this.audioWorkletNode) for (let t of e) this.postToWorklet({
+			type: "streamEnd",
+			streamId: t
+		});
+		this.activeStreams.clear(), this.fallbackQueues.clear(), this.removeUnlockHandler();
+	}
+	ensureStateSubscription() {
+		this.stateUnsubscribe ||= this.client.subscribeToState((e) => {
+			if (this.enabled) {
+				if (e === "connected" || e === "reconnecting") {
+					this.ensureWorkers();
+					return;
+				}
+				(e === "idle" || e === "offline" || e === "offlineError" || e === "connecting" || e === "connectingSlow") && this.stopWorkers();
+			}
+		});
+	}
+};
+//#endregion
+//#region src/worker/video-playback-worker.ts?worker
+function Et(e) {
+	return new Worker("" + new URL("assets/video-playback-worker-tC5nUVnw.js", import.meta.url).href, {
+		type: "module",
+		name: e?.name
+	});
+}
+//#endregion
+//#region src/media/ikon-video-playback.ts
+var X = t("IkonVideoPlayback");
+function Z(e) {
+	return e instanceof Error ? `${e.name}: ${e.message}` : String(e);
+}
+var Q = class e {
+	static MAX_WORKER_REBUILD_ATTEMPTS = 3;
+	client;
+	config;
+	enabled = !0;
+	workerRebuildAttempts = 0;
+	stateUnsubscribe = null;
+	worker = null;
+	protocolPort = null;
+	surfaces = /* @__PURE__ */ new Map();
+	constructor(e, t) {
+		this.client = e, this.config = t ?? {}, this.ensureStateSubscription();
+	}
+	async attachCanvas(e, t) {
+		if (!e || typeof e != "string") throw Error("streamId is required");
+		this.detachCanvas(e);
+		let n = this.canUseOffscreenCanvas(t) ? "offscreen" : "bitmap", r = null, i = null;
+		if (n === "bitmap" && (i = t.getContext("bitmaprenderer", { alpha: !1 }), i || (r = t.getContext("2d", {
+			alpha: !1,
+			desynchronized: !0
+		}))), this.surfaces.set(e, {
+			canvas: t,
+			ctx2d: r,
+			ctxBitmap: i,
+			mode: n,
+			attachedToWorker: !1
+		}), this.ensureStateSubscription(), !this.enabled) {
+			X.warn(`Canvas for stream ${e} not attached to the worker: video playback is disabled`);
+			return;
+		}
+		await this.ensureWorker(), this.ensureProtocolPort(), this.syncStreamToWorker(e), this.surfaces.get(e)?.attachedToWorker || X.warn(`Canvas for stream ${e} did not reach the worker; it will stay blank`);
+	}
+	detachCanvas(e) {
+		let t = this.surfaces.get(e);
+		if (t && (this.surfaces.delete(e), this.worker)) try {
+			this.worker.postMessage({
+				type: "unwatchStream",
+				streamId: e
+			}), t.mode === "offscreen" && this.worker.postMessage({
+				type: "detachSurface",
+				streamId: e
+			});
+		} catch {}
+	}
+	async setEnabled(e) {
+		if (this.enabled = e, this.ensureStateSubscription(), !e) {
+			if (this.worker) try {
+				this.worker.postMessage({
+					type: "setEnabled",
+					enabled: !1
+				});
+			} catch {}
+			this.detachProtocolPort();
+			return;
+		}
+		if (await this.ensureWorker(), this.ensureProtocolPort(), this.worker) {
+			try {
+				this.worker.postMessage({
+					type: "setEnabled",
+					enabled: !0
+				});
+			} catch {}
+			this.syncAllStreamsToWorker();
+		}
+	}
+	dispose() {
+		this.enabled = !1, this.stateUnsubscribe?.(), this.stateUnsubscribe = null, this.surfaces.clear(), this.stopWorker();
+	}
+	canUseOffscreenCanvas(e) {
+		return this.config.performance?.preferOffscreenCanvas ?? !0 ? "transferControlToOffscreen" in e && typeof e.transferControlToOffscreen == "function" : !1;
+	}
+	async ensureWorker() {
+		if (!this.enabled || this.worker) return;
+		if (typeof Worker > "u") {
+			X.warn("Video decode worker unavailable (Workers not supported)");
+			return;
+		}
+		let e;
+		try {
+			e = new Et();
+		} catch (e) {
+			X.warn(`Failed to create video worker: ${Z(e)}`);
+			return;
+		}
+		this.worker = e, e.addEventListener("message", (e) => this.onWorkerMessage(e.data)), e.addEventListener("error", (e) => {
+			let t = [
+				e.message,
+				e.filename,
+				e.lineno,
+				e.colno
+			].filter((e) => e != null && String(e).length > 0);
+			X.error(`Video worker failed: ${t.join(" ")}`.trim()), this.handleWorkerCrash();
+		}), e.postMessage({
+			type: "configure",
+			webRtcEnabled: this.client.isWebRtcMediaActive
+		}), e.postMessage({
+			type: "setEnabled",
+			enabled: this.enabled
+		}), this.syncAllStreamsToWorker();
+		let t = this.client.globalState;
+		t && this.syncStreamsFromGlobalState(t);
+	}
+	onWorkerMessage(e) {
+		if (e.type !== "streamBegin" && e.type !== "streamEnd") {
+			if (e.type === "frame") {
+				let t = this.surfaces.get(e.streamId);
+				if (!t || t.mode !== "bitmap") {
+					try {
+						e.bitmap.close();
+					} catch {}
+					return;
+				}
+				if (t.ctxBitmap) {
+					try {
+						t.ctxBitmap.transferFromImageBitmap(e.bitmap);
+					} catch {}
+					return;
+				}
+				if (!t.ctx2d) {
+					try {
+						e.bitmap.close();
+					} catch {}
+					return;
+				}
+				(t.canvas.width !== e.width || t.canvas.height !== e.height) && (t.canvas.width = e.width, t.canvas.height = e.height);
+				try {
+					t.ctx2d.drawImage(e.bitmap, 0, 0, e.width, e.height);
+				} finally {
+					try {
+						e.bitmap.close();
+					} catch {}
+				}
+				return;
+			}
+			if (e.type === "requestIdr") {
+				this.requestIdrForStream(e.senderId, e.trackId);
+				return;
+			}
+			if (e.type === "error") {
+				X.warn(`Video worker error: ${e.error.message}`);
+				return;
+			}
+			e.type === "log" ? X.info(e.message) : e.type === "debug" && X.debug(e.message);
+		}
+	}
+	syncAllStreamsToWorker() {
+		for (let e of this.surfaces.keys()) this.syncStreamToWorker(e);
+	}
+	syncStreamToWorker(e) {
+		if (!this.worker) return;
+		let t = this.surfaces.get(e);
+		if (t && !t.attachedToWorker) {
+			if (t.mode === "offscreen") {
+				try {
+					let n = t.canvas.transferControlToOffscreen();
+					this.worker.postMessage({
+						type: "attachSurface",
+						streamId: e,
+						canvas: n
+					}, [n]), t.attachedToWorker = !0;
+				} catch (n) {
+					X.warn(`Failed to attach offscreen canvas for stream ${e}: ${Z(n)}`), t.mode = "bitmap", t.ctxBitmap = t.canvas.getContext("bitmaprenderer", { alpha: !1 }), t.ctxBitmap || (t.ctx2d = t.canvas.getContext("2d", {
+						alpha: !1,
+						desynchronized: !0
+					}));
+					try {
+						this.worker.postMessage({
+							type: "watchStream",
+							streamId: e
+						}), t.attachedToWorker = !0;
+					} catch {}
+				}
+				return;
+			}
+			try {
+				this.worker.postMessage({
+					type: "watchStream",
+					streamId: e
+				}), t.attachedToWorker = !0;
+			} catch {}
+		}
+	}
+	requestIdrForStream(e, t) {
+		let n = et(Qe(), this.client.sessionId ?? 0, {
+			trackId: t,
+			targetIds: [e]
+		});
+		this.client.sendProtocolMessage(n);
+	}
+	detachProtocolPort() {
+		if (this.protocolPort) {
+			try {
+				this.protocolPort.close();
+			} catch {}
+			this.protocolPort = null;
+		}
+	}
+	ensureProtocolPort() {
+		if (!this.worker || this.protocolPort) return;
+		let e = this.client.createProtocolMessagePort({ opcodeGroupsMask: l.GROUP_VIDEO });
+		if (e) {
+			this.protocolPort = e;
+			try {
+				this.worker.postMessage({
+					type: "attachProtocolPort",
+					port: e.port
+				}, [e.port]);
+			} catch (e) {
+				X.warn(`Failed to attach video protocol port: ${Z(e)}`), this.protocolPort.close(), this.protocolPort = null;
+			}
+		}
+	}
+	syncStreamsFromGlobalState(e) {
+		if (!this.worker) return;
+		let t = Object.values(e.VideoStreams ?? {}).map((e) => ({
+			senderId: e.ClientSessionId,
+			trackId: e.TrackId,
+			info: e.Info
+		}));
+		if (t.length !== 0) try {
+			this.worker.postMessage({
+				type: "syncStreams",
+				streams: t
+			});
+		} catch {}
+	}
+	setWebRtcActive(e) {
+		if (this.worker) try {
+			this.worker.postMessage({
+				type: "setWebRtcEnabled",
+				enabled: e
+			});
+		} catch {}
+	}
+	handleProtocolTransportLost() {
+		this.worker && this.stopWorker();
+	}
+	handleWorkerCrash() {
+		if (this.stopWorker(), this.workerRebuildAttempts >= e.MAX_WORKER_REBUILD_ATTEMPTS) {
+			X.error("Video worker crashed repeatedly, giving up on rebuilds");
+			return;
+		}
+		this.workerRebuildAttempts++, this.ensureWorker().then(() => this.ensureProtocolPort());
+	}
+	stopWorker() {
+		if (this.detachProtocolPort(), this.worker) {
+			try {
+				this.worker.postMessage({ type: "dispose" });
+			} catch {}
+			try {
+				this.worker.terminate();
+			} catch {}
+			this.worker = null;
+		}
+	}
+	ensureStateSubscription() {
+		this.stateUnsubscribe ||= this.client.subscribeToState((e) => {
+			if (this.enabled) {
+				if (e === "connected" || e === "reconnecting") {
+					this.ensureWorker().then(() => this.ensureProtocolPort());
+					return;
+				}
+				(e === "idle" || e === "offline" || e === "offlineError" || e === "connecting" || e === "connectingSlow") && this.detachProtocolPort();
+			}
+		});
+	}
+}, Dt = /* @__PURE__ */ d({ IkonMedia: () => $ }), $ = class {
+	audio;
+	video;
+	constructor(e, t) {
+		this.audio = new Tt(e, t?.audio), this.video = new Q(e, t?.video), t?.mediaSession && this.audio.setMediaSession(t.mediaSession);
+	}
+	dispose() {
+		this.audio.dispose(), this.video.dispose();
+	}
+};
+//#endregion
+export { v as A, Ce as C, D, B as E, g as F, ee as I, te as L, _ as M, m as N, w as O, h as P, d as R, Se as S, xe as T, ge as _, xt as a, ve as b, pt as c, V as d, U as f, he as g, z as h, Tt as i, p as j, S as k, ht as l, H as m, Dt as n, lt as o, Ve as p, Q as r, _t as s, $ as t, yt as u, _e as v, be as w, ye as x, pe as y };