@ikonai/sdk 1.8.0 → 1.11.0

package/ikon-media-BQjL59S_.js

@@ -0,0 +1,2074 @@
+import { n as e } from "./log-type-DewKVFaU.js";
+import { c as t, n } from "./logger-gjegmH6K.js";
+import { a as r, f as i, g as a, i as o, l as s, n as c, r as l, t as u } from "./capabilities-ljRyAKpA.js";
+import { t as d } from "./media-session-helper-Do-OxyU6.js";
+import { i as f, n as p, r as m, t as h } from "./audio-constants-0i9B4zLJ.js";
+//#region src/worker/audio-playback-worker.ts?worker
+function g(e) {
+	return new Worker(new URL("assets/audio-playback-worker-BA5LbdyM.js", import.meta.url).href, {
+		type: "module",
+		name: e?.name
+	});
+}
+//#endregion
+//#region src/media/ikon-audio-playback.ts
+var _ = n("IkonAudioPlayback"), v = {
+	enabled: !1,
+	statusIntervalMs: 1e3
+};
+function y(e) {
+	return e instanceof Error ? `${e.name}: ${e.message}` : String(e);
+}
+function b(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 = ${h};
+const CONTROL_PERIOD_MS = 200;
+const UNDERRUN_JUMP_MS = 100;
+const STABLE_TIME_TO_DECREASE_MS = ${f};
+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 x = class n {
+	client;
+	config;
+	enabled = !1;
+	stateUnsubscribe = null;
+	isMobile = o();
+	boundVisibilityChange = null;
+	boundPageHide = null;
+	unlockHandler = null;
+	awaitingUnlock = !1;
+	recoveryTask = null;
+	static RESUME_TIMEOUT_MS = 100;
+	static MAX_WORKER_REBUILD_ATTEMPTS = 3;
+	workerRebuildAttempts = 0;
+	workerGivenUp = !1;
+	audioContext = null;
+	outputSampleRateHz = m;
+	audioWorkletNode = null;
+	scriptProcessorNode = null;
+	scriptDiagnosticsTimer = null;
+	workletModuleUrl = null;
+	workletModuleKey = null;
+	workletReady = null;
+	pendingWorkletMessages = [];
+	audioWorker = null;
+	protocolPort = null;
+	mediaSessionHelper = new d();
+	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 ?? {}, _.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 && l() && this.audioContext) {
+			this.stopAudioGraph();
+			try {
+				let e = new AudioContext({
+					sampleRate: m,
+					latencyHint: p
+				});
+				this.audioContext = e, this.outputSampleRateHz = e.sampleRate, e.resume().catch(() => void 0), this.setupAudioGraphAfterRecreate();
+			} catch (e) {
+				_.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 ?? v.enabled,
+			statusIntervalMs: e.statusIntervalMs ?? v.statusIntervalMs
+		};
+	}
+	resolveBackgroundConfig() {
+		let e = this.config.background ?? {};
+		return {
+			allowOnDesktop: e.allowOnDesktop ?? !0,
+			allowOnMobile: e.allowOnMobile ?? !1
+		};
+	}
+	async ensureAudioGraph(e, t) {
+		if (typeof window > "u") return;
+		if (!this.audioContext) {
+			let e = m, t = p;
+			try {
+				this.audioContext = new AudioContext({
+					sampleRate: e,
+					latencyHint: t
+				});
+			} catch (e) {
+				try {
+					this.audioContext = new AudioContext({ latencyHint: t });
+				} catch (e) {
+					try {
+						this.audioContext = new AudioContext();
+					} catch (e) {
+						_.warn(`Failed to create AudioContext: ${y(e)}`), this.audioContext = null;
+						return;
+					}
+					_.debug(`AudioContext latencyHint unsupported: ${y(e)}`);
+				}
+				_.debug(`AudioContext sample rate request unsupported: ${y(e)}`);
+			}
+			this.outputSampleRateHz = this.audioContext.sampleRate || 48e3, this.outputSampleRateHz !== e && _.debug(`AudioContext running at ${this.outputSampleRateHz}Hz (requested ${e}Hz)`), this.attachAudioContextHealthHandlers(this.audioContext);
+		}
+		l() && this.mediaSessionHelper.ensureSilentPlaybackElement();
+		let n = this.audioContext, r = this.resolveDiagnosticsConfig();
+		if ((this.config.performance?.preferAudioWorklet ?? !0) && u(n)) {
+			await this.ensureAudioWorklet(n, r, e, t);
+			return;
+		}
+		this.ensureScriptProcessor(n, r), await this.resumeAudioContextIfPossible(n, e, t), 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 && (_.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 t = e.resume(), r = new Promise((e, t) => {
+			setTimeout(() => t(/* @__PURE__ */ Error("AudioContext.resume() timed out")), n.RESUME_TIMEOUT_MS);
+		});
+		await Promise.race([t, 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 i = `${this.outputSampleRateHz}_2`;
+		if (!this.workletModuleUrl || this.workletModuleKey !== i) {
+			if (this.workletModuleUrl) try {
+				URL.revokeObjectURL(this.workletModuleUrl);
+			} catch {}
+			this.workletModuleKey = i, this.workletReady = null, this.workletModuleUrl = URL.createObjectURL(new Blob([b({
+				outputSampleRateHz: this.outputSampleRateHz,
+				outputChannels: 2
+			})], { type: "text/javascript" }));
+		}
+		this.workletReady ||= e.audioWorklet.addModule(this.workletModuleUrl).catch((e) => {
+			throw _.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 a = (this.config.performance?.preferSharedArrayBuffer ?? !0) && c();
+		this.audioWorkletNode = new AudioWorkletNode(e, "ikon-audio-player", {
+			numberOfInputs: 0,
+			numberOfOutputs: 1,
+			outputChannelCount: [2],
+			processorOptions: {
+				outputAudioConfig: { diagnostics: t },
+				useSharedArrayBuffer: a,
+				outputChannels: 2
+			}
+		}), this.audioWorkletNode.onprocessorerror = () => {
+			_.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" ? _.error(`[Worklet]${t} ${e.message}`) : e.level === "warn" ? _.warn(`[Worklet]${t} ${e.message}`) : _.info(`[Worklet]${t} ${e.message}`);
+					return;
+				}
+				if (n.type === "stats") {
+					if (!t.enabled) return;
+					let e = n;
+					_.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 o = this.pendingWorkletMessages.splice(0);
+		for (let e of o) this.postToWorklet(e);
+		let s = this.getContextState(e) === "running";
+		this.notifyPlaybackActive(s);
+	}
+	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 * h / 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;
+				_.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) {
+			_.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) {
+			_.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) {
+				_.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 && c() ? "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") {
+			_.warn("Audio decode worker unavailable (Workers not supported)");
+			return;
+		}
+		let e = this.client.createProtocolMessagePort({ opcodeGroupsMask: t.GROUP_AUDIO });
+		if (!e) return;
+		this.protocolPort = e;
+		try {
+			this.audioWorker = new g();
+		} catch (e) {
+			_.warn(`Failed to create audio worker: ${y(e)}`), this.protocolPort.close(), this.protocolPort = null;
+			return;
+		}
+		let n = this.audioWorker;
+		n.addEventListener("message", (e) => this.onAudioWorkerMessage(e.data)), n.addEventListener("error", (e) => {
+			let t = [
+				e.message,
+				e.filename,
+				e.lineno,
+				e.colno
+			].filter((e) => e != null && String(e).length > 0);
+			_.warn(`Audio worker failed, rebuilding: ${t.join(" ")}`.trim()), this.handleWorkerCrash();
+		});
+		let r = (this.config.performance?.preferSharedArrayBuffer ?? !0) && !!this.audioWorkletNode && c(), i = this.config.performance?.preferWebCodecs ?? !0, a = this.client.isWebRtcMediaActive, o = {
+			type: "configure",
+			transport: r ? "sab" : "pcm",
+			outputSampleRate: this.outputSampleRateHz,
+			outputChannels: 2,
+			preferWebCodecs: i,
+			webRtcEnabled: a
+		};
+		n.postMessage(o), n.postMessage({
+			type: "attachProtocolPort",
+			port: e.port
+		}, [e.port]);
+		let s = this.client.globalState;
+		s && this.syncStreamsFromGlobalState(s);
+		let l = this.audioWorkletNode ? "AudioWorklet" : "ScriptProcessor", u = r ? "SharedArrayBuffer" : "MessagePort", d = a ? "WebRTC (native)" : i && typeof AudioDecoder < "u" ? "WebCodecs" : "WASM Opus";
+		_.debug(`Audio initialized: renderer=${l}, 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" && _.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 t = this.audioContext;
+		return this.workerGivenUp || !t || this.getContextState(t) !== "running" || this.awaitingUnlock ? e.Blocked : this.hiddenMuted ? e.Hidden : e.Playing;
+	}
+	sendPlaybackReport(e, t, n, r) {
+		let o = e.indexOf("_");
+		if (o <= 0) return;
+		let s = Number(e.substring(0, o)), c = Number(e.substring(o + 1));
+		if (!Number.isFinite(s) || !Number.isFinite(c)) return;
+		let l = this.computePlaybackState();
+		this.lastReportedPlaybackState = l;
+		try {
+			let e = i({
+				Epoch: t,
+				PlayedSeconds: n,
+				BufferedMs: r,
+				State: l
+			});
+			this.client.sendProtocolMessage(a(e, this.client.sessionId ?? 0, {
+				trackId: c,
+				targetIds: [s]
+			}));
+		} 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 >= n.MAX_WORKER_REBUILD_ATTEMPTS) {
+			_.error("Audio worker crashed repeatedly, giving up on rebuilds; audio playback is off for the rest of the session"), this.workerGivenUp = !0, this.reportPlaybackStateIfChanged(), this.client.reportError(/* @__PURE__ */ Error("Audio playback worker crashed repeatedly; audio playback is off for the rest of the session"));
+			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 S(e) {
+	return new Worker(new URL("assets/video-playback-worker-v179IJ-C.js", import.meta.url).href, {
+		type: "module",
+		name: e?.name
+	});
+}
+//#endregion
+//#region src/media/ikon-video-playback.ts
+var C = n("IkonVideoPlayback");
+function w(e) {
+	return e instanceof Error ? `${e.name}: ${e.message}` : String(e);
+}
+var T = 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) {
+			C.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 || C.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") {
+			C.warn("Video decode worker unavailable (Workers not supported)");
+			return;
+		}
+		let e;
+		try {
+			e = new S();
+		} catch (e) {
+			C.warn(`Failed to create video worker: ${w(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);
+			C.warn(`Video worker failed, rebuilding: ${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") {
+				C.warn(`Video worker error: ${e.error.message}`);
+				return;
+			}
+			e.type === "log" ? C.info(e.message) : e.type === "debug" && C.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) {
+					C.warn(`Failed to attach offscreen canvas for stream ${e}: ${w(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 = s(r(), 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: t.GROUP_VIDEO });
+		if (e) {
+			this.protocolPort = e;
+			try {
+				this.worker.postMessage({
+					type: "attachProtocolPort",
+					port: e.port
+				}, [e.port]);
+			} catch (e) {
+				C.warn(`Failed to attach video protocol port: ${w(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) {
+			C.error("Video worker crashed repeatedly, giving up on rebuilds; video playback is off for the rest of the session"), this.client.reportError(/* @__PURE__ */ Error("Video playback worker crashed repeatedly; video playback is off for the rest of the session"));
+			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();
+			}
+		});
+	}
+}, E = class {
+	audio;
+	video;
+	constructor(e, t) {
+		this.audio = new x(e, t?.audio), this.video = new T(e, t?.video), t?.mediaSession && this.audio.setMediaSession(t.mediaSession);
+	}
+	dispose() {
+		this.audio.dispose(), this.video.dispose();
+	}
+};
+//#endregion
+export { E as IkonMedia };