@blockcast/mmt-render 0.1.0 → 0.3.0

package/dist/audio/index.js

@@ -1,39 +1,20 @@
-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 {
+  #buffer;
+  #writeIndex = 0;
+  #readIndex = 0;
+  #stalled;
+  #startupFrames;
+  #resumeFrames;
+  #resumeFollowsStartup;
+  #hasStarted;
+  #capacityHeadroomFrames;
+  #timestampAnchors = [];
+  #diagEnabled;
+  #diagReads = 0;
+  #diagFillSum = 0;
+  #diagOverflowSamples = 0;
   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");
     }
@@ -59,35 +40,35 @@ var AudioRingBuffer = class {
     }
     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(
+    this.#startupFrames = startupFrames;
+    this.#resumeFrames = resumeFrames;
+    this.#resumeFollowsStartup = config.resumeFrames === void 0;
+    this.#hasStarted = config.startUnstalled ?? false;
+    this.#capacityHeadroomFrames = capacityFrames - thresholdFrames;
+    this.#stalled = !(config.startUnstalled ?? false);
+    this.#diagEnabled = config.diag ?? false;
+    this.#buffer = Array.from(
       { length: config.channels },
       () => new Float32Array(capacityFrames)
-    ));
+    );
   }
   get stalled() {
-    return __privateGet(this, _stalled);
+    return this.#stalled;
   }
   get startupFrames() {
-    return __privateGet(this, _startupFrames);
+    return this.#startupFrames;
   }
   get capacity() {
-    return __privateGet(this, _buffer)[0].length;
+    return this.#buffer[0].length;
   }
   get length() {
-    return __privateGet(this, _writeIndex) - __privateGet(this, _readIndex);
+    return this.#writeIndex - 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;
+    const anchor = this.#timestampAnchors[0];
+    if (!anchor || anchor.sampleIndex > this.#readIndex) return void 0;
+    return anchor.timestampUs + (this.#readIndex - anchor.sampleIndex) / this.rate * 1e6;
   }
   write(timestampUs, data) {
     if (data.length !== this.channels) throw new Error("wrong channel count");
@@ -97,68 +78,68 @@ var AudioRingBuffer = class {
     if (data.some((channel) => channel.length !== samples)) {
       throw new Error("mismatched channel lengths");
     }
-    const start = __privateGet(this, _writeIndex);
+    const start = this.#writeIndex;
     const end = start + samples;
-    __privateGet(this, _timestampAnchors).push({ sampleIndex: start, timestampUs });
-    const overflow = end - __privateGet(this, _readIndex) - this.capacity;
+    this.#timestampAnchors.push({ sampleIndex: start, timestampUs });
+    const overflow = end - 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);
+      this.#stalled = false;
+      this.#hasStarted = true;
+      this.#readIndex += overflow;
+      if (this.#diagEnabled) this.#diagOverflowSamples += overflow;
+      this.#pruneTimestampAnchors();
     }
-    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);
+    const refillFrames = this.#hasStarted ? this.#resumeFrames : this.#startupFrames;
+    if (this.#stalled && end - this.#readIndex >= refillFrames) {
+      this.#stalled = false;
+      this.#hasStarted = true;
     }
     for (let channel = 0; channel < this.channels; channel++) {
       const src = data[channel];
-      const dst = __privateGet(this, _buffer)[channel];
+      const dst = this.#buffer[channel];
       for (let i = 0; i < samples; i++) {
         dst[(start + i) % dst.length] = src[i];
       }
     }
-    __privateSet(this, _writeIndex, end);
+    this.#writeIndex = end;
   }
   read(output) {
     if (output.length !== this.channels) throw new Error("wrong channel count");
-    if (__privateGet(this, _stalled)) return 0;
+    if (this.#stalled) return 0;
     const available = this.length;
     if (available === 0) {
-      __privateSet(this, _stalled, true);
+      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];
+      const src = this.#buffer[channel];
       for (let i = 0; i < readSamples; i++) {
-        dst[i] = src[(__privateGet(this, _readIndex) + i) % src.length];
+        dst[i] = src[(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);
+    this.#readIndex += readSamples;
+    this.#pruneTimestampAnchors();
+    if (readSamples < requested) this.#stalled = true;
+    if (this.#diagEnabled) {
+      this.#diagReads++;
+      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);
+    this.#writeIndex = 0;
+    this.#readIndex = 0;
+    this.#stalled = !startUnstalled;
+    this.#hasStarted = startUnstalled || resumeAfterReset;
+    this.#timestampAnchors = [];
+    this.#diagReads = 0;
+    this.#diagFillSum = 0;
+    this.#diagOverflowSamples = 0;
   }
   /**
    * Change the startup latency while preserving the configured storage
@@ -173,18 +154,18 @@ var AudioRingBuffer = class {
     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);
+    const newResumeFrames = this.#resumeFollowsStartup ? newStartupFrames : this.#resumeFrames;
+    const newCapacity = Math.max(newStartupFrames, newResumeFrames) + 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);
+    const wasStalled = this.#stalled;
+    this.#startupFrames = newStartupFrames;
+    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);
+      if (wasStalled && this.length >= this.#refillFrames()) {
+        this.#stalled = false;
+        this.#hasStarted = true;
       }
       return;
     }
@@ -193,61 +174,46 @@ var AudioRingBuffer = class {
       () => new Float32Array(newCapacity)
     );
     const samplesToKeep = Math.min(this.length, newCapacity);
-    const copyStart = __privateGet(this, _writeIndex) - samplesToKeep;
+    const copyStart = this.#writeIndex - samplesToKeep;
     for (let channel = 0; channel < this.channels; channel++) {
-      const src = __privateGet(this, _buffer)[channel];
+      const src = 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);
+    this.#buffer = next;
+    this.#readIndex = copyStart;
+    this.#pruneTimestampAnchors();
+    this.#stalled = samplesToKeep === 0 || wasStalled && samplesToKeep < this.#refillFrames();
+    if (!this.#stalled) this.#hasStarted = true;
   }
   getDiagAndReset() {
-    if (!__privateGet(this, _diagEnabled) || __privateGet(this, _diagReads) === 0) return null;
+    if (!this.#diagEnabled || this.#diagReads === 0) return null;
     const result = {
-      reads: __privateGet(this, _diagReads),
-      avgFill: Math.round(__privateGet(this, _diagFillSum) / __privateGet(this, _diagReads)),
+      reads: this.#diagReads,
+      avgFill: Math.round(this.#diagFillSum / this.#diagReads),
       capacity: this.capacity,
       skips: 0,
       dups: 0,
-      overflowSamples: __privateGet(this, _diagOverflowSamples)
+      overflowSamples: this.#diagOverflowSamples
     };
-    __privateSet(this, _diagReads, 0);
-    __privateSet(this, _diagFillSum, 0);
-    __privateSet(this, _diagOverflowSamples, 0);
+    this.#diagReads = 0;
+    this.#diagFillSum = 0;
+    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);
+  #pruneTimestampAnchors() {
+    let keep = 0;
+    while (keep + 1 < this.#timestampAnchors.length && this.#timestampAnchors[keep + 1].sampleIndex <= this.#readIndex) {
+      keep++;
+    }
+    if (keep > 0) this.#timestampAnchors.splice(0, keep);
+  }
+  #refillFrames() {
+    return this.#hasStarted ? this.#resumeFrames : this.#startupFrames;
+  }
 };
 
 // src/audio/audio-buffer-plan.ts
@@ -283,12 +249,11 @@ function deriveAudioBurstBufferPlan(input) {
 import { MmtpDecodePipeline } from "@blockcast/mmt-container/mmtp-decode-pipeline";
 
 // src/pacing/frame-pacer.ts
-var _frameCount, _anchorWallMs, _anchored;
 var FrameCountPacer = class {
+  #frameCount = 0;
+  #anchorWallMs = 0;
+  #anchored = false;
   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");
     }
@@ -298,11 +263,11 @@ var FrameCountPacer = class {
   }
   /** 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);
+    if (!this.#anchored) {
+      this.#anchorWallMs = now();
+      this.#anchored = true;
     }
-    __privateWrapper(this, _frameCount)._++;
+    this.#frameCount++;
   }
   /**
    * Compute sleep ms before reading the next MoQ object.
@@ -310,41 +275,62 @@ var FrameCountPacer = class {
    *   - 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() {
+  computeSleepMs(observedDelayMs) {
     if (this.thresholdMs <= 0) return 0;
-    if (!__privateGet(this, _anchored)) return 0;
-    if (__privateGet(this, _frameCount) <= this.warmupFrames) return 0;
-    const mediaMs = __privateGet(this, _frameCount) * this.frameDurationMs;
-    const wallMs = now() - __privateGet(this, _anchorWallMs);
+    if (!this.#anchored) return 0;
+    if (this.#frameCount <= this.warmupFrames) return 0;
+    if (observedDelayMs !== void 0 && Number.isFinite(observedDelayMs) && observedDelayMs > this.thresholdMs) {
+      return 0;
+    }
+    const mediaMs = this.#frameCount * this.frameDurationMs;
+    const wallMs = now() - 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);
+    this.#frameCount = 0;
+    this.#anchorWallMs = 0;
+    this.#anchored = false;
   }
   get snapshot() {
-    const mediaMs = __privateGet(this, _frameCount) * this.frameDurationMs;
-    const wallMs = __privateGet(this, _anchored) ? now() - __privateGet(this, _anchorWallMs) : 0;
+    const mediaMs = this.#frameCount * this.frameDurationMs;
+    const wallMs = this.#anchored ? now() - this.#anchorWallMs : 0;
     return {
-      frameCount: __privateGet(this, _frameCount),
+      frameCount: this.#frameCount,
       mediaMs,
       wallMs,
       aheadMs: mediaMs - wallMs,
       thresholdMs: this.thresholdMs,
-      anchored: __privateGet(this, _anchored)
+      anchored: this.#anchored
     };
   }
 };
-_frameCount = new WeakMap();
-_anchorWallMs = new WeakMap();
-_anchored = new WeakMap();
 function now() {
   if (typeof performance !== "undefined" && typeof performance.now === "function") {
     return performance.now();
@@ -375,260 +361,226 @@ function workletModuleUrl() {
 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 {
+  #context;
+  #pacer;
+  #mapper;
+  #codec;
+  #packetId;
+  #sampleRate;
+  #channels;
+  #description;
+  #latencyMs;
+  #startupFrames;
+  #startupThresholdFrames;
+  #capacityFrames;
+  #diag;
+  #warmupFrames;
+  #onState;
+  #onDiag;
+  #onError;
+  #reassemblyPolicy;
+  #decoder = null;
+  #pipeline = null;
+  #worklet = null;
+  #fecClient;
+  #closed = false;
+  #readyPromise = null;
+  #workletGeneration = 0;
+  #startupReleased = false;
   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);
+    this.#context = opts.context;
+    this.#mapper = opts.mapper;
+    this.#codec = opts.codec;
+    this.#packetId = opts.packetId;
+    this.#sampleRate = opts.sampleRate;
+    this.#channels = opts.channels;
+    this.#description = opts.description;
+    this.#latencyMs = opts.latencyMs;
+    this.#startupFrames = opts.startupFrames;
+    this.#startupThresholdFrames = opts.startupFrames ?? Math.ceil(opts.sampleRate * (opts.latencyMs / 1e3));
+    this.#capacityFrames = opts.capacityFrames;
+    this.#diag = opts.diag ?? false;
+    this.#warmupFrames = opts.warmupFrames ?? 0;
+    this.#onState = opts.onState;
+    this.#onDiag = opts.onDiag;
+    this.#onError = opts.onError;
+    this.#fecClient = opts.fecClient;
+    this.#reassemblyPolicy = opts.reassemblyPolicy;
     const auDurationMs = auDurationMsFromCodec(opts.codec, opts.sampleRate);
-    __privateSet(this, _pacer, new FrameCountPacer({
+    this.#pacer = new FrameCountPacer({
       frameDurationMs: auDurationMs,
       mapper: opts.mapper,
-      warmupFrames: __privateGet(this, _warmupFrames)
-    }));
+      warmupFrames: 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);
+    if (this.#readyPromise) return this.#readyPromise;
+    this.#readyPromise = this.#initialize();
+    return this.#readyPromise;
+  }
+  async #initialize() {
+    await this.#context.audioWorklet.addModule(workletModuleUrl());
+    const worklet = new AudioWorkletNode(this.#context, WORKLET_PROCESSOR_NAME, {
+      numberOfInputs: 0,
+      numberOfOutputs: 1,
+      outputChannelCount: [this.#channels]
+    });
+    const initMsg = {
+      type: "init",
+      generation: ++this.#workletGeneration,
+      channels: this.#channels,
+      rate: this.#sampleRate,
+      latencyMs: this.#latencyMs,
+      startupFrames: this.#startupFrames,
+      capacityFrames: this.#capacityFrames,
+      holdUntilStart: true,
+      diag: this.#diag
+    };
+    worklet.port.postMessage(initMsg);
+    worklet.port.onmessage = (ev) => {
+      const m = ev.data;
+      if (m.type === "state") {
+        if (m.generation !== this.#workletGeneration) return;
+        this.#onState?.({
+          timestampUs: m.timestamp,
+          stalled: m.stalled,
+          bufferedFrames: m.bufferedFrames,
+          writtenFrames: m.writtenFrames
+        });
+      } else if (m.type === "ringBufDiag") {
+        if (m.generation !== this.#workletGeneration) return;
+        this.#onDiag?.({
+          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 !== this.#workletGeneration || this.#startupReleased || m.bufferedFrames < this.#startupThresholdFrames) return;
+        this.#startupReleased = true;
+        const start = {
+          type: "start",
+          generation: this.#workletGeneration
+        };
+        worklet.port.postMessage(start);
+      }
+    };
+    this.#worklet = worklet;
+    const decoder = new AudioDecoder({
+      output: (data) => this.#onDecoded(data),
+      error: (err) => this.#onError?.(err)
+    });
+    const config = {
+      codec: this.#codec,
+      sampleRate: this.#sampleRate,
+      numberOfChannels: this.#channels,
+      ...this.#description ? { description: this.#description } : {}
+    };
+    decoder.configure(config);
+    this.#decoder = decoder;
+    const pipeline = new MmtpDecodePipeline();
+    pipeline.configure({
+      codec: this.#codec,
+      packetId: this.#packetId,
+      description: this.#description,
+      reorderWindow: 0,
+      // audio doesn't need reorder — AAC/Opus frames are self-contained
+      reassemblyPolicy: this.#reassemblyPolicy
+    });
+    if (this.#fecClient) pipeline.setFecClient(this.#fecClient);
+    pipeline.onFrame((codecData, meta) => {
+      if (!this.#decoder || this.#decoder.state !== "configured") return;
+      if (codecData.byteLength === 0) return;
+      this.#pacer.notifyFrame();
+      try {
+        this.#decoder.decode(new EncodedAudioChunk({
+          type: "key",
+          data: codecData,
+          timestamp: meta.timestamp
+        }));
+      } catch (err) {
+        this.#onError?.(err);
+      }
+    });
+    this.#pipeline = pipeline;
   }
   /** Feed one MoQ object (raw MMTP packet). */
   feedMoqObject(packet) {
-    __privateGet(this, _pipeline)?.feedMoqObject(packet);
+    this.#pipeline?.feedMoqObject(packet);
   }
   /** ms to sleep before the next object read. 0 when not anchored / not ahead. */
   paceSleepMs() {
-    return __privateGet(this, _pacer).computeSleepMs();
+    return this.#pacer.computeSleepMs();
   }
   /** Pacer snapshot (for diagnostics / UI). */
   get pacerSnapshot() {
-    return __privateGet(this, _pacer).snapshot;
+    return this.#pacer.snapshot;
   }
   /** Reset pacer on source switch (MoQ ↔ multicast). */
   resetPacer() {
-    __privateGet(this, _pacer).reset();
+    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);
+    this.#pacer.reset();
+    this.#startupReleased = true;
     const message = {
       type: "reset",
-      generation: ++__privateWrapper(this, _workletGeneration)._,
+      generation: ++this.#workletGeneration,
       startUnstalled
     };
-    __privateGet(this, _worklet)?.port.postMessage(message);
+    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);
+    if (!this.#worklet) throw new Error("AudioRenderPipeline.ready() must resolve first");
+    return this.#worklet;
   }
   close() {
-    if (__privateGet(this, _closed)) return;
-    __privateSet(this, _closed, true);
+    if (this.#closed) return;
+    this.#closed = true;
     try {
-      __privateGet(this, _decoder)?.close();
+      this.#decoder?.close();
     } catch {
     }
     try {
-      __privateGet(this, _pipeline)?.dispose();
+      this.#pipeline?.dispose();
     } catch {
     }
     try {
-      __privateGet(this, _worklet)?.disconnect();
+      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);
+    this.#decoder = null;
+    this.#pipeline = null;
+    this.#worklet = null;
+  }
+  // ─── Private ─────────────────────────────────────────────────────
+  #onDecoded(sample) {
+    if (this.#closed || !this.#worklet) {
+      sample.close();
+      return;
     }
-  };
-  __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 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);
     }
-  });
-  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));
+    const msg = {
+      type: "data",
+      data: channelData,
+      timestamp
+    };
+    this.#worklet.port.postMessage(msg, channelData.map((d) => d.buffer));
+  }
 };
 export {
   AudioRenderPipeline,