@blockcast/mmt-render 0.1.0-main.0399efef1f07

package/dist/audio/index.js

@@ -0,0 +1,664 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+
+// src/audio/audio-ring-buffer.ts
+var _buffer, _writeIndex, _readIndex, _stalled, _startupFrames, _resumeFrames, _resumeFollowsStartup, _hasStarted, _capacityHeadroomFrames, _timestampAnchors, _diagEnabled, _diagReads, _diagFillSum, _diagOverflowSamples, _AudioRingBuffer_instances, pruneTimestampAnchors_fn, refillFrames_fn;
+var AudioRingBuffer = class {
+  constructor(config) {
+    __privateAdd(this, _AudioRingBuffer_instances);
+    __privateAdd(this, _buffer);
+    __privateAdd(this, _writeIndex, 0);
+    __privateAdd(this, _readIndex, 0);
+    __privateAdd(this, _stalled);
+    __privateAdd(this, _startupFrames);
+    __privateAdd(this, _resumeFrames);
+    __privateAdd(this, _resumeFollowsStartup);
+    __privateAdd(this, _hasStarted);
+    __privateAdd(this, _capacityHeadroomFrames);
+    __privateAdd(this, _timestampAnchors, []);
+    __privateAdd(this, _diagEnabled);
+    __privateAdd(this, _diagReads, 0);
+    __privateAdd(this, _diagFillSum, 0);
+    __privateAdd(this, _diagOverflowSamples, 0);
+    if (!Number.isInteger(config.channels) || config.channels <= 0) {
+      throw new Error("invalid channels");
+    }
+    if (!Number.isFinite(config.rate) || config.rate <= 0) {
+      throw new Error("invalid sample rate");
+    }
+    if (!Number.isFinite(config.latencyMs) || config.latencyMs <= 0) {
+      throw new Error("invalid latency");
+    }
+    const latencyFrames = Math.ceil(config.rate * (config.latencyMs / 1e3));
+    const startupFrames = config.startupFrames ?? latencyFrames;
+    const resumeFrames = config.resumeFrames ?? startupFrames;
+    const thresholdFrames = Math.max(startupFrames, resumeFrames);
+    const capacityFrames = config.capacityFrames ?? Math.max(latencyFrames, thresholdFrames);
+    if (!Number.isSafeInteger(startupFrames) || startupFrames <= 0) {
+      throw new Error("invalid startup frames");
+    }
+    if (!Number.isSafeInteger(resumeFrames) || resumeFrames <= 0) {
+      throw new Error("invalid resume frames");
+    }
+    if (!Number.isSafeInteger(capacityFrames) || capacityFrames < thresholdFrames) {
+      throw new Error("invalid capacity frames");
+    }
+    this.channels = config.channels;
+    this.rate = config.rate;
+    __privateSet(this, _startupFrames, startupFrames);
+    __privateSet(this, _resumeFrames, resumeFrames);
+    __privateSet(this, _resumeFollowsStartup, config.resumeFrames === void 0);
+    __privateSet(this, _hasStarted, config.startUnstalled ?? false);
+    __privateSet(this, _capacityHeadroomFrames, capacityFrames - thresholdFrames);
+    __privateSet(this, _stalled, !(config.startUnstalled ?? false));
+    __privateSet(this, _diagEnabled, config.diag ?? false);
+    __privateSet(this, _buffer, Array.from(
+      { length: config.channels },
+      () => new Float32Array(capacityFrames)
+    ));
+  }
+  get stalled() {
+    return __privateGet(this, _stalled);
+  }
+  get startupFrames() {
+    return __privateGet(this, _startupFrames);
+  }
+  get capacity() {
+    return __privateGet(this, _buffer)[0].length;
+  }
+  get length() {
+    return __privateGet(this, _writeIndex) - __privateGet(this, _readIndex);
+  }
+  /** Timestamp of the next media sample after the PCM already emitted. */
+  get timestampUs() {
+    const anchor = __privateGet(this, _timestampAnchors)[0];
+    if (!anchor || anchor.sampleIndex > __privateGet(this, _readIndex)) return void 0;
+    return anchor.timestampUs + (__privateGet(this, _readIndex) - anchor.sampleIndex) / this.rate * 1e6;
+  }
+  write(timestampUs, data) {
+    if (data.length !== this.channels) throw new Error("wrong channel count");
+    if (!Number.isFinite(timestampUs)) throw new Error("invalid timestamp");
+    const samples = data[0].length;
+    if (samples === 0) return;
+    if (data.some((channel) => channel.length !== samples)) {
+      throw new Error("mismatched channel lengths");
+    }
+    const start = __privateGet(this, _writeIndex);
+    const end = start + samples;
+    __privateGet(this, _timestampAnchors).push({ sampleIndex: start, timestampUs });
+    const overflow = end - __privateGet(this, _readIndex) - this.capacity;
+    if (overflow > 0) {
+      __privateSet(this, _stalled, false);
+      __privateSet(this, _hasStarted, true);
+      __privateSet(this, _readIndex, __privateGet(this, _readIndex) + overflow);
+      if (__privateGet(this, _diagEnabled)) __privateSet(this, _diagOverflowSamples, __privateGet(this, _diagOverflowSamples) + overflow);
+      __privateMethod(this, _AudioRingBuffer_instances, pruneTimestampAnchors_fn).call(this);
+    }
+    const refillFrames = __privateGet(this, _hasStarted) ? __privateGet(this, _resumeFrames) : __privateGet(this, _startupFrames);
+    if (__privateGet(this, _stalled) && end - __privateGet(this, _readIndex) >= refillFrames) {
+      __privateSet(this, _stalled, false);
+      __privateSet(this, _hasStarted, true);
+    }
+    for (let channel = 0; channel < this.channels; channel++) {
+      const src = data[channel];
+      const dst = __privateGet(this, _buffer)[channel];
+      for (let i = 0; i < samples; i++) {
+        dst[(start + i) % dst.length] = src[i];
+      }
+    }
+    __privateSet(this, _writeIndex, end);
+  }
+  read(output) {
+    if (output.length !== this.channels) throw new Error("wrong channel count");
+    if (__privateGet(this, _stalled)) return 0;
+    const available = this.length;
+    if (available === 0) {
+      __privateSet(this, _stalled, true);
+      return 0;
+    }
+    const requested = output[0].length;
+    const readSamples = Math.min(available, requested);
+    for (let channel = 0; channel < this.channels; channel++) {
+      const dst = output[channel];
+      const src = __privateGet(this, _buffer)[channel];
+      for (let i = 0; i < readSamples; i++) {
+        dst[i] = src[(__privateGet(this, _readIndex) + i) % src.length];
+      }
+      for (let i = readSamples; i < requested; i++) dst[i] = 0;
+    }
+    __privateSet(this, _readIndex, __privateGet(this, _readIndex) + readSamples);
+    __privateMethod(this, _AudioRingBuffer_instances, pruneTimestampAnchors_fn).call(this);
+    if (readSamples < requested) __privateSet(this, _stalled, true);
+    if (__privateGet(this, _diagEnabled)) {
+      __privateWrapper(this, _diagReads)._++;
+      __privateSet(this, _diagFillSum, __privateGet(this, _diagFillSum) + available);
+    }
+    return readSamples;
+  }
+  /** Clear queued PCM; optionally treat the next fill as post-start recovery. */
+  reset(startUnstalled = false, resumeAfterReset = false) {
+    __privateSet(this, _writeIndex, 0);
+    __privateSet(this, _readIndex, 0);
+    __privateSet(this, _stalled, !startUnstalled);
+    __privateSet(this, _hasStarted, startUnstalled || resumeAfterReset);
+    __privateSet(this, _timestampAnchors, []);
+    __privateSet(this, _diagReads, 0);
+    __privateSet(this, _diagFillSum, 0);
+    __privateSet(this, _diagOverflowSamples, 0);
+  }
+  /**
+   * Change the startup latency while preserving the configured storage
+   * headroom above its buffering thresholds. Active playout keeps draining
+   * retained PCM; a stalled buffer waits for its startup or resume threshold.
+   */
+  resize(latencyMs) {
+    if (!Number.isFinite(latencyMs) || latencyMs <= 0) {
+      throw new Error("invalid latency");
+    }
+    const newStartupFrames = Math.ceil(this.rate * (latencyMs / 1e3));
+    if (!Number.isSafeInteger(newStartupFrames) || newStartupFrames <= 0) {
+      throw new Error("invalid latency");
+    }
+    const newResumeFrames = __privateGet(this, _resumeFollowsStartup) ? newStartupFrames : __privateGet(this, _resumeFrames);
+    const newCapacity = Math.max(newStartupFrames, newResumeFrames) + __privateGet(this, _capacityHeadroomFrames);
+    if (!Number.isSafeInteger(newCapacity) || newCapacity < Math.max(newStartupFrames, newResumeFrames)) {
+      throw new Error("invalid capacity frames");
+    }
+    const wasStalled = __privateGet(this, _stalled);
+    __privateSet(this, _startupFrames, newStartupFrames);
+    __privateSet(this, _resumeFrames, newResumeFrames);
+    if (newCapacity === this.capacity) {
+      if (wasStalled && this.length >= __privateMethod(this, _AudioRingBuffer_instances, refillFrames_fn).call(this)) {
+        __privateSet(this, _stalled, false);
+        __privateSet(this, _hasStarted, true);
+      }
+      return;
+    }
+    const next = Array.from(
+      { length: this.channels },
+      () => new Float32Array(newCapacity)
+    );
+    const samplesToKeep = Math.min(this.length, newCapacity);
+    const copyStart = __privateGet(this, _writeIndex) - samplesToKeep;
+    for (let channel = 0; channel < this.channels; channel++) {
+      const src = __privateGet(this, _buffer)[channel];
+      const dst = next[channel];
+      for (let i = 0; i < samplesToKeep; i++) {
+        const sampleIndex = copyStart + i;
+        dst[sampleIndex % dst.length] = src[sampleIndex % src.length];
+      }
+    }
+    __privateSet(this, _buffer, next);
+    __privateSet(this, _readIndex, copyStart);
+    __privateMethod(this, _AudioRingBuffer_instances, pruneTimestampAnchors_fn).call(this);
+    __privateSet(this, _stalled, samplesToKeep === 0 || wasStalled && samplesToKeep < __privateMethod(this, _AudioRingBuffer_instances, refillFrames_fn).call(this));
+    if (!__privateGet(this, _stalled)) __privateSet(this, _hasStarted, true);
+  }
+  getDiagAndReset() {
+    if (!__privateGet(this, _diagEnabled) || __privateGet(this, _diagReads) === 0) return null;
+    const result = {
+      reads: __privateGet(this, _diagReads),
+      avgFill: Math.round(__privateGet(this, _diagFillSum) / __privateGet(this, _diagReads)),
+      capacity: this.capacity,
+      skips: 0,
+      dups: 0,
+      overflowSamples: __privateGet(this, _diagOverflowSamples)
+    };
+    __privateSet(this, _diagReads, 0);
+    __privateSet(this, _diagFillSum, 0);
+    __privateSet(this, _diagOverflowSamples, 0);
+    return result;
+  }
+};
+_buffer = new WeakMap();
+_writeIndex = new WeakMap();
+_readIndex = new WeakMap();
+_stalled = new WeakMap();
+_startupFrames = new WeakMap();
+_resumeFrames = new WeakMap();
+_resumeFollowsStartup = new WeakMap();
+_hasStarted = new WeakMap();
+_capacityHeadroomFrames = new WeakMap();
+_timestampAnchors = new WeakMap();
+_diagEnabled = new WeakMap();
+_diagReads = new WeakMap();
+_diagFillSum = new WeakMap();
+_diagOverflowSamples = new WeakMap();
+_AudioRingBuffer_instances = new WeakSet();
+pruneTimestampAnchors_fn = function() {
+  let keep = 0;
+  while (keep + 1 < __privateGet(this, _timestampAnchors).length && __privateGet(this, _timestampAnchors)[keep + 1].sampleIndex <= __privateGet(this, _readIndex)) {
+    keep++;
+  }
+  if (keep > 0) __privateGet(this, _timestampAnchors).splice(0, keep);
+};
+refillFrames_fn = function() {
+  return __privateGet(this, _hasStarted) ? __privateGet(this, _resumeFrames) : __privateGet(this, _startupFrames);
+};
+
+// src/audio/audio-buffer-plan.ts
+function positive(value, label) {
+  if (!Number.isFinite(value) || value <= 0) throw new Error(`invalid ${label}`);
+  return value;
+}
+function deriveAudioBurstBufferPlan(input) {
+  const sampleRate = positive(input.sampleRate, "sample rate");
+  const chunkFrames = positive(input.chunkFrames, "audio chunk size");
+  const groupDurationMs = positive(input.groupDurationMs, "audio group duration");
+  if (!Number.isInteger(chunkFrames)) throw new Error("invalid audio chunk size");
+  const chunkDurationMs = 1e3 * chunkFrames / sampleRate;
+  const groupChunks = Math.max(1, Math.round(groupDurationMs / chunkDurationMs));
+  const deliveryWindowChunks = input.deliveryWindowMs === void 0 ? 0 : Math.max(
+    1,
+    Math.ceil(positive(input.deliveryWindowMs, "audio delivery window") / chunkDurationMs)
+  );
+  const deliveryChunks = Math.max(groupChunks, deliveryWindowChunks);
+  const deliveryFrames = deliveryChunks * chunkFrames;
+  const capacityFrames = deliveryFrames + deliveryFrames;
+  if (!Number.isSafeInteger(deliveryFrames) || !Number.isSafeInteger(capacityFrames)) {
+    throw new Error("audio buffer frame count exceeds safe integer range");
+  }
+  return {
+    startupFrames: deliveryFrames,
+    capacityFrames,
+    deliveryFrames
+  };
+}
+
+// src/audio/audio-render-pipeline.ts
+import { MmtpDecodePipeline } from "@blockcast/mmt-container/mmtp-decode-pipeline";
+
+// src/pacing/frame-pacer.ts
+var _frameCount, _anchorWallMs, _anchored;
+var FrameCountPacer = class {
+  constructor(opts) {
+    __privateAdd(this, _frameCount, 0);
+    __privateAdd(this, _anchorWallMs, 0);
+    __privateAdd(this, _anchored, false);
+    if (!(opts.frameDurationMs > 0)) {
+      throw new Error("frameDurationMs must be > 0");
+    }
+    this.frameDurationMs = opts.frameDurationMs;
+    this.thresholdMs = opts.mapper.pacingThresholdMs;
+    this.warmupFrames = Math.max(0, opts.warmupFrames ?? 0);
+  }
+  /** Call on every emitted decoded frame (AU or picture). Anchors on first call. */
+  notifyFrame() {
+    if (!__privateGet(this, _anchored)) {
+      __privateSet(this, _anchorWallMs, now());
+      __privateSet(this, _anchored, true);
+    }
+    __privateWrapper(this, _frameCount)._++;
+  }
+  /**
+   * Compute sleep ms before reading the next MoQ object.
+   * Returns 0 when:
+   *   - pacing is disabled (NullBlockMapper → threshold=0)
+   *   - the anchor is not yet set
+   *   - still in warmup
+   *   - the caller reports a standing backlog (see `observedDelayMs`)
+   *   - decoder is not ahead of wall clock by more than threshold
+   * Otherwise returns aheadMs - thresholdMs/2 (leaves half the threshold as headroom).
+   *
+   * `observedDelayMs` is how far this frame is behind the producer's own clock,
+   * measured by the caller against a producer-supplied sending instant (for
+   * MMTP, the header send-wall timestamp). It is optional because the anchored
+   * rate below is blind to it: `#anchorWallMs` is the wall time of the FIRST
+   * frame read, so `aheadMs` measures consumption against the join instant and
+   * not against the producer. Once `aheadMs` reaches the threshold the loop
+   * consumes at exactly the source rate, and recovering latency present at join
+   * requires consuming FASTER than the source rate. So without this argument a
+   * consumer that joined a live stream mid-block keeps that join latency for the
+   * life of the subscription.
+   *
+   * A caller that can measure the real distance from the producer passes it and
+   * gets a drain: while the backlog exceeds the threshold there is nothing to
+   * pace against, so return 0 and let the transport set the rate. At the live
+   * edge the anchored-rate behavior below applies unchanged.
+   *
+   * Callers with no producer clock omit it and keep the pure ATSC3-style
+   * anchored pacing (see the class doc), where a first-frame anchor is correct
+   * because a broadcast push has no live edge to catch up to.
+   */
+  computeSleepMs(observedDelayMs) {
+    if (this.thresholdMs <= 0) return 0;
+    if (!__privateGet(this, _anchored)) return 0;
+    if (__privateGet(this, _frameCount) <= this.warmupFrames) return 0;
+    if (observedDelayMs !== void 0 && Number.isFinite(observedDelayMs) && observedDelayMs > this.thresholdMs) {
+      return 0;
+    }
+    const mediaMs = __privateGet(this, _frameCount) * this.frameDurationMs;
+    const wallMs = now() - __privateGet(this, _anchorWallMs);
+    const aheadMs = mediaMs - wallMs;
+    if (aheadMs <= this.thresholdMs) return 0;
+    return aheadMs - this.thresholdMs / 2;
+  }
+  /** Reset anchor + counter. Call on source switch (MoQ ↔ multicast). */
+  reset() {
+    __privateSet(this, _frameCount, 0);
+    __privateSet(this, _anchorWallMs, 0);
+    __privateSet(this, _anchored, false);
+  }
+  get snapshot() {
+    const mediaMs = __privateGet(this, _frameCount) * this.frameDurationMs;
+    const wallMs = __privateGet(this, _anchored) ? now() - __privateGet(this, _anchorWallMs) : 0;
+    return {
+      frameCount: __privateGet(this, _frameCount),
+      mediaMs,
+      wallMs,
+      aheadMs: mediaMs - wallMs,
+      thresholdMs: this.thresholdMs,
+      anchored: __privateGet(this, _anchored)
+    };
+  }
+};
+_frameCount = new WeakMap();
+_anchorWallMs = new WeakMap();
+_anchored = new WeakMap();
+function now() {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+}
+
+// src/pacing/au-duration.ts
+function auDurationMsFromCodec(codec, sampleRate) {
+  if (!(sampleRate > 0)) throw new Error("sampleRate must be > 0");
+  if (codec.startsWith("opus") || codec.startsWith("Opus")) {
+    return 960 / sampleRate * 1e3;
+  }
+  if (codec.startsWith("mp4a") || codec.startsWith("AAC") || codec.startsWith("aac")) {
+    return 1024 / sampleRate * 1e3;
+  }
+  if (codec.startsWith("flac") || codec.startsWith("fLaC")) {
+    return 4096 / sampleRate * 1e3;
+  }
+  throw new Error(`unknown audio codec for AU duration derivation: ${codec}`);
+}
+
+// src/audio/worklet-url.ts
+function workletModuleUrl() {
+  const base = new URL("../worklet/render-worklet.js", import.meta.url);
+  return base.href;
+}
+var WORKLET_PROCESSOR_NAME = "mmt-render";
+
+// src/audio/audio-render-pipeline.ts
+var _context, _pacer, _mapper, _codec, _packetId, _sampleRate, _channels, _description, _latencyMs, _startupFrames2, _startupThresholdFrames, _capacityFrames, _diag, _warmupFrames, _onState, _onDiag, _onError, _reassemblyPolicy, _decoder, _pipeline, _worklet, _fecClient, _closed, _readyPromise, _workletGeneration, _startupReleased, _AudioRenderPipeline_instances, initialize_fn, onDecoded_fn;
+var AudioRenderPipeline = class {
+  constructor(opts) {
+    __privateAdd(this, _AudioRenderPipeline_instances);
+    __privateAdd(this, _context);
+    __privateAdd(this, _pacer);
+    __privateAdd(this, _mapper);
+    __privateAdd(this, _codec);
+    __privateAdd(this, _packetId);
+    __privateAdd(this, _sampleRate);
+    __privateAdd(this, _channels);
+    __privateAdd(this, _description);
+    __privateAdd(this, _latencyMs);
+    __privateAdd(this, _startupFrames2);
+    __privateAdd(this, _startupThresholdFrames);
+    __privateAdd(this, _capacityFrames);
+    __privateAdd(this, _diag);
+    __privateAdd(this, _warmupFrames);
+    __privateAdd(this, _onState);
+    __privateAdd(this, _onDiag);
+    __privateAdd(this, _onError);
+    __privateAdd(this, _reassemblyPolicy);
+    __privateAdd(this, _decoder, null);
+    __privateAdd(this, _pipeline, null);
+    __privateAdd(this, _worklet, null);
+    __privateAdd(this, _fecClient);
+    __privateAdd(this, _closed, false);
+    __privateAdd(this, _readyPromise, null);
+    __privateAdd(this, _workletGeneration, 0);
+    __privateAdd(this, _startupReleased, false);
+    __privateSet(this, _context, opts.context);
+    __privateSet(this, _mapper, opts.mapper);
+    __privateSet(this, _codec, opts.codec);
+    __privateSet(this, _packetId, opts.packetId);
+    __privateSet(this, _sampleRate, opts.sampleRate);
+    __privateSet(this, _channels, opts.channels);
+    __privateSet(this, _description, opts.description);
+    __privateSet(this, _latencyMs, opts.latencyMs);
+    __privateSet(this, _startupFrames2, opts.startupFrames);
+    __privateSet(this, _startupThresholdFrames, opts.startupFrames ?? Math.ceil(opts.sampleRate * (opts.latencyMs / 1e3)));
+    __privateSet(this, _capacityFrames, opts.capacityFrames);
+    __privateSet(this, _diag, opts.diag ?? false);
+    __privateSet(this, _warmupFrames, opts.warmupFrames ?? 0);
+    __privateSet(this, _onState, opts.onState);
+    __privateSet(this, _onDiag, opts.onDiag);
+    __privateSet(this, _onError, opts.onError);
+    __privateSet(this, _fecClient, opts.fecClient);
+    __privateSet(this, _reassemblyPolicy, opts.reassemblyPolicy);
+    const auDurationMs = auDurationMsFromCodec(opts.codec, opts.sampleRate);
+    __privateSet(this, _pacer, new FrameCountPacer({
+      frameDurationMs: auDurationMs,
+      mapper: opts.mapper,
+      warmupFrames: __privateGet(this, _warmupFrames)
+    }));
+  }
+  /** Load worklet module + create decoder + pipeline. Call once. */
+  async ready() {
+    if (__privateGet(this, _readyPromise)) return __privateGet(this, _readyPromise);
+    __privateSet(this, _readyPromise, __privateMethod(this, _AudioRenderPipeline_instances, initialize_fn).call(this));
+    return __privateGet(this, _readyPromise);
+  }
+  /** Feed one MoQ object (raw MMTP packet). */
+  feedMoqObject(packet) {
+    __privateGet(this, _pipeline)?.feedMoqObject(packet);
+  }
+  /** ms to sleep before the next object read. 0 when not anchored / not ahead. */
+  paceSleepMs() {
+    return __privateGet(this, _pacer).computeSleepMs();
+  }
+  /** Pacer snapshot (for diagnostics / UI). */
+  get pacerSnapshot() {
+    return __privateGet(this, _pacer).snapshot;
+  }
+  /** Reset pacer on source switch (MoQ ↔ multicast). */
+  resetPacer() {
+    __privateGet(this, _pacer).reset();
+  }
+  /** Drop queued PCM and its timestamp epoch at an explicit source boundary. */
+  resetPlayout(startUnstalled = false) {
+    __privateGet(this, _pacer).reset();
+    __privateSet(this, _startupReleased, true);
+    const message = {
+      type: "reset",
+      generation: ++__privateWrapper(this, _workletGeneration)._,
+      startUnstalled
+    };
+    __privateGet(this, _worklet)?.port.postMessage(message);
+  }
+  /** Node to connect to destination / gain. */
+  get rootNode() {
+    if (!__privateGet(this, _worklet)) throw new Error("AudioRenderPipeline.ready() must resolve first");
+    return __privateGet(this, _worklet);
+  }
+  close() {
+    if (__privateGet(this, _closed)) return;
+    __privateSet(this, _closed, true);
+    try {
+      __privateGet(this, _decoder)?.close();
+    } catch {
+    }
+    try {
+      __privateGet(this, _pipeline)?.dispose();
+    } catch {
+    }
+    try {
+      __privateGet(this, _worklet)?.disconnect();
+    } catch {
+    }
+    __privateSet(this, _decoder, null);
+    __privateSet(this, _pipeline, null);
+    __privateSet(this, _worklet, null);
+  }
+};
+_context = new WeakMap();
+_pacer = new WeakMap();
+_mapper = new WeakMap();
+_codec = new WeakMap();
+_packetId = new WeakMap();
+_sampleRate = new WeakMap();
+_channels = new WeakMap();
+_description = new WeakMap();
+_latencyMs = new WeakMap();
+_startupFrames2 = new WeakMap();
+_startupThresholdFrames = new WeakMap();
+_capacityFrames = new WeakMap();
+_diag = new WeakMap();
+_warmupFrames = new WeakMap();
+_onState = new WeakMap();
+_onDiag = new WeakMap();
+_onError = new WeakMap();
+_reassemblyPolicy = new WeakMap();
+_decoder = new WeakMap();
+_pipeline = new WeakMap();
+_worklet = new WeakMap();
+_fecClient = new WeakMap();
+_closed = new WeakMap();
+_readyPromise = new WeakMap();
+_workletGeneration = new WeakMap();
+_startupReleased = new WeakMap();
+_AudioRenderPipeline_instances = new WeakSet();
+initialize_fn = async function() {
+  await __privateGet(this, _context).audioWorklet.addModule(workletModuleUrl());
+  const worklet = new AudioWorkletNode(__privateGet(this, _context), WORKLET_PROCESSOR_NAME, {
+    numberOfInputs: 0,
+    numberOfOutputs: 1,
+    outputChannelCount: [__privateGet(this, _channels)]
+  });
+  const initMsg = {
+    type: "init",
+    generation: ++__privateWrapper(this, _workletGeneration)._,
+    channels: __privateGet(this, _channels),
+    rate: __privateGet(this, _sampleRate),
+    latencyMs: __privateGet(this, _latencyMs),
+    startupFrames: __privateGet(this, _startupFrames2),
+    capacityFrames: __privateGet(this, _capacityFrames),
+    holdUntilStart: true,
+    diag: __privateGet(this, _diag)
+  };
+  worklet.port.postMessage(initMsg);
+  worklet.port.onmessage = (ev) => {
+    var _a, _b;
+    const m = ev.data;
+    if (m.type === "state") {
+      if (m.generation !== __privateGet(this, _workletGeneration)) return;
+      (_a = __privateGet(this, _onState)) == null ? void 0 : _a.call(this, {
+        timestampUs: m.timestamp,
+        stalled: m.stalled,
+        bufferedFrames: m.bufferedFrames,
+        writtenFrames: m.writtenFrames
+      });
+    } else if (m.type === "ringBufDiag") {
+      if (m.generation !== __privateGet(this, _workletGeneration)) return;
+      (_b = __privateGet(this, _onDiag)) == null ? void 0 : _b.call(this, {
+        reads: m.reads,
+        avgFill: m.avgFill,
+        capacity: m.capacity,
+        skipsPerSec: m.skipsPerSec,
+        dupsPerSec: m.dupsPerSec,
+        overflowSamplesPerSec: m.overflowSamplesPerSec,
+        underflowSamplesPerSec: m.underflowSamplesPerSec
+      });
+    } else if (m.type === "writeAck") {
+      if (m.generation !== __privateGet(this, _workletGeneration) || __privateGet(this, _startupReleased) || m.bufferedFrames < __privateGet(this, _startupThresholdFrames)) return;
+      __privateSet(this, _startupReleased, true);
+      const start = {
+        type: "start",
+        generation: __privateGet(this, _workletGeneration)
+      };
+      worklet.port.postMessage(start);
+    }
+  };
+  __privateSet(this, _worklet, worklet);
+  const decoder = new AudioDecoder({
+    output: (data) => __privateMethod(this, _AudioRenderPipeline_instances, onDecoded_fn).call(this, data),
+    error: (err) => {
+      var _a;
+      return (_a = __privateGet(this, _onError)) == null ? void 0 : _a.call(this, err);
+    }
+  });
+  const config = {
+    codec: __privateGet(this, _codec),
+    sampleRate: __privateGet(this, _sampleRate),
+    numberOfChannels: __privateGet(this, _channels),
+    ...__privateGet(this, _description) ? { description: __privateGet(this, _description) } : {}
+  };
+  decoder.configure(config);
+  __privateSet(this, _decoder, decoder);
+  const pipeline = new MmtpDecodePipeline();
+  pipeline.configure({
+    codec: __privateGet(this, _codec),
+    packetId: __privateGet(this, _packetId),
+    description: __privateGet(this, _description),
+    reorderWindow: 0,
+    // audio doesn't need reorder — AAC/Opus frames are self-contained
+    reassemblyPolicy: __privateGet(this, _reassemblyPolicy)
+  });
+  if (__privateGet(this, _fecClient)) pipeline.setFecClient(__privateGet(this, _fecClient));
+  pipeline.onFrame((codecData, meta) => {
+    var _a;
+    if (!__privateGet(this, _decoder) || __privateGet(this, _decoder).state !== "configured") return;
+    if (codecData.byteLength === 0) return;
+    __privateGet(this, _pacer).notifyFrame();
+    try {
+      __privateGet(this, _decoder).decode(new EncodedAudioChunk({
+        type: "key",
+        data: codecData,
+        timestamp: meta.timestamp
+      }));
+    } catch (err) {
+      (_a = __privateGet(this, _onError)) == null ? void 0 : _a.call(this, err);
+    }
+  });
+  __privateSet(this, _pipeline, pipeline);
+};
+// ─── Private ─────────────────────────────────────────────────────
+onDecoded_fn = function(sample) {
+  if (__privateGet(this, _closed) || !__privateGet(this, _worklet)) {
+    sample.close();
+    return;
+  }
+  const timestamp = sample.timestamp;
+  const channelData = [];
+  for (let ch = 0; ch < sample.numberOfChannels; ch++) {
+    const data = new Float32Array(sample.numberOfFrames);
+    sample.copyTo(data, { format: "f32-planar", planeIndex: ch });
+    channelData.push(data);
+  }
+  sample.close();
+  const msg = {
+    type: "data",
+    data: channelData,
+    timestamp
+  };
+  __privateGet(this, _worklet).port.postMessage(msg, channelData.map((d) => d.buffer));
+};
+export {
+  AudioRenderPipeline,
+  AudioRingBuffer,
+  WORKLET_PROCESSOR_NAME,
+  deriveAudioBurstBufferPlan,
+  workletModuleUrl
+};
+//# sourceMappingURL=index.js.map