@blockcast/mmt-render 0.1.0-main.dd5d220269e4 → 0.1.0-main.e43a31ef704b

package/README.md

@@ -8,7 +8,7 @@ Shared render pipeline for MMT players: FEC-aware wall-clock pacing, per-AU pres
 pnpm add @blockcast/mmt-render
 ```
 
-Peer-installs through normal deps: `@blockcast/mmt-container` (provides `MmtpDecodePipeline` and the FEC-aware MFU reassembler) and `@blockcast/mmt-fec` (provides `FecBlockMapper`, which carries `pacingThresholdMs`, `K`, `D`, `symbolsPerGroup`).
+Peer-installs through normal deps: `@blockcast/mmt-container` (provides `MmtpDecodePipeline` and the FEC-aware MFU reassembler) and `@blockcast/mmt-fec` (provides `FecBlockMapper`, which carries `pacingThresholdMs`, `K`, `D` and the catalog's required `fec.blockProfile`).
 
 ## Quick start (audio)
 
@@ -17,7 +17,8 @@ import { AudioRenderPipeline } from "@blockcast/mmt-render/audio"
 import { FecBlockMapper } from "@blockcast/mmt-fec"
 
 const ctx = new AudioContext({ sampleRate: 48000 })
-const mapper = new FecBlockMapper({ interleaveDepthMs: 66, gopDurationMs: 21.33, k: 32 })
+// blockProfile is the catalog `fec.blockProfile`: required, never defaulted.
+const mapper = new FecBlockMapper({ blockProfile: "k-padded-v1", interleaveDepthMs: 66, gopDurationMs: 21.33, k: 32 })
 
 const audio = new AudioRenderPipeline({
   context: ctx,
@@ -103,7 +104,7 @@ Media-agnostic wall-clock pacer. Anchors on the first `notifyFrame()` call; comp
 
 ### `InterleaveTiming` (`src/pacing/interleave-timing.ts`)
 
-Per-AU presentation-time reconstruction from FEC coordinates. Implements `draft-ramadan-moq-fec-00 §8.3`:
+Per-AU presentation-time reconstruction from FEC coordinates: the `k-padded-v1` K-stride pacing model of `draft-ramadan-moq-fec-00 §8.3`, with `symbolsPerGroup = ceil(K / D)` computed here. It is pacing arithmetic, not an FEC block locator, and refuses a mapper under any other `fec.blockProfile`:
 
 ```
 au_index_in_block = groupInBlock × symbolsPerGroup + objectId
@@ -189,7 +190,7 @@ There is **no CMCD `x-bc-*` emission, no catalog (CMSF) inspector, and no MPU/MF
 ## Related packages
 
 - `@blockcast/mmt-container` — `MmtpDecodePipeline` (consumed for AU framing), MFU reassembly, catalog parser
-- `@blockcast/mmt-fec` — `FecBlockMapper` (provides `pacingThresholdMs`, `K`, `D`, `symbolsPerGroup`); `NullBlockMapper` disables pacing
+- `@blockcast/mmt-fec` — `FecBlockMapper` (provides `pacingThresholdMs`, `K`, `D`, `blockProfile`); `NullBlockMapper` disables pacing
 - `@blockcast/mmt-transport` — produces the MoQ objects that feed `feedMoqObject()`
 
 ## Testing

package/dist/audio/audio-render-pipeline.js

@@ -1,30 +1,12 @@
-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-render-pipeline.ts
 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");
     }
@@ -34,11 +16,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.
@@ -72,39 +54,36 @@ var FrameCountPacer = class {
    */
   computeSleepMs(observedDelayMs) {
     if (this.thresholdMs <= 0) return 0;
-    if (!__privateGet(this, _anchored)) return 0;
-    if (__privateGet(this, _frameCount) <= this.warmupFrames) return 0;
+    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 = __privateGet(this, _frameCount) * this.frameDurationMs;
-    const wallMs = now() - __privateGet(this, _anchorWallMs);
+    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();
@@ -135,260 +114,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, _startupFrames, _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, _startupFrames);
-    __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, _startupFrames, 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);
+    this.#decoder = null;
+    this.#pipeline = null;
+    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();
-_startupFrames = 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, _startupFrames),
-    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);
+  // ─── Private ─────────────────────────────────────────────────────
+  #onDecoded(sample) {
+    if (this.#closed || !this.#worklet) {
+      sample.close();
+      return;
     }
-  });
-  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);
+    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);
     }
-  });
-  __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);
+    const msg = {
+      type: "data",
+      data: channelData,
+      timestamp
+    };
+    this.#worklet.port.postMessage(msg, channelData.map((d) => d.buffer));
   }
-  sample.close();
-  const msg = {
-    type: "data",
-    data: channelData,
-    timestamp
-  };
-  __privateGet(this, _worklet).port.postMessage(msg, channelData.map((d) => d.buffer));
 };
 export {
   AudioRenderPipeline