@ikonai/sdk 1.10.0 → 1.11.2

package/ikon-media-capture-4aEsbGgC.js

@@ -0,0 +1,1422 @@
+import { c as e, n as t } from "./logger-gjegmH6K.js";
+import { _ as n, d as r, m as i, n as a, r as o, s, t as c } from "./capabilities-ljRyAKpA.js";
+//#region src/media/ring-buffer.ts
+var l = class {
+	static getStorageForCapacity(e, t) {
+		let n = Int32Array.BYTES_PER_ELEMENT * 2, r = t.BYTES_PER_ELEMENT * e;
+		return new SharedArrayBuffer(n + r);
+	}
+	readWrite;
+	storage;
+	buf;
+	constructor(e, t) {
+		this.buf = e, this.readWrite = new Int32Array(e, 0, 2);
+		let n = Int32Array.BYTES_PER_ELEMENT * 2, r = (e.byteLength - n) / Float32Array.BYTES_PER_ELEMENT;
+		this.storage = new t(e, n, r);
+	}
+	get capacity() {
+		return this.storage.length;
+	}
+	flush() {
+		Atomics.store(this.readWrite, 0, 0), Atomics.store(this.readWrite, 1, 0);
+	}
+	availableRead() {
+		let e = Atomics.load(this.readWrite, 0), t = Atomics.load(this.readWrite, 1);
+		return t >= e ? t - e : this.capacity - (e - t);
+	}
+	availableWrite() {
+		return this.capacity - this.availableRead() - 1;
+	}
+	push(e) {
+		let t = Math.min(this.availableWrite(), e.length);
+		if (t <= 0) return 0;
+		let n = Atomics.load(this.readWrite, 1), r = Math.min(t, this.capacity - n);
+		this.storage.set(e.subarray(0, r), n);
+		let i = t - r;
+		return i > 0 && this.storage.set(e.subarray(r, r + i), 0), n = (n + t) % this.capacity, Atomics.store(this.readWrite, 1, n), Atomics.notify(this.readWrite, 1), t;
+	}
+	pop(e) {
+		let t = Math.min(this.availableRead(), e.length);
+		if (t <= 0) return 0;
+		let n = Atomics.load(this.readWrite, 0), r = Math.min(t, this.capacity - n);
+		e.set(this.storage.subarray(n, n + r), 0);
+		let i = t - r;
+		return i > 0 && e.set(this.storage.subarray(0, i), r), n = (n + t) % this.capacity, Atomics.store(this.readWrite, 0, n), t;
+	}
+	skip(e) {
+		let t = Math.min(this.availableRead(), e);
+		if (t <= 0) return 0;
+		let n = Atomics.load(this.readWrite, 0);
+		return n = (n + t) % this.capacity, Atomics.store(this.readWrite, 0, n), t;
+	}
+};
+//#endregion
+//#region src/worker/audio-capture-worker.ts?worker
+function u(e) {
+	return new Worker(new URL("assets/audio-capture-worker-CJ5S-nQt.js", import.meta.url).href, {
+		type: "module",
+		name: e?.name
+	});
+}
+//#endregion
+//#region src/media/ikon-audio-capture.ts
+var d = t("IkonAudioCapture"), f = 3, p = 200, m = 2e3, h = 5e3, g = 3e3;
+function _(e) {
+	return new Promise((t) => setTimeout(t, e));
+}
+function v(e) {
+	switch (e.name) {
+		case "NotReadableError": return {
+			action: "retry",
+			reason: "device-busy",
+			canRetry: !0
+		};
+		case "AbortError":
+		case "TrackStartError": return {
+			action: "retry",
+			reason: "unknown",
+			canRetry: !0
+		};
+		case "OverconstrainedError": return {
+			action: "fallback-constraints",
+			reason: "unknown",
+			canRetry: !0
+		};
+		case "NotAllowedError":
+		case "SecurityError": return {
+			action: "fail",
+			reason: "permission-denied",
+			canRetry: !1
+		};
+		case "NotFoundError": return {
+			action: "fail",
+			reason: "no-device",
+			canRetry: !1
+		};
+		default: return {
+			action: "fail",
+			reason: "unknown",
+			canRetry: !1
+		};
+	}
+}
+function y() {
+	let e = globalThis.crypto;
+	return e?.randomUUID ? e.randomUUID() : `cap_${Date.now()}_${Math.floor(Math.random() * 1e9)}`;
+}
+function b() {
+	return "\nclass RingBuffer {\n  static getStorageForCapacity(capacity, type) {\n    const indexBytes = Int32Array.BYTES_PER_ELEMENT * 2;\n    const dataBytes = type.BYTES_PER_ELEMENT * capacity;\n    return new SharedArrayBuffer(indexBytes + dataBytes);\n  }\n\n  constructor(sharedArrayBuffer, type) {\n    this.buf = sharedArrayBuffer;\n    this.readWrite = new Int32Array(sharedArrayBuffer, 0, 2);\n    const dataOffset = Int32Array.BYTES_PER_ELEMENT * 2;\n    const dataLength = (sharedArrayBuffer.byteLength - dataOffset) / Float32Array.BYTES_PER_ELEMENT;\n    this.storage = new type(sharedArrayBuffer, dataOffset, dataLength);\n  }\n\n  get capacity() {\n    return this.storage.length;\n  }\n\n  available_read() {\n    const read = Atomics.load(this.readWrite, 0);\n    const write = Atomics.load(this.readWrite, 1);\n    if (write >= read) return write - read;\n    return this.capacity - (read - write);\n  }\n\n  available_write() {\n    return this.capacity - this.available_read() - 1;\n  }\n\n  push(input) {\n    const writable = Math.min(this.available_write(), input.length);\n    if (writable <= 0) return 0;\n\n    const read = Atomics.load(this.readWrite, 0);\n    let write = Atomics.load(this.readWrite, 1);\n\n    const firstPart = Math.min(writable, this.capacity - write);\n    this.storage.set(input.subarray(0, firstPart), write);\n    const remaining = writable - firstPart;\n    if (remaining > 0) {\n      this.storage.set(input.subarray(firstPart, firstPart + remaining), 0);\n    }\n\n    write = (write + writable) % this.capacity;\n    Atomics.store(this.readWrite, 1, write);\n    Atomics.notify(this.readWrite, 1);\n    if (this.available_read() > this.capacity - 2) {\n      Atomics.store(this.readWrite, 0, read);\n    }\n\n    return writable;\n  }\n}\n\nconst RENDER_QUANTUM_SIZE = 128;\n\nclass IkonAudioCaptureProcessor extends AudioWorkletProcessor {\n  constructor(options) {\n    super();\n    const cfg = options?.processorOptions || {};\n    this.channels = cfg.channels || 1;\n    this.transport = cfg.transport || 'pcm';\n    this.ring = null;\n    this.temp = new Float32Array(RENDER_QUANTUM_SIZE * this.channels);\n\n    if (this.transport === 'sab' && cfg.sharedArrayBuffer) {\n      this.ring = new RingBuffer(cfg.sharedArrayBuffer, Float32Array);\n    }\n\n    // Pre-allocated rotating transfer buffers for PCM mode\n    // We use two buffers and alternate between them since postMessage transfers ownership\n    this.transferBuffers = [\n      new Float32Array(RENDER_QUANTUM_SIZE),\n      new Float32Array(RENDER_QUANTUM_SIZE)\n    ];\n    this.transferBufferIndex = 0;\n\n    this.port.postMessage({ type: 'ready' });\n  }\n\n  process(inputs) {\n    const input = inputs[0];\n    if (!input || input.length === 0) {\n      return true;\n    }\n\n    const frames = input[0]?.length || 0;\n    if (frames === 0) {\n      return true;\n    }\n\n    const channelCount = input.length;\n    for (let i = 0; i < frames; i++) {\n      let sum = 0;\n      for (let ch = 0; ch < channelCount; ch++) {\n        const channel = input[ch];\n        sum += channel ? (channel[i] || 0) : 0;\n      }\n      this.temp[i] = sum / channelCount;\n    }\n\n    const out = this.temp.subarray(0, frames);\n    if (this.transport === 'sab' && this.ring) {\n      this.ring.push(out);\n      return true;\n    }\n\n    // Use rotating pre-allocated transfer buffer\n    let buffer = this.transferBuffers[this.transferBufferIndex];\n    // If buffer was transferred (detached), recreate it\n    if (buffer.byteLength === 0) {\n      buffer = new Float32Array(RENDER_QUANTUM_SIZE);\n      this.transferBuffers[this.transferBufferIndex] = buffer;\n    }\n    buffer.set(out);\n    const toSend = buffer.subarray(0, frames);\n    this.port.postMessage({ type: 'pcm', pcm: toSend }, [buffer.buffer]);\n    // Flip to next buffer for next call\n    this.transferBufferIndex = (this.transferBufferIndex + 1) % 2;\n    return true;\n  }\n}\n\nregisterProcessor('ikon-audio-capture', IkonAudioCaptureProcessor);\n";
+}
+var x = class t {
+	client;
+	static RESUME_TIMEOUT_MS = 3e3;
+	worker = null;
+	sendPort = null;
+	workletModuleUrl = null;
+	workletReady = null;
+	workletContext = null;
+	audioContext = null;
+	nextTrackId = 1;
+	captures = /* @__PURE__ */ new Map();
+	keepAliveSource = null;
+	keepAliveGain = null;
+	pendingCaptures = /* @__PURE__ */ new Map();
+	activeWebRtcCaptureInvalidate = null;
+	config;
+	deviceChangeHandler = null;
+	constructor(e, t) {
+		this.client = e, this.config = t ?? {}, this.setupDeviceChangeListener();
+	}
+	emitDiagnostic(e) {
+		if (this.config.onDiagnosticEvent) try {
+			this.config.onDiagnosticEvent(e);
+		} catch {}
+	}
+	async isMicrophoneAvailable(e) {
+		if (!navigator.mediaDevices?.enumerateDevices) return !0;
+		try {
+			let t = (await navigator.mediaDevices.enumerateDevices()).filter((e) => e.kind === "audioinput");
+			return e ? t.some((t) => t.deviceId === e) : t.length > 0;
+		} catch {
+			return !0;
+		}
+	}
+	setupDeviceChangeListener() {
+		navigator.mediaDevices?.addEventListener && (this.deviceChangeHandler = () => {
+			this.handleDeviceChange();
+		}, navigator.mediaDevices.addEventListener("devicechange", this.deviceChangeHandler));
+	}
+	removeDeviceChangeListener() {
+		this.deviceChangeHandler && navigator.mediaDevices?.removeEventListener && (navigator.mediaDevices.removeEventListener("devicechange", this.deviceChangeHandler), this.deviceChangeHandler = null);
+	}
+	extractDeviceId(e) {
+		if (!e?.deviceId) return null;
+		let t = e.deviceId;
+		return typeof t == "string" ? t : typeof t == "object" && "exact" in t ? String(t.exact) : typeof t == "object" && "ideal" in t ? String(t.ideal) : null;
+	}
+	async handleDeviceChange() {
+		if (this.captures.size === 0) return;
+		let e = Array.from(this.captures.values());
+		this.emitDiagnostic({
+			event: "device-change",
+			details: { captureCount: e.length }
+		});
+		for (let t of e) {
+			if (t.stopped) continue;
+			let e = t.intendedDeviceId ?? t.track.getSettings().deviceId, n = await this.isMicrophoneAvailable(e ?? void 0);
+			t.stopped || n || (d.warn(`Microphone device disconnected, deviceId=${e?.substring(0, 8) ?? "default"}`), this.config.deviceDisconnectPolicy?.autoStop ?? !0 ? this.handleRecoverableError(t, /* @__PURE__ */ Error("Microphone device disconnected"), "device-disconnected") : this.notifyError(t, /* @__PURE__ */ Error("Microphone device disconnected"), "device-disconnected", !0));
+		}
+	}
+	notifyError(e, t, n, r) {
+		if (e.stopped) return;
+		let i = Date.now(), a = t.name;
+		if (e.lastErrorReason === n && e.lastErrorName === a && i - e.lastErrorTime < h) return;
+		e.lastErrorTime = i, e.lastErrorReason = n, e.lastErrorName = a;
+		let o = this.config.autoRestartPolicy;
+		if (o?.enabled && r) {
+			let r = o.restartableReasons ?? ["track-ended", "device-disconnected"], a = o.maxRestarts ?? 3, s = o.backoffMs ?? [
+				500,
+				1e3,
+				2e3
+			];
+			if (i - e.lastStableTime > 3e4 && (e.restartCount = 0), r.includes(n) && e.restartCount < a) {
+				let r = s[Math.min(e.restartCount, s.length - 1)];
+				if (e.restartCount++, d.info(`Auto-restarting capture (attempt ${e.restartCount}/${a}) in ${r}ms, reason=${n}`), this.emitDiagnostic({
+					event: "auto-restart",
+					captureId: e.captureId,
+					details: {
+						attempt: e.restartCount,
+						maxRestarts: a,
+						delayMs: r,
+						reason: n
+					}
+				}), e.onError) try {
+					e.onError(t, n, !0);
+				} catch {}
+				e.pendingRestartTimer && clearTimeout(e.pendingRestartTimer);
+				let i = e.restartCount, o = e.onError, c = {
+					...e.originalRequest,
+					constraints: e.currentConstraints,
+					options: e.currentOptions,
+					onError: e.onError,
+					onStateChange: e.onStateChange
+				};
+				e.pendingRestartTimer = setTimeout(() => {
+					e.pendingRestartTimer = null, !(!e.stopped || e.stoppedReason !== "recoverable-error") && this.startMic(c).then((e) => {
+						let t = this.captures.get(e.captureId);
+						t && (t.restartCount = i, t.lastStableTime = Date.now());
+					}).catch((e) => {
+						d.warn(`Auto-restart failed: ${e}`);
+						let t = e instanceof Error ? e : Error(String(e)), n = "unknown";
+						if (t.name === "NotAllowedError" && (n = "permission-revoked"), o) try {
+							o(/* @__PURE__ */ Error(`Auto-restart failed: ${t.message}`), n, i < a && n !== "permission-revoked");
+						} catch {}
+					});
+				}, r);
+				return;
+			}
+		}
+		if (e.onError) try {
+			e.onError(t, n, r);
+		} catch {}
+	}
+	handleRecoverableError(e, t, n) {
+		this.notifyError(e, t, n, !0), e.stop("recoverable-error");
+	}
+	async attemptResumeAsync(e, t, n = !1) {
+		if (e.stopped) return !1;
+		if (e.ctx.state === "running") return !0;
+		if (e.ctx.state !== "suspended") return !1;
+		let r = Date.now();
+		if (!n && r - e.lastResumeAttemptTime < g) return d.debug(`Resume attempt from ${t} skipped (cooldown)`), !1;
+		e.lastResumeAttemptTime = r, this.emitDiagnostic({
+			event: "resume-attempt",
+			captureId: e.captureId,
+			details: {
+				source: t,
+				isUserGesture: n
+			}
+		});
+		try {
+			await this.resumeWithTimeout(e.ctx);
+			let n = e.ctx.state, r = n === "running";
+			return this.emitDiagnostic({
+				event: "resume-result",
+				captureId: e.captureId,
+				details: {
+					source: t,
+					success: r,
+					state: n
+				}
+			}), r;
+		} catch (r) {
+			return d.warn(`Failed to resume AudioContext from ${t}: ${r}`), this.emitDiagnostic({
+				event: "resume-result",
+				captureId: e.captureId,
+				details: {
+					source: t,
+					success: !1,
+					error: String(r)
+				}
+			}), n && this.notifyError(e, /* @__PURE__ */ Error("AudioContext suspended - user gesture required"), "context-suspended", !0), !1;
+		}
+	}
+	attemptResume(e, t, n = !1) {
+		if (e.stopped || e.ctx.state !== "suspended") return;
+		let r = Date.now();
+		if (!n && r - e.lastResumeAttemptTime < g) {
+			d.debug(`Resume attempt from ${t} skipped (cooldown)`);
+			return;
+		}
+		e.lastResumeAttemptTime = r, d.info(`Attempting AudioContext resume from ${t}`), e.ctx.resume().then(() => {
+			d.debug("AudioContext resumed successfully");
+		}).catch((t) => {
+			d.warn(`Failed to resume AudioContext: ${t}`), n && this.notifyError(e, /* @__PURE__ */ Error("AudioContext suspended - user gesture required"), "context-suspended", !0);
+		});
+	}
+	setupAudioContextStateListener(e, t) {
+		let n = () => {
+			if (t.stopped) return;
+			let n = e.state;
+			if (d.debug(`AudioContext state changed to: ${n}`), this.emitDiagnostic({
+				event: "state-change",
+				captureId: t.captureId,
+				details: { state: n }
+			}), t.onStateChange) try {
+				t.onStateChange(n);
+			} catch {}
+			n === "suspended" && (this.attemptResume(t, "statechange"), this.notifyError(t, /* @__PURE__ */ Error("AudioContext suspended - user gesture may be required"), "context-suspended", !0)), n === "interrupted" && (d.info("AudioContext interrupted (iOS), waiting for user to return"), this.notifyError(t, /* @__PURE__ */ Error("Audio interrupted - waiting for user to return"), "context-interrupted", !0));
+		};
+		e.addEventListener("statechange", n), t.stateChangeHandler = n;
+	}
+	removeAudioContextStateListener(e, t) {
+		t.stateChangeHandler &&= (e.removeEventListener("statechange", t.stateChangeHandler), null);
+	}
+	setupVisibilityChangeListener(e) {
+		let t = () => {
+			document.visibilityState === "hidden" && !e.stopped ? d.debug("Page hidden - audio may be suspended soon") : document.visibilityState === "visible" && !e.stopped && this.attemptResume(e, "visibilitychange");
+		};
+		document.addEventListener("visibilitychange", t), e.visibilityHandler = t;
+	}
+	removeVisibilityChangeListener(e) {
+		e.visibilityHandler &&= (document.removeEventListener("visibilitychange", e.visibilityHandler), null);
+	}
+	setupBFCacheHandlers(e) {
+		let t = () => {
+			e.stopped || d.debug("Page hiding (BFCache) - audio may be suspended");
+		}, n = (t) => {
+			t.persisted && !e.stopped && (d.info("Page restored from BFCache - checking audio state"), e.ctx.state === "suspended" && this.attemptResume(e, "bfcache"));
+		};
+		window.addEventListener("pagehide", t), window.addEventListener("pageshow", n), e.pagehideHandler = t, e.pageshowHandler = n;
+	}
+	removeBFCacheHandlers(e) {
+		e.pagehideHandler &&= (window.removeEventListener("pagehide", e.pagehideHandler), null), e.pageshowHandler &&= (window.removeEventListener("pageshow", e.pageshowHandler), null);
+	}
+	allocateTrackId() {
+		let e = this.nextTrackId;
+		return this.nextTrackId += 1, e;
+	}
+	async startMicWebRtc(e) {
+		let t = this.client.webRtcSignaling;
+		if (!t) throw Error("WebRTC signaling is not connected");
+		let n = e.constraints ? { ...e.constraints } : void 0;
+		n && typeof n.deviceId == "string" && (n.deviceId = { exact: n.deviceId }), await t.startAudioCapture(n);
+		let r = "webrtc-audio", i = !0, a = e.constraints ?? {}, o = e.options ?? {};
+		t.onAudioCaptureError = (t) => {
+			if (!i || !e.onError) return;
+			let n = v(t);
+			try {
+				e.onError(t, n.reason === "permission-denied" ? "permission-revoked" : n.reason, n.canRetry);
+			} catch (e) {
+				d.warn(`onError callback threw: ${e}`);
+			}
+		};
+		let s = () => {
+			i && (i = !1, e.onStopped?.());
+		}, c = () => {
+			this.activeWebRtcCaptureInvalidate === s && (this.activeWebRtcCaptureInvalidate = null);
+		};
+		this.activeWebRtcCaptureInvalidate = s;
+		let l = {
+			captureId: r,
+			streamId: r,
+			get isActive() {
+				return i;
+			},
+			get currentConstraints() {
+				return a;
+			},
+			get currentOptions() {
+				return o;
+			},
+			startSegment(e) {
+				t.startAudioSegment(e);
+			},
+			endSegment(e) {
+				t.endAudioSegment(e);
+			},
+			async stop() {
+				i && (i = !1, c(), t.onAudioCaptureError = null, t.stopAudioCapture(), e.onStopped?.());
+			},
+			async updateConstraints() {
+				return !1;
+			},
+			updateOptions() {},
+			async resume() {
+				return !0;
+			},
+			async restart() {
+				return l;
+			}
+		};
+		return l;
+	}
+	ensureWorker() {
+		if (this.worker) return this.worker;
+		let e = new u();
+		return this.worker = e, e.addEventListener("message", (e) => {
+			let t = e.data;
+			if (t?.type !== "error") return;
+			let n = t.error, r = `${n?.name ?? "Error"} ${n?.message ?? ""}`.trim(), i = typeof t.captureId == "string" ? this.captures.get(t.captureId) : void 0;
+			if (!i || i.stopped) {
+				d.warn(`Audio capture worker error: ${r}`);
+				return;
+			}
+			d.error(`Audio capture worker error, stopping captureId=${i.captureId.substring(0, 8)}: ${r}`), this.handleRecoverableError(i, /* @__PURE__ */ Error(`Audio capture worker error: ${r}`), "unknown");
+		}), e.addEventListener("error", (t) => {
+			let n = [
+				t.message,
+				t.filename,
+				t.lineno,
+				t.colno
+			].filter((e) => e != null && String(e).length > 0);
+			if (d.error(`Audio capture worker failed: ${n.join(" ")}`.trim()), this.worker === e) {
+				try {
+					e.terminate();
+				} catch {}
+				this.worker = null, this.sendPort?.close(), this.sendPort = null;
+			}
+			this.failActiveCapturesAfterWorkerCrash(Error(`Audio capture worker failed: ${n.join(" ")}`.trim()));
+		}), e;
+	}
+	failActiveCapturesAfterWorkerCrash(e) {
+		let t = this.client.sessionId;
+		for (let r of Array.from(this.captures.values())) r.stopped || (t && this.client.sendProtocolMessage(n(i({}), t, { trackId: r.trackId })), this.handleRecoverableError(r, e, "unknown"));
+	}
+	ensureSendPort() {
+		if (!this.client.sessionId) throw Error("Cannot start audio capture before client is connected");
+		let t = this.ensureWorker();
+		if (!this.sendPort) {
+			let n = this.client.createProtocolSendPort({ opcodeGroupsMask: e.GROUP_AUDIO });
+			if (!n) throw Error("Failed to create protocol send port for audio capture");
+			this.sendPort = n, t.postMessage({
+				type: "attachSendPort",
+				port: n.port
+			}, [n.port]);
+		}
+	}
+	startKeepAlive(e) {
+		if (!(this.keepAliveSource || e.state === "closed")) try {
+			let t = e.createGain();
+			t.gain.value = 0, t.connect(e.destination);
+			let n = e.createOscillator();
+			n.connect(t), n.start(), this.keepAliveGain = t, this.keepAliveSource = n, d.debug("Audio keep-alive started - capture will survive a backgrounded tab");
+		} catch (e) {
+			d.debug("Could not start the audio keep-alive", e), this.stopKeepAlive();
+		}
+	}
+	stopKeepAlive() {
+		try {
+			this.keepAliveSource?.stop();
+		} catch {}
+		try {
+			this.keepAliveSource?.disconnect(), this.keepAliveGain?.disconnect();
+		} catch {}
+		this.keepAliveSource = null, this.keepAliveGain = null;
+	}
+	async ensureAudioContext() {
+		if (typeof AudioContext > "u") throw Error("AudioContext is not available in this environment");
+		if (this.audioContext && this.audioContext.state !== "closed") {
+			let e = this.audioContext;
+			return e.state === "running" || await this.resumeWithTimeout(e), e;
+		}
+		let e = new AudioContext({ latencyHint: "interactive" });
+		return this.audioContext = e, e.state === "running" || await this.resumeWithTimeout(e), e;
+	}
+	async resumeWithTimeout(e) {
+		let n = new Promise((e, n) => {
+			setTimeout(() => n(/* @__PURE__ */ Error("AudioContext.resume() timed out")), t.RESUME_TIMEOUT_MS);
+		});
+		await Promise.race([e.resume(), n]);
+	}
+	async acquireMicrophoneStream(e) {
+		if (!navigator.mediaDevices) throw Error("Media devices are not available in this environment");
+		let t = {
+			autoGainControl: !1,
+			noiseSuppression: !1,
+			echoCancellation: !1
+		}, n = e.constraints ? {
+			...t,
+			...e.constraints
+		} : t;
+		typeof n.deviceId == "string" && (n.deviceId = { exact: n.deviceId });
+		let r = this.buildFallbackConstraints(n), i = await this.tryGetUserMediaWithRetries(n);
+		if (i.stream) return {
+			stream: i.stream,
+			constraints: n
+		};
+		if (i.errorInfo.action === "fallback-constraints") {
+			d.info(`Constraints failed (${i.error.name}), trying fallback constraints`), this.emitDiagnostic({
+				event: "fallback",
+				details: {
+					errorName: i.error.name,
+					originalConstraints: Object.keys(n)
+				}
+			});
+			let e = await this.tryGetUserMediaWithRetries(r);
+			if (e.stream) return d.info("getUserMedia succeeded with fallback constraints"), {
+				stream: e.stream,
+				constraints: r
+			};
+			let t = e.error;
+			throw t.captureReason = "constraints-failed", t;
+		}
+		let a = i.error;
+		throw a.captureReason = i.errorInfo.reason, a;
+	}
+	buildFallbackConstraints(e) {
+		let t = { ...e };
+		if (t.deviceId) {
+			let e = t.deviceId;
+			typeof e == "object" && "exact" in e && (t.deviceId = { ideal: e.exact });
+		}
+		return delete t.sampleRate, delete t.sampleSize, delete t.channelCount, t;
+	}
+	async tryGetUserMediaWithRetries(e) {
+		let t = /* @__PURE__ */ Error("No attempts made"), n = {
+			action: "fail",
+			reason: "unknown",
+			canRetry: !1
+		};
+		for (let r = 0; r < f; r++) try {
+			return {
+				stream: await navigator.mediaDevices.getUserMedia({ audio: e }),
+				error: t,
+				errorInfo: n
+			};
+		} catch (e) {
+			if (t = e instanceof Error ? e : Error(String(e)), n = v(t), d.debug(`getUserMedia attempt ${r + 1}/${f} failed: ${t.name} (action: ${n.action})`), this.emitDiagnostic({
+				event: "retry",
+				details: {
+					attempt: r + 1,
+					maxAttempts: f,
+					errorName: t.name,
+					action: n.action
+				}
+			}), n.action !== "retry") break;
+			if (r < 2) {
+				let e = p * (r + 1);
+				d.debug(`Retrying getUserMedia in ${e}ms`), await _(e);
+			}
+		}
+		return {
+			stream: null,
+			error: t,
+			errorInfo: n
+		};
+	}
+	async ensureWorklet(e) {
+		if (!c(e)) throw Error("AudioWorklet is not supported in this browser");
+		if (this.workletModuleUrl ||= URL.createObjectURL(new Blob([b()], { type: "text/javascript" })), this.workletReady && this.workletContext === e) try {
+			await this.workletReady;
+			return;
+		} catch {
+			this.workletReady = null;
+		}
+		this.workletContext = e;
+		let t = e.audioWorklet.addModule(this.workletModuleUrl);
+		this.workletReady = t;
+		try {
+			await t;
+		} catch (e) {
+			throw this.workletReady === t && (this.workletReady = null), e;
+		}
+	}
+	handleWebRtcTransportLost() {
+		if (this.activeWebRtcCaptureInvalidate) {
+			d.warn("WebRTC transport lost during active capture; invalidating the capture handle");
+			let e = this.activeWebRtcCaptureInvalidate;
+			this.activeWebRtcCaptureInvalidate = null, e();
+		}
+	}
+	async startMic(e = {}) {
+		let t = this.client.sessionId;
+		if (!t) throw Error("Cannot start audio capture before client is connected");
+		if (this.client.isWebRtcCaptureAvailable) return this.startMicWebRtc(e);
+		this.client.isWebRtcFirstConnecting ? d.debug("WebRTC still connecting, capturing audio via protocol channel") : this.client.isWebRtcEnabled && d.warn("WebRTC unavailable, capturing audio via protocol channel");
+		let n = y(), r = {
+			captureId: n,
+			aborted: !1,
+			stream: null,
+			source: null,
+			worklet: null,
+			gain: null
+		};
+		this.pendingCaptures.set(n, r);
+		let i = () => {
+			if (r.aborted) throw Error("Capture was aborted");
+		};
+		try {
+			this.ensureSendPort();
+			let s = await this.ensureAudioContext();
+			i();
+			let c, u;
+			try {
+				let t = await this.acquireMicrophoneStream(e);
+				c = t.stream, u = t.constraints, r.stream = c;
+			} catch (t) {
+				let n = t instanceof Error ? t : Error(String(t)), r = n.captureReason ?? "unknown";
+				if (e.onError) try {
+					e.onError(n, r, r !== "permission-denied" && r !== "no-device");
+				} catch {}
+				throw t;
+			}
+			i();
+			let f = c.getAudioTracks()[0];
+			if (!f) throw c.getTracks().forEach((e) => e.stop()), Error("No audio track available");
+			await this.ensureWorklet(s), i();
+			let p = this.allocateTrackId(), h = s.createMediaStreamSource(c);
+			r.source = h;
+			let g = s.createGain();
+			g.gain.value = 0, g.connect(s.destination), r.gain = g;
+			let _ = a() ? "sab" : "pcm", v;
+			if (_ === "sab") {
+				let e = Math.floor(s.sampleRate * 10);
+				v = l.getStorageForCapacity(e, Float32Array);
+			}
+			let y = this.ensureWorker(), b = e.onStopped;
+			y.postMessage({
+				type: "start",
+				captureId: n,
+				streamId: n,
+				sourceType: "microphone",
+				senderId: t,
+				trackId: p,
+				sampleRate: s.sampleRate,
+				channels: 1,
+				options: {
+					...e.options,
+					preferWebCodecs: this.config.performance?.preferWebCodecs
+				},
+				transport: _,
+				sharedArrayBuffer: v,
+				correlationId: e.correlationId
+			}), await new Promise((e, t) => {
+				let r = setTimeout(() => {
+					y.removeEventListener("message", i), t(/* @__PURE__ */ Error("Audio capture worker start timeout"));
+				}, 1e4), i = (a) => {
+					let o = a.data;
+					if (o?.type === "started" && o.captureId === n) clearTimeout(r), y.removeEventListener("message", i), e();
+					else if (o?.type === "error" && o.captureId === n) {
+						clearTimeout(r), y.removeEventListener("message", i);
+						let e = o.error;
+						t(Error(e?.message ?? "Audio capture failed to start"));
+					}
+				};
+				y.addEventListener("message", i);
+			}), i();
+			let x = new AudioWorkletNode(s, "ikon-audio-capture", {
+				numberOfInputs: 1,
+				numberOfOutputs: 1,
+				outputChannelCount: [1],
+				processorOptions: {
+					transport: _,
+					channels: 1,
+					sharedArrayBuffer: v
+				}
+			});
+			r.worklet = x, x.onprocessorerror = () => {
+				d.error(`Audio capture worklet processor crashed (captureId=${n})`);
+				let e = this.captures.get(n);
+				e && !e.stopped && this.notifyError(e, /* @__PURE__ */ Error("Audio capture worklet processor crashed"), "unknown", !0);
+			}, h.connect(x), x.connect(g), _ === "pcm" && (x.port.onmessage = (e) => {
+				let t = e.data;
+				if (!(!t || typeof t != "object") && t.type === "pcm" && t.pcm instanceof Float32Array) {
+					let e = t.pcm;
+					y.postMessage({
+						type: "pcm",
+						captureId: n,
+						pcm: e
+					}, [e.buffer]);
+				}
+			});
+			let S = this.extractDeviceId(e.constraints), C = {
+				captureId: n,
+				trackId: p,
+				stream: c,
+				track: f,
+				ctx: s,
+				source: h,
+				worklet: x,
+				gain: g,
+				stopped: !1,
+				intendedDeviceId: S,
+				currentConstraints: u,
+				currentOptions: e.options ?? {},
+				healthCheckTimer: null,
+				visibilityHandler: null,
+				pagehideHandler: null,
+				pageshowHandler: null,
+				trackEndedHandler: null,
+				lastErrorTime: 0,
+				lastErrorReason: null,
+				lastErrorName: null,
+				lastResumeAttemptTime: 0,
+				restartCount: 0,
+				lastStableTime: Date.now(),
+				mutedSinceTime: null,
+				originalRequest: e,
+				stateChangeHandler: null,
+				pendingRestartTimer: null,
+				stoppedReason: null,
+				onError: e.onError,
+				onStateChange: e.onStateChange,
+				startSegment: (e) => {
+					C.stopped || y.postMessage({
+						type: "startSegment",
+						captureId: n
+					});
+				},
+				endSegment: (e) => {
+					C.stopped || (y.postMessage({
+						type: "endSegment",
+						captureId: n
+					}), o() && C.stop());
+				},
+				stop: async (e = "user") => {
+					if (!C.stopped) {
+						if (C.stoppedReason = e, C.stopped = !0, this.captures.delete(n), this.captures.size === 0 && this.stopKeepAlive(), C.healthCheckTimer &&= (clearInterval(C.healthCheckTimer), null), e !== "recoverable-error" && C.pendingRestartTimer && (clearTimeout(C.pendingRestartTimer), C.pendingRestartTimer = null), this.removeVisibilityChangeListener(C), this.removeBFCacheHandlers(C), C.trackEndedHandler) {
+							try {
+								C.track.removeEventListener("ended", C.trackEndedHandler);
+							} catch {}
+							C.trackEndedHandler = null;
+						}
+						this.removeAudioContextStateListener(s, C);
+						try {
+							h.disconnect();
+						} catch {}
+						try {
+							x.disconnect();
+						} catch {}
+						try {
+							g.disconnect();
+						} catch {}
+						try {
+							c.getTracks().forEach((e) => e.stop());
+						} catch {}
+						if (y.postMessage({
+							type: "stop",
+							captureId: n
+						}), b) try {
+							b();
+						} catch {}
+					}
+				},
+				updateConstraints: async (e) => {
+					if (C.stopped) return !1;
+					try {
+						return await C.track.applyConstraints(e), C.currentConstraints = e, !0;
+					} catch {
+						return !1;
+					}
+				},
+				updateOptions: (e) => {
+					C.stopped || (C.currentOptions = e, y.postMessage({
+						type: "updateOptions",
+						captureId: n,
+						options: e
+					}));
+				}
+			};
+			this.setupAudioContextStateListener(s, C), this.setupVisibilityChangeListener(C), this.setupBFCacheHandlers(C), C.healthCheckTimer = setInterval(() => {
+				this.performHealthCheck(C);
+			}, m);
+			let w = () => {
+				C.stopped || (d.warn(`Microphone track ended unexpectedly, captureId=${n.substring(0, 8)}`), this.handleRecoverableError(C, /* @__PURE__ */ Error("Microphone track ended unexpectedly"), "track-ended"));
+			};
+			return C.trackEndedHandler = w, f.addEventListener("ended", w), this.captures.set(n, C), this.startKeepAlive(C.ctx), this.pendingCaptures.delete(n), {
+				captureId: n,
+				streamId: n,
+				get isActive() {
+					return !C.stopped;
+				},
+				get currentConstraints() {
+					return C.currentConstraints;
+				},
+				get currentOptions() {
+					return C.currentOptions;
+				},
+				startSegment: C.startSegment,
+				endSegment: C.endSegment,
+				stop: C.stop,
+				updateConstraints: C.updateConstraints,
+				updateOptions: C.updateOptions,
+				resume: this.resumeContext.bind(this, n),
+				restart: (e) => this.restartCapture(n, e)
+			};
+		} finally {
+			let e = this.pendingCaptures.get(n);
+			if (this.pendingCaptures.delete(n), e?.aborted) {
+				if (e.source) try {
+					e.source.disconnect();
+				} catch {}
+				if (e.worklet) try {
+					e.worklet.disconnect();
+				} catch {}
+				if (e.gain) try {
+					e.gain.disconnect();
+				} catch {}
+				if (e.stream) try {
+					e.stream.getTracks().forEach((e) => e.stop());
+				} catch {}
+			}
+		}
+	}
+	async stop(e) {
+		let t = this.captures.get(e);
+		return t ? (await t.stop(), !0) : !1;
+	}
+	startSegment(e) {
+		let t = this.captures.get(e);
+		return t ? (t.startSegment(), !0) : !1;
+	}
+	endSegment(e) {
+		let t = this.captures.get(e);
+		return t ? (t.endSegment(), !0) : !1;
+	}
+	dispose() {
+		this.removeDeviceChangeListener();
+		for (let e of this.pendingCaptures.values()) {
+			if (e.aborted = !0, e.source) try {
+				e.source.disconnect();
+			} catch {}
+			if (e.worklet) try {
+				e.worklet.disconnect();
+			} catch {}
+			if (e.gain) try {
+				e.gain.disconnect();
+			} catch {}
+			if (e.stream) try {
+				e.stream.getTracks().forEach((e) => e.stop());
+			} catch {}
+		}
+		this.pendingCaptures.clear();
+		for (let e of this.captures.values()) e.stop("dispose");
+		if (this.captures.clear(), this.worker) {
+			try {
+				this.worker.postMessage({ type: "dispose" });
+			} catch {}
+			try {
+				this.worker.terminate();
+			} catch {}
+			this.worker = null;
+		}
+		if (this.sendPort?.close(), this.sendPort = null, this.stopKeepAlive(), this.audioContext) {
+			try {
+				this.audioContext.onstatechange = null, this.audioContext.close();
+			} catch {}
+			this.audioContext = null;
+		}
+		if (this.workletContext = null, this.workletReady = null, this.workletModuleUrl) {
+			try {
+				URL.revokeObjectURL(this.workletModuleUrl);
+			} catch {}
+			this.workletModuleUrl = null;
+		}
+	}
+	performHealthCheck(e) {
+		if (e.stopped) return;
+		if (e.track.readyState !== "live") {
+			d.warn(`Health check: track is ${e.track.readyState}, captureId=${e.captureId.substring(0, 8)}`), this.handleRecoverableError(e, /* @__PURE__ */ Error(`Microphone track is ${e.track.readyState}`), "track-ended");
+			return;
+		}
+		let t = e.ctx.state;
+		if (t === "closed") {
+			d.warn(`Health check: AudioContext closed, captureId=${e.captureId.substring(0, 8)}`), this.notifyError(e, /* @__PURE__ */ Error("AudioContext was closed"), "context-closed", !1), e.stop("dispose");
+			return;
+		}
+		t === "suspended" && this.attemptResume(e, "healthcheck"), e.track.readyState === "live" && t === "running" && (e.lastStableTime = Date.now());
+		let n = this.config.mutedInputDetection;
+		if (e.track.muted) {
+			if (d.debug(`Health check: track is muted, captureId=${e.captureId.substring(0, 8)}`), n?.enabled) {
+				let t = Date.now();
+				if (e.mutedSinceTime === null) e.mutedSinceTime = t;
+				else {
+					let r = t - e.mutedSinceTime;
+					r >= (n.durationMs ?? 5e3) && (d.warn(`Health check: input muted for ${r}ms, captureId=${e.captureId.substring(0, 8)}`), this.notifyError(e, /* @__PURE__ */ Error(`Microphone input muted for ${Math.round(r / 1e3)}s`), "input-muted", !0), e.mutedSinceTime = t);
+				}
+			}
+		} else e.mutedSinceTime = null;
+	}
+	getActiveCaptures() {
+		return Array.from(this.captures.values()).filter((e) => !e.stopped).map((e) => ({
+			captureId: e.captureId,
+			trackState: e.track.readyState,
+			contextState: e.ctx.state,
+			isMuted: e.track.muted,
+			intendedDeviceId: e.intendedDeviceId,
+			lastErrorReason: e.lastErrorReason,
+			lastErrorAt: e.lastErrorTime
+		}));
+	}
+	async restartCapture(e, t) {
+		let n = this.captures.get(e), r = n !== void 0, i = {
+			constraints: n?.currentConstraints,
+			options: n?.currentOptions,
+			onError: n?.onError,
+			onStateChange: n?.onStateChange,
+			...t
+		};
+		n && !n.stopped && await n.stop("user");
+		try {
+			return await this.startMic(i);
+		} catch (e) {
+			let t = e instanceof Error ? e : Error(String(e));
+			throw r && t.name === "NotAllowedError" && (t.captureReason = "permission-revoked"), t;
+		}
+	}
+	async resumeContext(e) {
+		let t = this.captures.get(e);
+		return !t || t.stopped ? !1 : this.attemptResumeAsync(t, "userGesture", !0);
+	}
+}, S = 3e3;
+function C(e, t, n, r) {
+	if (!n && !r) return {
+		width: e,
+		height: t
+	};
+	let i = n ? n / e : Infinity, a = r ? r / t : Infinity, o = Math.min(i, a);
+	return {
+		width: Math.max(1, Math.floor(e * o)),
+		height: Math.max(1, Math.floor(t * o))
+	};
+}
+async function w(e, t) {
+	let n = t.mime ?? "image/jpeg", r = t.quality ?? .92;
+	if (typeof OffscreenCanvas < "u" && e instanceof OffscreenCanvas) try {
+		return await e.convertToBlob({
+			type: n,
+			quality: r
+		});
+	} catch {}
+	let i = e;
+	return await new Promise((e, t) => {
+		i.toBlob((n) => {
+			n ? e(n) : t(/* @__PURE__ */ Error("Canvas toBlob returned null"));
+		}, n, r);
+	});
+}
+var T = class {
+	async captureFromStream(e, t = {}) {
+		let n = e.getVideoTracks()[0];
+		if (!n) throw Error("No video track available in the provided stream");
+		let r = document.createElement("video");
+		r.style.position = "fixed", r.style.left = "-99999px", r.style.top = "0", r.muted = !0, r.playsInline = !0, r.autoplay = !0, r.srcObject = e;
+		try {
+			document.body.appendChild(r);
+		} catch {}
+		try {
+			await new Promise((e, t) => {
+				let n = setTimeout(() => t(/* @__PURE__ */ Error("Timed out waiting for video metadata")), S);
+				r.addEventListener("loadedmetadata", () => {
+					clearTimeout(n), e();
+				}, { once: !0 }), r.addEventListener("error", () => {
+					clearTimeout(n), t(/* @__PURE__ */ Error("Failed to load video element"));
+				}, { once: !0 });
+			});
+			try {
+				await r.play();
+			} catch {}
+			let { width: e, height: i } = C(r.videoWidth || (n.getSettings().width ?? 1280), r.videoHeight || (n.getSettings().height ?? 720), t.width, t.height), a;
+			if (typeof OffscreenCanvas < "u") a = new OffscreenCanvas(e, i);
+			else {
+				let t = document.createElement("canvas");
+				t.width = e, t.height = i, a = t;
+			}
+			let o = a.getContext("2d", { alpha: !1 });
+			if (!o) throw Error("2D canvas context unavailable");
+			o.drawImage(r, 0, 0, e, i);
+			let s = await w(a, t), c = await s.arrayBuffer();
+			return {
+				mime: s.type || t.mime || "image/jpeg",
+				width: e,
+				height: i,
+				data: new Uint8Array(c)
+			};
+		} finally {
+			try {
+				r.pause();
+			} catch {}
+			try {
+				r.srcObject = null;
+			} catch {}
+			try {
+				r.remove();
+			} catch {}
+		}
+	}
+	async acquireCameraStream(e) {
+		if (!navigator.mediaDevices) throw Error("Media devices are not available in this environment");
+		let t = e.constraints ?? {}, n = e.width ?? 1280, r = e.height ?? 720, i = {
+			...t,
+			width: t.width ?? { ideal: n },
+			height: t.height ?? { ideal: r }
+		};
+		return await navigator.mediaDevices.getUserMedia({
+			video: i,
+			audio: !1
+		});
+	}
+	async captureFromCamera(e = {}) {
+		let t = await this.acquireCameraStream(e), n = t.getVideoTracks()[0];
+		if (!n) throw t.getTracks().forEach((e) => e.stop()), Error("No video track available");
+		let r = document.createElement("video");
+		r.style.position = "fixed", r.style.left = "-99999px", r.style.top = "0", r.muted = !0, r.playsInline = !0, r.autoplay = !0, r.srcObject = t;
+		try {
+			document.body.appendChild(r);
+		} catch {}
+		try {
+			await new Promise((e, t) => {
+				let n = setTimeout(() => t(/* @__PURE__ */ Error("Timed out waiting for video metadata")), S);
+				r.addEventListener("loadedmetadata", () => {
+					clearTimeout(n), e();
+				}, { once: !0 }), r.addEventListener("error", () => {
+					clearTimeout(n), t(/* @__PURE__ */ Error("Failed to load video element"));
+				}, { once: !0 });
+			});
+			try {
+				await r.play();
+			} catch {}
+			let { width: t, height: i } = C(r.videoWidth || (n.getSettings().width ?? 1280), r.videoHeight || (n.getSettings().height ?? 720), e.width, e.height), a;
+			if (typeof OffscreenCanvas < "u") a = new OffscreenCanvas(t, i);
+			else {
+				let e = document.createElement("canvas");
+				e.width = t, e.height = i, a = e;
+			}
+			let o = a.getContext("2d", { alpha: !1 });
+			if (!o) throw Error("2D canvas context unavailable");
+			o.drawImage(r, 0, 0, t, i);
+			let s = await w(a, e), c = await s.arrayBuffer();
+			return {
+				mime: s.type || e.mime || "image/jpeg",
+				width: t,
+				height: i,
+				data: new Uint8Array(c)
+			};
+		} finally {
+			try {
+				r.pause();
+			} catch {}
+			try {
+				r.srcObject = null;
+			} catch {}
+			try {
+				r.remove();
+			} catch {}
+			try {
+				t.getTracks().forEach((e) => e.stop());
+			} catch {}
+		}
+	}
+	async captureFromNativeCamera(e = {}) {
+		if (typeof document > "u") throw Error("Native camera capture requires a DOM environment");
+		let t = await E(e.facing);
+		return t ? await D(t, e) : null;
+	}
+};
+function E(e) {
+	return new Promise((t) => {
+		let n = document.createElement("input");
+		n.type = "file", n.accept = "image/*", n.setAttribute("capture", e ?? "environment"), n.style.position = "fixed", n.style.left = "-99999px", n.style.top = "0";
+		let r = !1, i = (e) => {
+			if (!r) {
+				r = !0;
+				try {
+					n.remove();
+				} catch {}
+				t(e);
+			}
+		};
+		n.addEventListener("change", () => {
+			let e = n.files && n.files[0] ? n.files[0] : null;
+			i(e);
+		}), n.addEventListener("cancel", () => i(null));
+		try {
+			document.body.appendChild(n);
+		} catch {
+			i(null);
+			return;
+		}
+		n.click();
+	});
+}
+async function D(e, t) {
+	let n = URL.createObjectURL(e), r;
+	try {
+		r = await new Promise((e, t) => {
+			let r = new Image();
+			r.onload = () => e(r), r.onerror = () => t(/* @__PURE__ */ Error("Failed to decode image")), r.src = n;
+		});
+	} finally {
+		URL.revokeObjectURL(n);
+	}
+	let i = r.naturalWidth || r.width, a = r.naturalHeight || r.height, { width: o, height: s } = C(i, a, t.width, t.height), c = t.mime ?? (e.type === "image/png" ? "image/png" : "image/jpeg"), l = t.quality ?? .92;
+	if (o === i && s === a && e.type === c) {
+		let t = await e.arrayBuffer();
+		return {
+			mime: e.type,
+			width: i,
+			height: a,
+			data: new Uint8Array(t)
+		};
+	}
+	let u = document.createElement("canvas");
+	u.width = o, u.height = s;
+	let d = u.getContext("2d", { alpha: !1 });
+	if (!d) throw Error("2D canvas context unavailable");
+	d.drawImage(r, 0, 0, o, s);
+	let f = await new Promise((e, t) => {
+		u.toBlob((n) => n ? e(n) : t(/* @__PURE__ */ Error("Canvas toBlob returned null")), c, l);
+	}), p = await f.arrayBuffer();
+	return {
+		mime: f.type || c,
+		width: o,
+		height: s,
+		data: new Uint8Array(p)
+	};
+}
+//#endregion
+//#region src/worker/video-capture-worker.ts?worker
+function O(e) {
+	return new Worker(new URL("assets/video-capture-worker-DRYxkwR0.js", import.meta.url).href, {
+		type: "module",
+		name: e?.name
+	});
+}
+//#endregion
+//#region src/media/ikon-video-capture.ts
+var k = t("IkonVideoCapture"), A = 1e4;
+function j() {
+	let e = globalThis.crypto;
+	return e?.randomUUID ? e.randomUUID() : `cap_${Date.now()}_${Math.floor(Math.random() * 1e9)}`;
+}
+function M() {
+	let e = globalThis.MediaStreamTrackProcessor;
+	if (!e) throw Error("MediaStreamTrackProcessor is not available in this browser");
+	return e;
+}
+var N = class {
+	client;
+	worker = null;
+	protocolPort = null;
+	sendPort = null;
+	nextTrackId = 1;
+	captures = /* @__PURE__ */ new Map();
+	constructor(e) {
+		this.client = e;
+	}
+	allocateTrackId() {
+		let e = this.nextTrackId;
+		return this.nextTrackId += 1, e;
+	}
+	ensureWorker() {
+		if (this.worker) return this.worker;
+		let e = new O();
+		return this.worker = e, e.addEventListener("message", (e) => {
+			let t = e.data;
+			if (t?.type === "error") {
+				let e = t.error, n = `${e?.name ?? "Error"} ${e?.message ?? ""}`.trim(), r = typeof t.captureId == "string" ? this.captures.get(t.captureId) : void 0;
+				r && !r.stopped ? (k.error(`Video capture worker error, stopping captureId=${r.captureId.substring(0, 8)}: ${n}`), this.failCapture(r, /* @__PURE__ */ Error(`Video capture worker error: ${n}`))) : typeof t.captureId == "string" ? k.debug(`Video capture worker error for an inactive capture: ${n}`) : k.warn(`Video capture worker error: ${n}`);
+			} else t?.type === "log" ? k.info(t.message) : t?.type === "debug" && k.debug(t.message);
+		}), e.addEventListener("error", (t) => {
+			let n = [
+				t.message,
+				t.filename,
+				t.lineno,
+				t.colno
+			].filter((e) => e != null && String(e).length > 0);
+			if (k.error(`Video capture worker failed: ${n.join(" ")}`.trim()), this.worker === e) {
+				try {
+					e.terminate();
+				} catch {}
+				this.worker = null, this.protocolPort?.close(), this.protocolPort = null, this.sendPort?.close(), this.sendPort = null;
+			}
+			let i = Error(`Video capture worker failed: ${n.join(" ")}`.trim()), a = this.client.sessionId;
+			for (let e of Array.from(this.captures.values())) e.stopped || (a && this.client.sendProtocolMessage(r(s({}), a, { trackId: e.trackId })), this.failCapture(e, i));
+		}), e;
+	}
+	failCapture(e, t) {
+		try {
+			e.onError?.(t);
+		} catch (t) {
+			k.warn(`onError callback threw for captureId=${e.captureId.substring(0, 8)}: ${t}`);
+		}
+		e.stop();
+	}
+	ensurePorts() {
+		if (!this.client.sessionId) throw Error("Cannot start video capture before client is connected");
+		let t = this.ensureWorker();
+		if (!this.sendPort) {
+			let n = this.client.createProtocolSendPort({ opcodeGroupsMask: e.GROUP_VIDEO });
+			if (!n) throw Error("Failed to create protocol send port for video capture");
+			this.sendPort = n, t.postMessage({
+				type: "attachSendPort",
+				port: n.port
+			}, [n.port]);
+		}
+		if (!this.protocolPort) {
+			let n = this.client.createProtocolMessagePort({ opcodeGroupsMask: e.GROUP_VIDEO });
+			n && (this.protocolPort = n, t.postMessage({
+				type: "attachProtocolPort",
+				port: n.port
+			}, [n.port]));
+		}
+	}
+	async getMediaStream(e) {
+		if (!navigator.mediaDevices) throw Error("Media devices are not available in this environment");
+		let t = e.constraints ?? {}, n = e.options?.framerate ?? 30;
+		if (e.sourceType === "screen") {
+			let e = {
+				...t,
+				frameRate: t.frameRate ?? { ideal: n }
+			};
+			return navigator.mediaDevices.getDisplayMedia({
+				video: e,
+				audio: !1
+			});
+		}
+		let r = e.options?.width ?? 1280, i = e.options?.height ?? 720, a = {
+			...t,
+			frameRate: t.frameRate ?? { ideal: n },
+			width: t.width ?? { ideal: r },
+			height: t.height ?? { ideal: i }
+		};
+		return typeof a.deviceId == "string" && (a.deviceId = { exact: a.deviceId }), navigator.mediaDevices.getUserMedia({ video: a });
+	}
+	async startCameraWebRtc(e) {
+		let t = this.client.webRtcSignaling;
+		if (!t) throw Error("WebRTC signaling is not connected");
+		let n = { ...e.constraints };
+		e.options?.width && !n.width && (n.width = { ideal: e.options.width }), e.options?.height && !n.height && (n.height = { ideal: e.options.height }), e.options?.framerate && !n.frameRate && (n.frameRate = { ideal: e.options.framerate }), typeof n.deviceId == "string" && (n.deviceId = { exact: n.deviceId }), t.sendVideoCaptureCorrelation(0, e.correlationId);
+		let r = (await t.startVideoCapture(Object.keys(n).length > 0 ? n : void 0, e.options?.bitrate, 0, e.correlationId)).getVideoTracks()[0], i = "webrtc-video", a = !0, o = e.onStopped, s = {
+			captureId: i,
+			streamId: i,
+			sourceType: "camera",
+			get isActive() {
+				return a;
+			},
+			get currentOptions() {
+				return e.options;
+			},
+			async stop() {
+				a && (a = !1, await t.stopVideoCapture(0), o?.());
+			},
+			async updateOptions() {}
+		};
+		return r && r.addEventListener("ended", () => {
+			s.stop();
+		}), s;
+	}
+	async startScreenWebRtc(e) {
+		let t = this.client.webRtcSignaling;
+		if (!t) throw Error("WebRTC signaling is not connected");
+		let n = { ...e.constraints };
+		e.options?.framerate && !n.frameRate && (n.frameRate = { ideal: e.options.framerate }), t.sendVideoCaptureCorrelation(1, e.correlationId);
+		let r = await t.startScreenCapture(Object.keys(n).length > 0 ? n : void 0, e.options?.bitrate, 1, e.correlationId), i = r.getVideoTracks()[0], a = "webrtc-screen", o = !0, s = e.onStopped, c = {
+			captureId: a,
+			streamId: a,
+			sourceType: "screen",
+			get isActive() {
+				return o;
+			},
+			get currentOptions() {
+				return e.options;
+			},
+			async stop() {
+				o && (o = !1, r.getTracks().forEach((e) => e.stop()), await t.stopVideoCapture(1), s?.());
+			},
+			async updateOptions() {}
+		};
+		return i && i.addEventListener("ended", () => {
+			c.stop();
+		}), c;
+	}
+	async start(e) {
+		let t = this.client.sessionId;
+		if (!t) throw Error("Cannot start video capture before client is connected");
+		if (this.client.isWebRtcCaptureAvailable && e.sourceType === "camera") return this.startCameraWebRtc(e);
+		if (this.client.isWebRtcCaptureAvailable && e.sourceType === "screen") return this.startScreenWebRtc(e);
+		this.client.isWebRtcFirstConnecting ? k.debug("WebRTC still connecting, capturing video via protocol channel") : this.client.isWebRtcEnabled && k.warn("WebRTC unavailable, capturing video via protocol channel"), this.ensurePorts();
+		let n = j(), r = await this.getMediaStream(e), i = r.getVideoTracks()[0];
+		if (!i) throw r.getTracks().forEach((e) => e.stop()), Error("No video track available");
+		e.sourceType === "screen" && await new Promise((e) => setTimeout(e, 200));
+		let a = i.getSettings(), o = e.sourceType === "screen" ? a.width ?? 1280 : e.options?.width ?? a.width ?? 1280, s = e.sourceType === "screen" ? a.height ?? 720 : e.options?.height ?? a.height ?? 720, c = new (M())({ track: i }).readable, l = this.allocateTrackId(), u = this.ensureWorker(), d = e.sourceType, f = e.onStopped, p = new Promise((e, t) => {
+			let r = setTimeout(() => {
+				u.removeEventListener("message", i), t(/* @__PURE__ */ Error("Video capture worker start timeout"));
+			}, A), i = (a) => {
+				let o = a.data;
+				if (o?.captureId === n) {
+					if (o.type === "started") clearTimeout(r), u.removeEventListener("message", i), e();
+					else if (o.type === "error") {
+						clearTimeout(r), u.removeEventListener("message", i);
+						let e = o.error;
+						t(Error(e?.message ?? "Video capture failed to start"));
+					}
+				}
+			};
+			u.addEventListener("message", i);
+		});
+		u.postMessage({
+			type: "start",
+			captureId: n,
+			streamId: n,
+			sourceType: d,
+			kind: e.sourceType,
+			senderId: t,
+			trackId: l,
+			width: o,
+			height: s,
+			readable: c,
+			options: e.options,
+			correlationId: e.correlationId,
+			trackSettings: {
+				width: a.width,
+				height: a.height,
+				frameRate: a.frameRate
+			}
+		}, [c]);
+		try {
+			await p;
+		} catch (e) {
+			throw r.getTracks().forEach((e) => e.stop()), e;
+		}
+		let m = {
+			captureId: n,
+			trackId: l,
+			stream: r,
+			track: i,
+			sourceType: e.sourceType,
+			stopped: !1,
+			currentOptions: e.options,
+			onError: e.onError,
+			stop: async () => {
+				if (!m.stopped) {
+					m.stopped = !0, this.captures.delete(n), m.dimensionCheckInterval &&= (clearInterval(m.dimensionCheckInterval), void 0);
+					try {
+						r.getTracks().forEach((e) => e.stop());
+					} catch {}
+					if (u.postMessage({
+						type: "stop",
+						captureId: n
+					}), f) try {
+						f();
+					} catch {}
+				}
+			},
+			updateOptions: async (e) => {
+				if (!m.stopped) {
+					if (m.sourceType === "camera") {
+						let t = e.width !== void 0 && e.width !== m.currentOptions?.width, n = e.height !== void 0 && e.height !== m.currentOptions?.height, r = e.framerate !== void 0 && e.framerate !== m.currentOptions?.framerate;
+						if (t || n || r) try {
+							let t = {};
+							e.width !== void 0 && (t.width = { ideal: e.width }), e.height !== void 0 && (t.height = { ideal: e.height }), e.framerate !== void 0 && (t.frameRate = { ideal: e.framerate }), await i.applyConstraints(t), k.info(`Camera track constraints updated: ${e.width}x${e.height}@${e.framerate}fps`);
+						} catch (e) {
+							k.warn(`Failed to apply camera constraints: ${e}`);
+						}
+					}
+					m.currentOptions = e, u.postMessage({
+						type: "updateOptions",
+						captureId: n,
+						options: e
+					});
+				}
+			}
+		};
+		if (e.sourceType === "screen") {
+			let e = o, t = s;
+			m.dimensionCheckInterval = setInterval(() => {
+				if (m.stopped) {
+					m.dimensionCheckInterval &&= (clearInterval(m.dimensionCheckInterval), void 0);
+					return;
+				}
+				let r = i.getSettings(), a = r.width ?? e, o = r.height ?? t;
+				(a !== e || o !== t) && (e = a, t = o, u.postMessage({
+					type: "updateDimensions",
+					captureId: n,
+					width: a,
+					height: o
+				}));
+			}, 1e3);
+		}
+		return i.addEventListener("ended", () => {
+			m.stop();
+		}), this.captures.set(n, m), {
+			captureId: n,
+			streamId: n,
+			sourceType: e.sourceType,
+			get isActive() {
+				return !m.stopped;
+			},
+			get currentOptions() {
+				return m.currentOptions;
+			},
+			stop: m.stop,
+			updateOptions: m.updateOptions
+		};
+	}
+	async startCamera(e) {
+		return this.start({
+			sourceType: "camera",
+			...e
+		});
+	}
+	async startScreen(e) {
+		return this.start({
+			sourceType: "screen",
+			...e
+		});
+	}
+	async stop(e) {
+		let t = this.captures.get(e);
+		return t ? (await t.stop(), !0) : !1;
+	}
+	getActiveScreenStream() {
+		for (let e of this.captures.values()) if (e.sourceType === "screen") return e.stream;
+		return null;
+	}
+	dispose() {
+		for (let e of this.captures.values()) e.stop();
+		if (this.captures.clear(), this.worker) {
+			try {
+				this.worker.postMessage({ type: "dispose" });
+			} catch {}
+			try {
+				this.worker.terminate();
+			} catch {}
+			this.worker = null;
+		}
+		this.protocolPort?.close(), this.protocolPort = null, this.sendPort?.close(), this.sendPort = null;
+	}
+}, P = class {
+	audio;
+	video;
+	image;
+	constructor(e, t) {
+		this.audio = new x(e, t?.audio), this.video = new N(e), this.image = new T();
+	}
+	dispose() {
+		this.audio.dispose(), this.video.dispose();
+	}
+};
+//#endregion
+export { P as IkonMediaCapture };