@ikonai/sdk 1.10.0 → 1.11.0

package/channel-manager-ehgy3BJp.js

@@ -0,0 +1,878 @@
+import { C as e, S as t, _ as n, a as r, b as i, m as a, x as o, y as s } from "./log-type-DewKVFaU.js";
+import { c, n as l } from "./logger-gjegmH6K.js";
+import { $ as u, I as d, J as f, ct as p, et as m, n as h, t as g, tt as _ } from "./web-transport-support-Cdyk4mQe.js";
+var v = 131074;
+function y(e) {
+	let t = {};
+	return e && Object.assign(t, e), t;
+}
+function b(e) {
+	return new n(1).finish();
+}
+function x(e, t, n) {
+	let r = b(e);
+	return i(v, r, 1, t, n);
+}
+//#endregion
+//#region src/transport/keepalive-watchdog.ts
+var S = l("KeepaliveWatchdog"), C = class {
+	timeoutMs;
+	what;
+	onTimeout;
+	timeout = null;
+	lastResetAt = 0;
+	constructor(e, t, n) {
+		this.timeoutMs = e, this.what = t, this.onTimeout = n;
+	}
+	reset() {
+		this.clear(), this.lastResetAt = Date.now(), !(this.timeoutMs <= 0) && (this.timeout = setTimeout(() => {
+			S.error(`No keepalive received in ${this.timeoutMs}ms, closing ${this.what}`), this.fire(this.timeoutMs);
+		}, this.timeoutMs));
+	}
+	checkNow() {
+		if (this.timeout === null || this.timeoutMs <= 0) return;
+		let e = Date.now() - this.lastResetAt;
+		e > this.timeoutMs && (S.error(`Keepalive cadence missed while the page was suspended (last received ${e}ms ago, limit ${this.timeoutMs}ms), closing ${this.what}`), this.fire(this.timeoutMs));
+	}
+	checkWithin(e) {
+		if (this.lastResetAt === 0 || e <= 0) return;
+		let t = this.timeoutMs > 0 ? Math.min(e, this.timeoutMs) : e, n = Date.now() - this.lastResetAt;
+		if (n >= t) {
+			S.error(`No keepalive in ${n}ms against a ${t}ms budget, closing ${this.what}`), this.fire(t);
+			return;
+		}
+		this.clear(), this.timeout = setTimeout(() => {
+			S.error(`No keepalive received within the ${t}ms budget, closing ${this.what}`), this.fire(t);
+		}, t - n);
+	}
+	clear() {
+		this.timeout &&= (clearTimeout(this.timeout), null);
+	}
+	fire(e) {
+		this.clear(), this.onTimeout(new u(e));
+	}
+}, w = 4, T = 65536, E = class {
+	buffer = new Uint8Array(T);
+	bufferOffset = 0;
+	bufferLength = 0;
+	dataView = null;
+	dataViewBuffer = null;
+	push(e, t) {
+		this.append(e);
+		let n = this.getDataView();
+		for (; this.bufferLength >= w;) {
+			let e = n.getUint32(this.bufferOffset, !0);
+			if (e < w || e > 20971520) throw this.reset(), Error(`Invalid protocol message length: ${e}`);
+			if (this.bufferLength < e) return;
+			let r = this.buffer.subarray(this.bufferOffset, this.bufferOffset + e);
+			this.bufferOffset += e, this.bufferLength -= e, t(r);
+		}
+		this.bufferLength === 0 && (this.bufferOffset = 0);
+	}
+	reset() {
+		this.bufferOffset = 0, this.bufferLength = 0;
+	}
+	append(e) {
+		let t = this.bufferLength + e.length, n = this.bufferOffset + this.bufferLength;
+		if (n + e.length > this.buffer.length) {
+			if (t > this.buffer.length) {
+				let e = Math.max(t, this.buffer.length * 2), r = new Uint8Array(e);
+				r.set(this.buffer.subarray(this.bufferOffset, n)), this.buffer = r, this.bufferOffset = 0, this.dataViewBuffer = null;
+			} else this.buffer.copyWithin(0, this.bufferOffset, n), this.bufferOffset = 0;
+		}
+		this.buffer.set(e, this.bufferOffset + this.bufferLength), this.bufferLength += e.length;
+	}
+	getDataView() {
+		let e = this.buffer.buffer;
+		return this.dataViewBuffer !== e && (this.dataViewBuffer = e, this.dataView = new DataView(e)), this.dataView;
+	}
+}, D = l("HttpStreamTransport"), O = 1e4, k = 3500, A = 1048576, j = 16, M = [
+	"binary",
+	"sse",
+	"poll"
+], N = class {
+	framer = new E();
+	callbacks;
+	sessionId;
+	keepaliveTimeoutMs;
+	connectionTimeoutMs;
+	pinnedMode;
+	preferredMode;
+	baseUri = "";
+	sid = "";
+	mode = "binary";
+	downstreamAbort = null;
+	keepalive = null;
+	keepaliveResponseMessage = null;
+	isClosed = !1;
+	connected = !1;
+	connecting = !1;
+	sendQueue = [];
+	sendPumpRunning = !1;
+	firstMessageResolver = null;
+	constructor(e) {
+		this.callbacks = e.callbacks, this.sessionId = e.sessionId, this.keepaliveTimeoutMs = e.keepaliveTimeoutMs, this.connectionTimeoutMs = e.connectionTimeoutMs ?? O, this.pinnedMode = e.httpStreamMode, this.preferredMode = e.httpStreamPreferredMode;
+	}
+	get isConnected() {
+		return this.connected && !this.isClosed;
+	}
+	get activeMode() {
+		return this.mode;
+	}
+	async connect(e, t) {
+		this.isClosed = !1, this.connecting = !0, this.baseUri = e;
+		let n = Date.now(), r = null, i = this.pinnedMode ? [this.pinnedMode] : P(this.preferredMode);
+		for (let e of i) {
+			if (this.isClosed) throw new p("HTTP stream closed while connecting");
+			try {
+				this.sid = I(), await this.openMode(t, e), this.mode = e, this.connected = !0, this.connecting = !1, this.resetKeepaliveTimeout(), D.debug(`HTTP stream connected in ${e} mode in ${Date.now() - n}ms`);
+				return;
+			} catch (t) {
+				if (r = t instanceof Error ? t : Error(String(t)), this.abortDownstream(), t instanceof f) throw this.connecting = !1, t;
+				D.debug(`HTTP stream ${e} mode failed after ${Date.now() - n}ms: ${r.message}`);
+			}
+		}
+		throw this.connecting = !1, new p(`HTTP stream failed in every mode: ${r?.message ?? "unknown error"}`, r ?? void 0);
+	}
+	send(e) {
+		if (this.isClosed) {
+			D.warn("Cannot send: HTTP stream closed");
+			return;
+		}
+		this.sendQueue.push(e), this.runSendPump();
+	}
+	close() {
+		this.isClosed = !0, this.connected = !1, this.clearKeepaliveTimeout(), this.abortDownstream(), this.sendQueue.length = 0;
+	}
+	async openMode(e, t) {
+		let n = new AbortController();
+		this.downstreamAbort = n;
+		let r = Math.min(k, this.connectionTimeoutMs), i = setTimeout(() => n.abort(), r);
+		try {
+			await this.openChannel(e, t, n.signal), await this.openDownstream(t, n, r);
+		} finally {
+			clearTimeout(i);
+		}
+	}
+	async openChannel(e, t, n) {
+		let r;
+		try {
+			r = await fetch(this.openUrl(t), {
+				method: "POST",
+				headers: { "Content-Type": "text/plain" },
+				body: L(e),
+				cache: "no-store",
+				credentials: "omit",
+				signal: n
+			});
+		} catch (e) {
+			throw n.aborted ? new p("HTTP stream channel did not open before the mode deadline") : e;
+		}
+		if (r.status === 401 || r.status === 403) throw new f(`HTTP stream rejected the auth ticket (${r.status})`);
+		if (!r.ok) throw new p(`HTTP stream could not be opened, status ${r.status}`);
+	}
+	async openDownstream(e, t, n) {
+		this.framer.reset();
+		let r = new Promise((e, r) => {
+			let i = () => {
+				this.firstMessageResolver = null, r(new p(`No server message in ${n}ms`));
+			};
+			t.signal.addEventListener("abort", i, { once: !0 }), this.firstMessageResolver = () => {
+				t.signal.removeEventListener("abort", i), this.firstMessageResolver = null, e();
+			};
+		}), i = await fetch(this.streamUrl(e), {
+			method: "GET",
+			headers: { Accept: e === "sse" ? "text/event-stream" : "application/octet-stream" },
+			cache: "no-store",
+			credentials: "omit",
+			signal: t.signal
+		});
+		if (i.status === 401 || i.status === 403) throw new f(`HTTP stream rejected the auth ticket (${i.status})`);
+		if (!i.ok || !i.body) throw new p(`HTTP stream request failed with status ${i.status}`);
+		this.runDownstreamLoop(e, i, t), await r;
+	}
+	async runDownstreamLoop(e, t, n) {
+		let r = t;
+		try {
+			for (; r && !this.isClosed && !n.signal.aborted;) {
+				if (await this.readResponse(e, r), e !== "poll") {
+					this.isClosed || this.handleClose("HTTP stream ended", !1);
+					return;
+				}
+				if (r = await fetch(this.streamUrl(e), {
+					method: "GET",
+					headers: { Accept: "application/octet-stream" },
+					cache: "no-store",
+					credentials: "omit",
+					signal: n.signal
+				}), r.status === 410) {
+					this.handleClose("HTTP stream channel is gone", !1);
+					return;
+				}
+				if (!r.ok || !r.body) {
+					this.handleClose(`HTTP stream poll failed with status ${r.status}`, !1);
+					return;
+				}
+			}
+		} catch (e) {
+			if (n.signal.aborted || this.isClosed) return;
+			D.debug(`HTTP stream read loop ended: ${e instanceof Error ? e.message : e}`), this.handleClose("HTTP stream read failed", !1);
+		}
+	}
+	async readResponse(e, t) {
+		let n = t.body.getReader(), r = e === "sse" ? new F() : null;
+		for (;;) {
+			let { value: e, done: t } = await n.read();
+			if (t) return;
+			if (e) {
+				if (r) {
+					r.push(e, (e) => this.framer.push(e, (e) => this.handleProtocolMessage(e)));
+					continue;
+				}
+				this.framer.push(e, (e) => this.handleProtocolMessage(e));
+			}
+		}
+	}
+	async runSendPump() {
+		if (!this.sendPumpRunning) {
+			this.sendPumpRunning = !0;
+			try {
+				for (; this.sendQueue.length > 0 && !this.isClosed;) {
+					let e = this.takeBatch(), t = await fetch(this.sendUrl(), {
+						method: "POST",
+						headers: { "Content-Type": "text/plain" },
+						body: e,
+						cache: "no-store",
+						credentials: "omit"
+					});
+					if (t.status === 410) {
+						this.handleClose("HTTP stream channel is gone", !1);
+						return;
+					}
+					if (!t.ok) throw new p(`HTTP stream send failed with status ${t.status}`);
+				}
+			} catch (e) {
+				if (this.isClosed) return;
+				D.warn(`HTTP stream send failed: ${e instanceof Error ? e.message : e}`), this.handleClose("HTTP stream send failed", !1);
+			} finally {
+				this.sendPumpRunning = !1;
+			}
+		}
+	}
+	takeBatch() {
+		let e = 0, t = 0;
+		for (; t < this.sendQueue.length;) {
+			let n = this.sendQueue[t].length;
+			if (t > 0 && e + n > A) break;
+			e += n, t++;
+		}
+		let n = new Uint8Array(e), r = 0;
+		for (let e = 0; e < t; e++) n.set(this.sendQueue[e], r), r += this.sendQueue[e].length;
+		return this.sendQueue.splice(0, t), n;
+	}
+	streamUrl(e) {
+		return `${this.baseUri}${this.baseUri.includes("?") ? "&" : "?"}sid=${this.sid}&mode=${e}`;
+	}
+	openUrl(e) {
+		return `${this.streamUrl(e)}&open=1`;
+	}
+	sendUrl() {
+		return `${this.baseUri}${this.baseUri.includes("?") ? "&" : "?"}sid=${this.sid}`;
+	}
+	getKeepaliveResponse() {
+		return this.keepaliveResponseMessage ||= x(y(), this.sessionId), this.keepaliveResponseMessage;
+	}
+	handleProtocolMessage(t) {
+		try {
+			let n = e(t).opcode;
+			if (this.firstMessageResolver && this.firstMessageResolver(), n === c.KEEPALIVE_REQUEST) {
+				this.send(this.getKeepaliveResponse()), this.resetKeepaliveTimeout();
+				return;
+			}
+			this.resetKeepaliveTimeout(), this.callbacks.onProtocolMessage(t.slice());
+		} catch (e) {
+			D.error("Failed to process protocol message:", e), this.callbacks.onError(e instanceof Error ? e : Error(String(e)));
+		}
+	}
+	handleClose(e, t) {
+		this.isClosed || this.connecting || (this.isClosed = !0, this.connected = !1, this.clearKeepaliveTimeout(), this.abortDownstream(), this.callbacks.onClose(e, t));
+	}
+	abortDownstream() {
+		this.downstreamAbort &&= (this.downstreamAbort.abort(), null);
+	}
+	checkKeepaliveNow() {
+		this.keepalive?.checkNow();
+	}
+	checkKeepaliveWithin(e) {
+		this.keepalive?.checkWithin(e);
+	}
+	resetKeepaliveTimeout() {
+		this.keepalive ??= new C(this.keepaliveTimeoutMs, "HTTP stream", (e) => {
+			this.callbacks.onError(e), this.close();
+		}), this.keepalive.reset();
+	}
+	clearKeepaliveTimeout() {
+		this.keepalive?.clear();
+	}
+};
+function P(e) {
+	return e ? [e, ...M.filter((t) => t !== e)] : M;
+}
+var F = class e {
+	static MaxLineLength = Math.ceil(a / 3) * 4 + 16;
+	decoder = new TextDecoder();
+	pending = "";
+	push(e, t) {
+		this.pending += this.decoder.decode(e, { stream: !0 });
+		let n = this.pending.indexOf("\n");
+		for (; n !== -1;) {
+			let e = this.pending.slice(0, n);
+			this.pending = this.pending.slice(n + 1), this.assertWithinLineBound(e.length), e.startsWith("data: ") && t(R(e.slice(6))), n = this.pending.indexOf("\n");
+		}
+		this.assertWithinLineBound(this.pending.length);
+	}
+	assertWithinLineBound(t) {
+		if (t > e.MaxLineLength) throw this.pending = "", Error(`HTTP stream line exceeds ${e.MaxLineLength} characters`);
+	}
+};
+function I() {
+	let e = new Uint8Array(j);
+	crypto.getRandomValues(e);
+	let t = "";
+	for (let n of e) t += n.toString(16).padStart(2, "0");
+	return t;
+}
+function L(e) {
+	let t = "";
+	for (let n of e) t += String.fromCharCode(n);
+	return btoa(t);
+}
+function R(e) {
+	let t = atob(e), n = new Uint8Array(t.length);
+	for (let e = 0; e < t.length; e++) n[e] = t.charCodeAt(e);
+	return n;
+}
+//#endregion
+//#region src/transport/web-socket-transport.ts
+var z = l("WebSocketTransport"), B = 1e4, V = class {
+	ws = null;
+	keepalive = null;
+	isClosed = !1;
+	keepaliveResponseMessage = null;
+	firstMessageResolver = null;
+	keepaliveTimeoutMs;
+	connectionTimeoutMs;
+	callbacks;
+	sessionId;
+	constructor(e) {
+		this.callbacks = e.callbacks, this.sessionId = e.sessionId, this.keepaliveTimeoutMs = e.keepaliveTimeoutMs, this.connectionTimeoutMs = e.connectionTimeoutMs ?? B;
+	}
+	get isConnected() {
+		return this.ws?.readyState === WebSocket.OPEN;
+	}
+	async connect(e, t) {
+		this.isClosed = !1;
+		let n = Date.now();
+		return new Promise((r, i) => {
+			try {
+				this.ws = new WebSocket(e), this.ws.binaryType = "arraybuffer";
+			} catch (e) {
+				i(new p(`Failed to create WebSocket: ${e}`, e instanceof Error ? e : void 0));
+				return;
+			}
+			let a = !1, o = !1, s = () => {
+				clearTimeout(u), this.ws && (this.ws.onopen = null, this.ws.onerror = null, this.ws.onclose = null, this.ws.onmessage = null);
+			}, c = () => {
+				o || (o = !0, clearTimeout(u), this.firstMessageResolver = null, z.debug(`WebSocket connected in ${Date.now() - n}ms`), r());
+			}, l = (e) => {
+				o || (o = !0, this.firstMessageResolver = null, s(), i(e));
+			};
+			this.firstMessageResolver = c;
+			let u = setTimeout(() => {
+				this.ws?.close(), z.warn(`WebSocket connection timeout after ${this.connectionTimeoutMs}ms`), l(new p("WebSocket connection timeout"));
+			}, this.connectionTimeoutMs);
+			this.ws.onopen = () => {
+				a = !0, this.ws.send(t), this.resetKeepaliveTimeout();
+			}, this.ws.onerror = () => {
+				z.debug(`WebSocket connection failed after ${Date.now() - n}ms`), l(new p("WebSocket connection failed"));
+			}, this.ws.onclose = (e) => {
+				if (this.clearKeepaliveTimeout(), !o) {
+					l(a ? new f("WebSocket closed before first server message") : new p("WebSocket connection closed before opening"));
+					return;
+				}
+				if (this.isClosed) return;
+				let t = e.wasClean && (e.code === 1e3 || e.code === 1001), n = e.reason || `code=${e.code}`;
+				this.callbacks.onClose(n, t);
+			}, this.ws.onmessage = (e) => {
+				this.handleProtocolMessage(new Uint8Array(e.data));
+			};
+		});
+	}
+	send(e) {
+		this.ws?.readyState === WebSocket.OPEN ? this.ws.send(e) : z.warn("Cannot send: WebSocket not connected");
+	}
+	close() {
+		this.isClosed = !0, this.clearKeepaliveTimeout(), this.ws &&= (this.ws.close(1e3, "Client closing"), null);
+	}
+	getKeepaliveResponse() {
+		return this.keepaliveResponseMessage ||= x(y(), this.sessionId), this.keepaliveResponseMessage;
+	}
+	handleProtocolMessage(t) {
+		try {
+			let n = e(t).opcode;
+			if (this.firstMessageResolver && this.firstMessageResolver(), n === c.KEEPALIVE_REQUEST) {
+				this.send(this.getKeepaliveResponse()), this.resetKeepaliveTimeout();
+				return;
+			}
+			this.resetKeepaliveTimeout(), this.callbacks.onProtocolMessage(t);
+		} catch (e) {
+			z.error("Failed to process protocol message:", e), this.callbacks.onError(e instanceof Error ? e : Error(String(e)));
+		}
+	}
+	checkKeepaliveNow() {
+		this.keepalive?.checkNow();
+	}
+	checkKeepaliveWithin(e) {
+		this.keepalive?.checkWithin(e);
+	}
+	resetKeepaliveTimeout() {
+		this.keepalive ??= new C(this.keepaliveTimeoutMs, "connection", (e) => {
+			this.callbacks.onError(e), this.close();
+		}), this.keepalive.reset();
+	}
+	clearKeepaliveTimeout() {
+		this.keepalive?.clear();
+	}
+}, H = l("WebTransportTransport"), U = 1e4, W = class {
+	transport = null;
+	stream = null;
+	reader = null;
+	writer = null;
+	keepalive = null;
+	readLoopActive = !1;
+	isClosed = !1;
+	framer = new E();
+	keepaliveResponseMessage = null;
+	firstMessageResolver = null;
+	firstMessageRejecter = null;
+	keepaliveTimeoutMs;
+	connectionTimeoutMs;
+	callbacks;
+	sessionId;
+	constructor(e) {
+		this.callbacks = e.callbacks, this.sessionId = e.sessionId, this.keepaliveTimeoutMs = e.keepaliveTimeoutMs, this.connectionTimeoutMs = e.connectionTimeoutMs ?? U;
+	}
+	get isConnected() {
+		return this.transport !== null && this.writer !== null;
+	}
+	async connect(e, t) {
+		if (!g()) throw new p("WebTransport is not supported in this browser");
+		this.isClosed = !1;
+		let n = Date.now(), r = new Promise((e, t) => {
+			this.firstMessageResolver = e, this.firstMessageRejecter = t;
+		});
+		try {
+			this.transport = new WebTransport(e);
+			let i, a = new Promise((e, t) => {
+				i = setTimeout(() => t(new p("WebTransport connection timeout")), this.connectionTimeoutMs);
+			});
+			try {
+				await Promise.race([this.transport.ready, a]);
+			} catch (e) {
+				throw e instanceof p && H.warn(`WebTransport connection timeout after ${this.connectionTimeoutMs}ms`), e;
+			} finally {
+				clearTimeout(i);
+			}
+			this.transport.closed.then(() => {
+				this.handleClose("Connection closed", !0);
+			}).catch((e) => {
+				H.error("WebTransport connection closed with error:", e), this.handleClose(e instanceof Error ? e.message : "Connection error", !1);
+			}), this.stream = await this.transport.createBidirectionalStream(), this.reader = this.stream.readable.getReader(), this.writer = this.stream.writable.getWriter(), await this.writer.write(t), this.resetKeepaliveTimeout(), this.startReadLoop();
+			let o = Math.max(this.connectionTimeoutMs - (Date.now() - n), 1), s, c = new Promise((e, t) => {
+				s = setTimeout(() => t(new p("WebTransport closed before first server message")), o);
+			});
+			try {
+				await Promise.race([r, c]);
+			} finally {
+				clearTimeout(s);
+			}
+			this.firstMessageResolver = null, this.firstMessageRejecter = null, H.info(`WebTransport connected in ${Date.now() - n}ms`);
+		} catch (e) {
+			this.firstMessageResolver = null, this.firstMessageRejecter = null, this.isClosed = !0, this.cleanup();
+			let t = Date.now() - n;
+			throw H.warn(`WebTransport connection failed after ${t}ms: ${e}`), new p(`Failed to connect WebTransport: ${e}`, e instanceof Error ? e : void 0);
+		}
+	}
+	send(e) {
+		if (!this.writer) {
+			H.warn("Cannot send: WebTransport not connected");
+			return;
+		}
+		this.writer.write(e).catch((e) => {
+			H.error("Failed to send protocol message:", e), this.callbacks.onError(e instanceof Error ? e : Error(String(e)));
+		});
+	}
+	close() {
+		this.isClosed = !0, this.clearKeepaliveTimeout(), this.readLoopActive = !1, this.cleanup();
+	}
+	async startReadLoop() {
+		if (this.reader) {
+			this.readLoopActive = !0;
+			try {
+				for (; this.readLoopActive && this.reader;) {
+					let { value: e, done: t } = await this.reader.read();
+					if (t) break;
+					e && this.framer.push(e, (e) => this.handleProtocolMessage(e));
+				}
+				this.readLoopActive && this.handleClose("Stream ended", !1);
+			} catch (e) {
+				this.readLoopActive && (H.warn(`Read loop failed, closing transport: ${e instanceof Error ? e.message : String(e)}`), this.callbacks.onError(e instanceof Error ? e : Error(String(e))), this.handleClose("Read loop failed", !1));
+			}
+		}
+	}
+	getKeepaliveResponse() {
+		return this.keepaliveResponseMessage ||= x(y(), this.sessionId), this.keepaliveResponseMessage;
+	}
+	handleProtocolMessage(t) {
+		try {
+			let n = e(t).opcode;
+			if (this.firstMessageResolver && this.firstMessageResolver(), n === c.KEEPALIVE_REQUEST) {
+				this.send(this.getKeepaliveResponse()), this.resetKeepaliveTimeout();
+				return;
+			}
+			this.resetKeepaliveTimeout(), this.callbacks.onProtocolMessage(t);
+		} catch (e) {
+			H.error("Failed to process protocol message:", e), this.callbacks.onError(e instanceof Error ? e : Error(String(e)));
+		}
+	}
+	handleClose(e, t) {
+		if (!this.isClosed) {
+			if (this.isClosed = !0, this.clearKeepaliveTimeout(), this.readLoopActive = !1, this.cleanup(), this.firstMessageRejecter) {
+				this.firstMessageRejecter(new f(`WebTransport closed before first server message: ${e}`)), this.firstMessageResolver = null, this.firstMessageRejecter = null;
+				return;
+			}
+			this.callbacks.onClose(e, t);
+		}
+	}
+	checkKeepaliveNow() {
+		this.keepalive?.checkNow();
+	}
+	checkKeepaliveWithin(e) {
+		this.keepalive?.checkWithin(e);
+	}
+	resetKeepaliveTimeout() {
+		this.keepalive ??= new C(this.keepaliveTimeoutMs, "connection", (e) => {
+			this.callbacks.onError(e), this.close();
+		}), this.keepalive.reset();
+	}
+	clearKeepaliveTimeout() {
+		this.keepalive?.clear();
+	}
+	cleanup() {
+		if (this.reader &&= (this.reader.releaseLock(), null), this.writer &&= (this.writer.releaseLock(), null), this.stream = null, this.framer.reset(), this.transport) {
+			try {
+				this.transport.close();
+			} catch {}
+			this.transport = null;
+		}
+	}
+}, G = l("Channel"), K = class {
+	state = "disconnected";
+	transport = null;
+	config;
+	entrypoint;
+	constructor(e) {
+		this.config = e, this.entrypoint = e.entrypoint;
+	}
+	get channelState() {
+		return this.state;
+	}
+	get opcodeGroups() {
+		return this.entrypoint.OpcodeGroupsFromServer;
+	}
+	get type() {
+		return this.entrypoint.Type;
+	}
+	get isConnected() {
+		return this.transport?.isConnected ?? !1;
+	}
+	get httpStreamMode() {
+		return this.transport instanceof N ? this.transport.activeMode : null;
+	}
+	async connect() {
+		if (this.state !== "disconnected") throw Error(`Cannot connect: already in state ${this.state}`);
+		this.setState("connecting");
+		try {
+			await this.connectTransport(), this.setState("connected");
+		} catch (e) {
+			throw this.setState("disconnected"), e;
+		}
+	}
+	disconnect() {
+		this.transport &&= (this.transport.close(), null), this.setState("disconnected");
+	}
+	triggerReconnect(e) {
+		this.transport &&= (this.transport.close(), null), this.config.onClose?.(e, !1);
+	}
+	checkHealth(e) {
+		this.state === "connected" && (e === void 0 ? this.transport?.checkKeepaliveNow?.() : this.transport?.checkKeepaliveWithin?.(e), this.state === "connected" && this.transport && !this.transport.isConnected && this.handleClose("Transport dead after tab resume", !1));
+	}
+	send(e) {
+		if (!this.transport?.isConnected) {
+			G.warn("Cannot send: channel not connected");
+			return;
+		}
+		this.transport.send(e);
+	}
+	async connectTransport() {
+		let e = this.entrypoint, t = {
+			sessionId: this.config.sessionId,
+			keepaliveTimeoutMs: this.config.keepaliveTimeoutMs,
+			connectionTimeoutMs: this.config.connectionTimeoutMs,
+			httpStreamMode: this.config.httpStreamMode,
+			httpStreamPreferredMode: this.config.httpStreamPreferredMode,
+			callbacks: {
+				onProtocolMessage: (e) => this.handleProtocolMessage(e),
+				onClose: (e, t) => this.handleClose(e, t),
+				onError: (e) => this.handleError(e)
+			}
+		};
+		switch (e.Type) {
+			case r.WebSocket:
+			case r.WebSocketProxy:
+				this.transport = new V(t);
+				break;
+			case r.WebTransport:
+			case r.WebTransportProxy:
+				if (!g()) throw Error("WebTransport is not supported in this browser");
+				this.transport = new W(t);
+				break;
+			case r.HttpStream:
+			case r.HttpStreamProxy:
+				this.transport = new N(t);
+				break;
+			default: throw Error(`Unsupported entrypoint type: ${r[e.Type]}`);
+		}
+		await this.transport.connect(e.Uri, e.AuthTicket);
+	}
+	handleProtocolMessage(e) {
+		try {
+			let t = s(e);
+			if (o(t) === c.CORE_ON_SERVER_STOPPING) {
+				G.debug("Received server stopping message"), this.setState("stopped"), this.transport?.close();
+				return;
+			}
+			this.config.onProtocolMessage?.(t);
+		} catch (e) {
+			G.error("Failed to handle protocol message:", e), this.config.onError?.(e instanceof Error ? e : Error(String(e)));
+		}
+	}
+	handleClose(e, t) {
+		this.transport = null, this.config.onClose?.(e, t);
+	}
+	handleError(e) {
+		this.config.onError?.(e), e instanceof u && this.handleClose("Keepalive timeout", !1);
+	}
+	setState(e) {
+		this.state !== e && (this.state = e, this.config.onStateChange?.(e));
+	}
+}, q = l("ChannelManager"), J = 5e3, Y = class e {
+	channels = /* @__PURE__ */ new Map();
+	activeType = null;
+	state = "idle";
+	reconnectAttempts = 0;
+	shouldReconnect = !0;
+	entrypoints = [];
+	abortController = null;
+	connectionTimeoutMs;
+	stabilityTimer = null;
+	config;
+	constructor(e) {
+		this.config = e;
+	}
+	get managerState() {
+		return this.state;
+	}
+	get activeHttpStreamMode() {
+		for (let e of this.channels.values()) {
+			let t = e.httpStreamMode;
+			if (t) return t;
+		}
+		return null;
+	}
+	get activeEndpointType() {
+		return this.activeType;
+	}
+	async connect(e, t) {
+		if (this.state !== "idle" && this.state !== "offline") throw Error(`Cannot connect: already in state ${this.state}`);
+		if (this.entrypoints = e, this.shouldReconnect = !0, this.reconnectAttempts = 0, this.abortController = new AbortController(), t?.retry) {
+			this.attemptReconnect();
+			return;
+		}
+		await this.connectInternal();
+	}
+	disconnect() {
+		this.shouldReconnect = !1, this.abortController?.abort(), this.abortController = null, this.disconnectAll(), this.setState("idle");
+	}
+	sendProtocolMessage(e) {
+		let n = t(e);
+		for (let [t, r] of this.channels) if (t & n) {
+			r.send(e);
+			return;
+		}
+		this.state === "connected" && q.warn("No channel found for message");
+	}
+	sendToAll(e) {
+		for (let t of this.channels.values()) t.send(e);
+	}
+	checkHealth(e) {
+		if (this.state === "connected") for (let t of this.channels.values()) t.checkHealth(e);
+	}
+	triggerReconnect(e) {
+		if (this.state === "connected") {
+			q.debug(`Forcing reconnect: ${e}`);
+			for (let t of this.channels.values()) t.triggerReconnect(e);
+		}
+	}
+	async connectInternal(t = !1) {
+		this.setState("connecting");
+		let n = this.entrypoints.filter((t) => t.Type !== r.WebRTC && !e.isNativeOnlyType(t.Type)), i = this.groupByType(n);
+		if (i.size === 0) throw this.setState("offline"), Error("No entrypoints available");
+		let a;
+		if (this.config.orderedEndpointTypes !== void 0) {
+			let e = new Set(i.keys());
+			a = this.config.orderedEndpointTypes.filter((t) => e.has(t));
+		} else a = this.config.endpointSelector ? this.config.endpointSelector.getOrderedTypes(i) : Array.from(i.keys());
+		if (a.length === 0) throw this.setState("offline"), new _(null, null, [...i.keys()].map((e) => r[e]));
+		this.connectionTimeoutMs = a.length > 1 ? 5e3 : 1e4, q.debug(`Endpoint types to try: [${a.map((e) => r[e]).join(", ")}], transport timeout: ${this.connectionTimeoutMs}ms`);
+		for (let e of a) {
+			if (!this.shouldReconnect) return;
+			let t = i.get(e), n = Date.now();
+			q.debug(`Trying ${r[e]} (${t.length} channel(s))`);
+			try {
+				await this.connectAllChannels(t), this.config.endpointSelector?.rememberWorkingType(e), this.config.onRememberWorkingType?.(e), this.activeType = e, q.debug(`Connected via ${r[e]} in ${Date.now() - n}ms`), this.setState("connected"), this.startStabilityTimer();
+				return;
+			} catch (t) {
+				q.warn(`Failed to connect using ${r[e]} after ${Date.now() - n}ms: ${t instanceof Error ? t.message : t}`);
+				let a = this.channels.size > 0;
+				if (this.disconnectAll(), t instanceof f) throw t;
+				if (a && this.config.onRefreshEntrypoints) try {
+					q.info("Partial connection detected, refreshing entrypoints");
+					let e = await this.config.onRefreshEntrypoints();
+					this.entrypoints = e.entrypoints, this.config.sessionId = e.sessionId;
+					let t = e.entrypoints.filter((e) => e.Type !== r.WebRTC), n = this.groupByType(t);
+					for (let [e, t] of n) i.set(e, t);
+				} catch (e) {
+					q.warn(`Failed to refresh entrypoints: ${e}`);
+				}
+			}
+		}
+		throw t || this.setState("offline"), Error("Failed to connect using any endpoint type");
+	}
+	async connectAllChannels(e) {
+		if (e.length === 0) throw Error("No entrypoints to connect");
+		let t = (await Promise.allSettled(e.map((e) => this.connectChannel(e)))).filter((e) => e.status === "rejected");
+		if (t.length > 0) {
+			let e = t.map((e) => e.reason instanceof Error ? e.reason.message : String(e.reason));
+			throw t.some((e) => e.reason instanceof f) ? new f(e.join(", ")) : Error(e.join(", "));
+		}
+	}
+	async connectChannel(e) {
+		let t = new K({
+			entrypoint: e,
+			sessionId: this.config.sessionId,
+			keepaliveTimeoutMs: this.config.keepaliveTimeoutMs,
+			connectionTimeoutMs: this.connectionTimeoutMs,
+			httpStreamMode: this.config.httpStreamMode,
+			httpStreamPreferredMode: this.config.httpStreamPreferredMode,
+			onProtocolMessage: (e) => {
+				this.config.onProtocolMessage?.(e);
+			},
+			onStateChange: (t) => {
+				this.handleChannelStateChange(e.OpcodeGroupsFromServer, t);
+			},
+			onClose: (t, n) => {
+				this.handleChannelClose(e.OpcodeGroupsFromServer, t, n);
+			},
+			onError: (e) => {
+				this.config.onError?.(e);
+			}
+		});
+		await t.connect(), this.channels.set(e.OpcodeGroupsFromServer, t);
+	}
+	static isNativeOnlyType(e) {
+		switch (e) {
+			case r.Tcp:
+			case r.TcpTls:
+			case r.TcpProxy:
+			case r.Udp:
+			case r.UdpDtls:
+			case r.Https: return !0;
+			default: return !1;
+		}
+	}
+	groupByType(e) {
+		let t = /* @__PURE__ */ new Map();
+		for (let n of e) {
+			let e = t.get(n.Type) ?? [];
+			e.push(n), t.set(n.Type, e);
+		}
+		return t;
+	}
+	handleChannelStateChange(e, t) {
+		t === "stopped" && (this.shouldReconnect = !1, this.disconnectAll(), this.setState("stopped"));
+	}
+	handleChannelClose(e, t, n) {
+		this.state !== "idle" && this.state !== "stopped" && this.state !== "offline" && this.channels.has(e) && this.state === "connected" && (q.warn("Channel closed unexpectedly, attempting reconnect"), this.disconnectAll(), this.attemptReconnect());
+	}
+	async attemptReconnect() {
+		if (this.shouldReconnect) {
+			if (!d()) {
+				q.warn("Retry disabled via ikon-retry=false, skipping reconnect"), this.setState("offline"), this.config.onError?.(new m(0));
+				return;
+			}
+			if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+				q.warn(`Max reconnect attempts (${this.config.maxReconnectAttempts}) reached`), this.setState("offline"), this.config.onError?.(new m(this.config.maxReconnectAttempts));
+				return;
+			}
+			if (this.setState("reconnecting"), this.reconnectAttempts++, this.reconnectAttempts > 1) {
+				q.info(`Reconnecting in ${this.config.reconnectBackoffMs}ms (attempt ${this.reconnectAttempts}/${this.config.maxReconnectAttempts})`);
+				try {
+					await h(this.config.reconnectBackoffMs, this.abortController?.signal);
+				} catch {
+					return;
+				}
+			} else q.info(`Reconnecting immediately (attempt ${this.reconnectAttempts}/${this.config.maxReconnectAttempts})`);
+			if (this.shouldReconnect) try {
+				await this.connectInternal(!0);
+			} catch (e) {
+				if (e instanceof f) {
+					q.warn("Auth rejected during reconnect, stopping retries and signaling full re-auth"), this.config.onError?.(e), this.setState("offline");
+					return;
+				}
+				if (e instanceof _) {
+					q.warn(`${e.message} Not retrying`), this.config.onError?.(e), this.setState("offline");
+					return;
+				}
+				await this.attemptReconnect();
+			}
+		}
+	}
+	disconnectAll() {
+		for (let e of this.channels.values()) e.disconnect();
+		this.channels.clear(), this.activeType = null;
+	}
+	setState(e) {
+		this.state !== e && (this.state === "connected" && e !== "connected" && this.clearStabilityTimer(), this.state = e, this.config.onStateChange?.(e));
+	}
+	startStabilityTimer() {
+		this.clearStabilityTimer(), this.stabilityTimer = setTimeout(() => {
+			this.stabilityTimer = null, this.state === "connected" && (this.reconnectAttempts = 0);
+		}, J);
+	}
+	clearStabilityTimer() {
+		this.stabilityTimer &&= (clearTimeout(this.stabilityTimer), null);
+	}
+};
+//#endregion
+export { Y as ChannelManager };