@blockcast/mmt-render 0.1.0-main.00b4b0b04934

package/README.md

@@ -0,0 +1,208 @@
+# @blockcast/mmt-render
+
+Shared render pipeline for MMT players: FEC-aware wall-clock pacing, per-AU presentation-time reconstruction under FEC interleave, an `AudioWorkletProcessor` with an exact-timestamp PCM FIFO, and a keyframe-gated `VideoDecoder` driver. The package is the canonical substrate for moqtail, `hang-mmt-fec`, and Shaka integrations so they do not independently invent timing, buffering, or sample-correction policy. It is *not* a "reference renderer + diagnostics UI" — there is no DOM, chart, or catalog browser. Diagnostics are structured snapshots and worklet telemetry messages that callers can render however they like.
+
+## Install
+
+```bash
+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` and the catalog's required `fec.blockProfile`).
+
+## Quick start (audio)
+
+```ts
+import { AudioRenderPipeline } from "@blockcast/mmt-render/audio"
+import { FecBlockMapper } from "@blockcast/mmt-fec"
+
+const ctx = new AudioContext({ sampleRate: 48000 })
+// 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,
+  codec: "mp4a.40.2",
+  packetId: 0x0011,
+  sampleRate: 48000,
+  channels: 2,
+  description: aacEsdsDescription,   // from catalog / init segment
+  mapper,
+  reassemblyPolicy: { transport: "reliable-moq" },
+  latencyMs: mapper.interleaveDepthMs, // one catalog FEC block
+  diag: true,
+  onDiag: (d) => console.log("ring", d),
+})
+
+await audio.ready()
+audio.rootNode.connect(ctx.destination)
+
+for await (const obj of moqSubscription) {
+  audio.feedMoqObject(obj.payload)
+  const sleep = audio.paceSleepMs()
+  if (sleep > 0) await new Promise((r) => setTimeout(r, sleep))
+}
+```
+
+## Quick start (video)
+
+```ts
+import { VideoRenderPipeline } from "@blockcast/mmt-render/video"
+
+const video = new VideoRenderPipeline({
+  codec: "hev1.1.6.L120.90",
+  packetId: 0x0010,
+  description: hvccBox,
+  width: 1920,
+  height: 1080,
+  framerate: 30,
+  mapper,
+  reassemblyPolicy: { transport: "reliable-moq" },
+  onFrame: (frame) => {
+    canvas.getContext("2d")?.drawImage(frame, 0, 0)
+    frame.close()
+  },
+  onError: (e) => console.warn(e),
+})
+
+for await (const obj of moqSubscription) {
+  video.feedMoqObject(obj.payload)
+  const sleep = video.paceSleepMs()
+  if (sleep > 0) await new Promise((r) => setTimeout(r, sleep))
+}
+```
+
+## Exports
+
+Per `package.json`:
+
+| Subpath | Symbols |
+|---------|---------|
+| `@blockcast/mmt-render` | re-exports of `./pacing`, `./audio`, `./video` |
+| `@blockcast/mmt-render/pacing` | `FrameCountPacer`, `InterleaveTiming`, `auDurationMsFromCodec`, `pictureDurationMs` |
+| `@blockcast/mmt-render/pacing/frame-pacer` | `FrameCountPacer` only |
+| `@blockcast/mmt-render/pacing/interleave-timing` | `InterleaveTiming` only |
+| `@blockcast/mmt-render/audio` | `AudioRenderPipeline`, `AudioRingBuffer`, message types, `WORKLET_PROCESSOR_NAME`, `workletModuleUrl` |
+| `@blockcast/mmt-render/audio/ring-buffer` | `AudioRingBuffer` only |
+| `@blockcast/mmt-render/audio/render-messages` | `FromMain` / `ToMain` message types |
+| `@blockcast/mmt-render/audio/render-pipeline` | `AudioRenderPipeline` only |
+| `@blockcast/mmt-render/audio/worklet-url` | `workletModuleUrl()`, `WORKLET_PROCESSOR_NAME` |
+| `@blockcast/mmt-render/audio/worklet.js` | Prebuilt self-contained worklet IIFE — pass to `audioWorklet.addModule()` |
+| `@blockcast/mmt-render/video` | `VideoRenderPipeline`, `KeyframeGate`, frame meta types |
+| `@blockcast/mmt-render/video/keyframe-gate` | `KeyframeGate` only |
+| `@blockcast/mmt-render/video/render-pipeline` | `VideoRenderPipeline` only |
+
+The fine-grained subpaths exist so a lean consumer (e.g. moqtail's `player.ts`) can import just the pacer + AU-duration helpers without pulling in `@blockcast/mmt-container` (see `src/audio/index.ts:5-7`).
+
+## Components
+
+### `FrameCountPacer` (`src/pacing/frame-pacer.ts`)
+
+Media-agnostic wall-clock pacer. Anchors on the first `notifyFrame()` call; computes media time as `frameCount × frameDurationMs`. Sleeps the read loop when the decoder runs ahead of wall-clock by more than `mapper.pacingThresholdMs`. Returns `0` for `NullBlockMapper` (pacing disabled). Why not derive media time from MPU timestamps? Under FEC interleaving, encoders pack multiple AUs per MMTP MPU with a single `mpu_timestamp`; the observed delta is a fraction of the real per-AU duration, so timestamp-driven pacing never sleeps and lets burst delivery saturate the decoder. See the file-level comment for the Sony libatsc3 reference.
+
+`PacerSnapshot` exposes `frameCount`, `mediaMs`, `wallMs`, `aheadMs`, `thresholdMs`, `anchored` for diagnostics overlays.
+
+### `InterleaveTiming` (`src/pacing/interleave-timing.ts`)
+
+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
+ssId              = sbn × K + au_index_in_block
+presentationUs    = anchorMpuUs + ssId × frameDurationUs
+```
+
+Same answer whether the AU arrived via MoQ unicast (group_id/object_id) or multicast UDP (SS_ID from the FEC Payload ID). Methods: `presentationUs(groupId, objectId)`, `presentationUsFromSsId(ssId)`, `frameAtOffset(offsetUs)` (inverse), `blockTimeRangeUs(sbn)`. Consumers: CMAF segment cut points, debug overlays, cross-path FEC combining.
+
+### `auDurationMsFromCodec` / `pictureDurationMs` (`src/pacing/au-duration.ts`)
+
+Nominal AU duration helpers. AAC-LC = 1024 samples; Opus default = 960; FLAC = 4096. Throws on unknown codec — no silent fallback. Lives in the pacing subpath specifically to avoid pulling in `mmt-container`.
+
+### `AudioRingBuffer` (`src/audio/audio-ring-buffer.ts`)
+
+Timestamp-anchored PCM FIFO. Decoder output stays in emission order, and every decoded chunk adds an exact MMTP timestamp anchor for playout reporting. Timestamps never reposition samples, guess discontinuities, or trigger sample correction. Startup waits for the full caller-supplied, catalog-derived capacity. Underflow re-stalls until that capacity is full again. Source changes use an explicit `reset`; there is no elapsed-time heuristic. The compatibility `skips` and `dups` telemetry fields remain present but are always zero.
+
+Optional telemetry via `getDiagAndReset()`: `reads`, `avgFill`, `capacity`, `skips`, `dups`, `overflowSamples`.
+
+### `AudioRenderPipeline` (`src/audio/audio-render-pipeline.ts`)
+
+End-to-end glue: `MoQ object → MmtpDecodePipeline → WebCodecs AudioDecoder → AudioWorkletNode (ring buffer)`. Owns the worklet, decoder, decode pipeline, and pacer. Audio uses `reorderWindow: 0` because AAC/Opus frames are self-contained.
+
+API:
+
+```ts
+await pipeline.ready()                  // load worklet + create decoder
+pipeline.feedMoqObject(packet)          // hot path
+pipeline.paceSleepMs()                  // throttle read loop
+pipeline.rootNode.connect(destination)  // connect to AudioContext
+pipeline.resetPacer()                   // on source switch (MoQ ↔ multicast)
+pipeline.resetPlayout()                 // drop queued PCM + old timestamp epoch
+pipeline.close()                        // teardown
+```
+
+`onState` and `onDiag` callbacks surface worklet messages (`StateMessage`, `DiagMessage`) for player UIs.
+
+### `KeyframeGate` (`src/video/keyframe-gate.ts`)
+
+Tiny state machine. Drops delta frames until the first keyframe arrives, then opens permanently. `reset()` re-arms after a decoder error so the next IDR reopens the gate. Required for mid-stream subscribe — relays may deliver P/B frames from the middle of a GOP before the first IDR, which yields "key frame required" decoder errors otherwise.
+
+### `VideoRenderPipeline` (`src/video/video-render-pipeline.ts`)
+
+End-to-end glue for video: `MoQ object → MmtpDecodePipeline → KeyframeGate → WebCodecs VideoDecoder → onFrame(VideoFrame)`. Datagram delivery uses a catalog-derived frame reorder window and explicit catalog/in-band deadline. Reliable MoQ uses protocol-verified sequential groups with no frame window or timeout. Decoder errors trigger an internal `reset()` that closes the gate, resets the pacer, and reconfigures the decoder so the next keyframe re-opens playback.
+
+This replaces the `decodeQueueSize > 10 drop-deltas` workaround in moqtail's `webcodecs-backend.ts` and the `reorderWindow = 0 // TODO` in hang-mmt-fec's `video/decoder.ts` (see file header at `src/video/video-render-pipeline.ts:1-15`).
+
+## AudioWorklet bundle
+
+`AudioWorkletGlobalScope` cannot resolve bare specifiers, so the worklet is shipped as a self-contained IIFE at `dist/worklet/render-worklet.js`. Two ways to load it:
+
+```ts
+// 1. Vite-style static URL (recommended for bundled apps)
+import workletUrl from "@blockcast/mmt-render/audio/worklet.js?url"
+await ctx.audioWorklet.addModule(workletUrl)
+
+// 2. import.meta.url resolution (no bundler)
+import { workletModuleUrl } from "@blockcast/mmt-render/audio/worklet-url"
+await ctx.audioWorklet.addModule(workletModuleUrl())
+```
+
+`AudioRenderPipeline.ready()` uses option (2) internally. Processor name is exported as `WORKLET_PROCESSOR_NAME = "mmt-render"`.
+
+## Diagnostics surface
+
+The package does not render its own UI. It exposes typed data the host can render:
+
+- `FrameCountPacer.snapshot` → `PacerSnapshot` (frameCount, mediaMs, wallMs, aheadMs, thresholdMs, anchored)
+- `AudioRingBuffer.getDiagAndReset()` → `AudioRingBufferDiag` (reads, avgFill, capacity, skips, dups, overflowSamples)
+- Worklet `StateMessage` (exact timestamp, stalled, bufferedFrames) every ~13 ms
+- Worklet `DiagMessage` (fill/overflow/underflow telemetry; skip/dup remain zero) when `diag: true` was passed at init
+- `audio underflow: <ms>ms` `console.warn` when the worklet runs dry (`src/audio/render-worklet.ts:58`)
+
+There is **no CMCD `x-bc-*` emission, no catalog (CMSF) inspector, and no MPU/MFU packet inspector** in this package. CMCD lives in `@blockcast/mmt-container/cmcd-producer`; catalog parsing lives in `@blockcast/mmt-container/carp`. This package is purely the render side.
+
+## Use cases
+
+- **Player implementations.** moqtail and hang-mmt-fec both consume this — adding a third player only requires wiring a transport into `feedMoqObject()`.
+- **Debugging multicast losses.** `PacerSnapshot.aheadMs` going negative + ring-buffer underflow warns indicate the decoder can't keep up; large positive `aheadMs` indicates burst delivery and pacing is throttling correctly.
+- **Customer demos / overlays.** `onState` + `onDiag` callbacks feed real-time HUDs without the host having to instrument the pipeline.
+- **Source-switch testing.** `resetPlayout()` / `VideoRenderPipeline.reset()` clear the old epoch when flipping between MoQ unicast and SSM multicast.
+
+## Related packages
+
+- `@blockcast/mmt-container` — `MmtpDecodePipeline` (consumed for AU framing), MFU reassembly, catalog parser
+- `@blockcast/mmt-fec` — `FecBlockMapper` (provides `pacingThresholdMs`, `K`, `D`, `blockProfile`); `NullBlockMapper` disables pacing
+- `@blockcast/mmt-transport` — produces the MoQ objects that feed `feedMoqObject()`
+
+## Testing
+
+```bash
+pnpm test            # vitest, runs src/__tests__/*.test.ts
+pnpm test:watch
+pnpm build           # tsc --emitDeclarationOnly + esbuild bundles (incl. worklet IIFE)
+```
+
+Existing suites: `frame-pacer.test.ts`, `interleave-timing.test.ts`, `audio-ring-buffer.test.ts`, `keyframe-gate.test.ts`. The pacer suite uses `vi.spyOn(performance, "now")` to drive deterministic wall time. There is no DOM / `AudioContext` integration test — the worklet is exercised in-browser by the consuming players' E2E suites.
+
+## License
+
+Apache-2.0 — see `LICENSE`. (libmmt npm packages are all Apache-2.0; the Rust crates are dual `MIT OR Apache-2.0`.)

package/dist/audio/audio-buffer-plan.d.ts

@@ -0,0 +1,27 @@
+export interface AudioBurstBufferPlanInput {
+    sampleRate: number;
+    chunkFrames: number;
+    /** Catalog media-group duration. Integer milliseconds may be rounded. */
+    groupDurationMs: number;
+    /** Optional catalog-derived datagram/FEC delivery span. */
+    deliveryWindowMs?: number;
+}
+export interface AudioBurstBufferPlan {
+    /** PCM required before playout starts or resumes. */
+    startupFrames: number;
+    /** Maximum retained PCM, including the next complete delivery burst. */
+    capacityFrames: number;
+    /** Maximum PCM frames delivered as one catalog-defined burst. */
+    deliveryFrames: number;
+}
+/**
+ * Convert catalog delivery timing into exact codec-frame FIFO geometry.
+ *
+ * `groupDurationMs` is commonly rounded to an integer, so media-group units
+ * use nearest-unit rounding. FEC delivery windows are upper bounds and use
+ * ceiling. Storage holds the startup burst plus one complete successor burst;
+ * this prevents an atomic MoQ group from overwriting PCM while the worklet is
+ * draining the preceding group without adding a guessed time margin.
+ */
+export declare function deriveAudioBurstBufferPlan(input: AudioBurstBufferPlanInput): AudioBurstBufferPlan;
+//# sourceMappingURL=audio-buffer-plan.d.ts.map

package/dist/audio/audio-buffer-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio-buffer-plan.d.ts","sourceRoot":"","sources":["../../src/audio/audio-buffer-plan.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,yBAAyB;IACxC,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;IACnB,yEAAyE;IACzE,eAAe,EAAE,MAAM,CAAA;IACvB,2DAA2D;IAC3D,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC,qDAAqD;IACrD,aAAa,EAAE,MAAM,CAAA;IACrB,wEAAwE;IACxE,cAAc,EAAE,MAAM,CAAA;IACtB,iEAAiE;IACjE,cAAc,EAAE,MAAM,CAAA;CACvB;AAOD;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,yBAAyB,GAC/B,oBAAoB,CA2BtB"}

package/dist/audio/audio-render-pipeline.d.ts

@@ -0,0 +1,83 @@
+/**
+ * AudioRenderPipeline — end-to-end audio render for MoQ/MMT players.
+ *
+ * Pipeline: MoQ object → MmtpDecodePipeline → WebCodecs AudioDecoder
+ *           → AudioWorkletNode (exact-timestamp FIFO)
+ *
+ * The consumer:
+ *   1. constructs with codec/sampleRate/channels/mapper from catalog
+ *   2. awaits ready()
+ *   3. calls feedMoqObject(packet) for each arriving MoQ object
+ *   4. between objects, awaits paceSleepMs() to throttle burst delivery
+ *   5. connects rootNode to an AudioContext destination (or a GainNode)
+ *   6. close() on teardown
+ *
+ * Pacing uses FrameCountPacer (anchor on first decoded AU, frame count × AU
+ * duration) with threshold = mapper.pacingThresholdMs — NOT MPU timestamps
+ * (ambiguous under FEC interleave).
+ */
+import { type PipelineFecClient } from '@blockcast/mmt-container/mmtp-decode-pipeline';
+import type { MfuReassemblyPolicy } from '@blockcast/mmt-container/mfu-reassembly-policy';
+import type { FecBlockMapper } from '@blockcast/mmt-fec';
+export interface AudioRenderPipelineOpts {
+    context: AudioContext;
+    codec: string;
+    /** MMTP packet_id for this audio track — from catalog. */
+    packetId?: number;
+    sampleRate: number;
+    channels: number;
+    description?: Uint8Array;
+    mapper: FecBlockMapper;
+    fecClient?: PipelineFecClient;
+    /** Reliable MoQ is clock-free; datagram deadlines come from catalog/in-band timing. */
+    reassemblyPolicy: MfuReassemblyPolicy;
+    /** Catalog-derived PCM startup buffer in milliseconds. */
+    latencyMs: number;
+    /** Exact PCM startup threshold when catalog grouping is codec-aligned. */
+    startupFrames?: number;
+    /** Exact PCM storage ceiling, including one successor delivery burst. */
+    capacityFrames?: number;
+    /** Enable ring-buffer telemetry messages. Default false. */
+    diag?: boolean;
+    /** Called when worklet reports state (playback timestamp + exact buffer accounting). Optional. */
+    onState?: (state: {
+        timestampUs: number | undefined;
+        stalled: boolean;
+        bufferedFrames: number;
+        writtenFrames: number;
+    }) => void;
+    /** Called when worklet reports ring-buffer diag (telemetry). Optional. */
+    onDiag?: (diag: {
+        reads: number;
+        avgFill: number;
+        capacity: number;
+        skipsPerSec: number;
+        dupsPerSec: number;
+        overflowSamplesPerSec: number;
+        underflowSamplesPerSec: number;
+    }) => void;
+    /** Warmup frames before pacing engages. Default 0 (audio tolerates instant pacing). */
+    warmupFrames?: number;
+    /** Audio underflow / config event logger. Optional. */
+    onError?: (err: unknown) => void;
+}
+export declare class AudioRenderPipeline {
+    #private;
+    constructor(opts: AudioRenderPipelineOpts);
+    /** Load worklet module + create decoder + pipeline. Call once. */
+    ready(): Promise<void>;
+    /** Feed one MoQ object (raw MMTP packet). */
+    feedMoqObject(packet: Uint8Array): void;
+    /** ms to sleep before the next object read. 0 when not anchored / not ahead. */
+    paceSleepMs(): number;
+    /** Pacer snapshot (for diagnostics / UI). */
+    get pacerSnapshot(): import("../pacing/frame-pacer.js").PacerSnapshot;
+    /** Reset pacer on source switch (MoQ ↔ multicast). */
+    resetPacer(): void;
+    /** Drop queued PCM and its timestamp epoch at an explicit source boundary. */
+    resetPlayout(startUnstalled?: boolean): void;
+    /** Node to connect to destination / gain. */
+    get rootNode(): AudioNode;
+    close(): void;
+}
+//# sourceMappingURL=audio-render-pipeline.d.ts.map

package/dist/audio/audio-render-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio-render-pipeline.d.ts","sourceRoot":"","sources":["../../src/audio/audio-render-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAsB,KAAK,iBAAiB,EAAE,MAAM,+CAA+C,CAAA;AAC1G,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gDAAgD,CAAA;AACzF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAYxD,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,YAAY,CAAA;IACrB,KAAK,EAAE,MAAM,CAAA;IACb,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,UAAU,CAAA;IACxB,MAAM,EAAE,cAAc,CAAA;IACtB,SAAS,CAAC,EAAE,iBAAiB,CAAA;IAC7B,uFAAuF;IACvF,gBAAgB,EAAE,mBAAmB,CAAA;IACrC,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAA;IACjB,0EAA0E;IAC1E,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,yEAAyE;IACzE,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,4DAA4D;IAC5D,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,kGAAkG;IAClG,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE;QAChB,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;QAC/B,OAAO,EAAE,OAAO,CAAA;QAChB,cAAc,EAAE,MAAM,CAAA;QACtB,aAAa,EAAE,MAAM,CAAA;KACtB,KAAK,IAAI,CAAA;IACV,0EAA0E;IAC1E,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE;QACd,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;QAChD,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,qBAAqB,EAAE,MAAM,CAAA;QACtE,sBAAsB,EAAE,MAAM,CAAA;KAC/B,KAAK,IAAI,CAAA;IACV,uFAAuF;IACvF,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,uDAAuD;IACvD,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAA;CACjC;AAED,qBAAa,mBAAmB;;gBA6BlB,IAAI,EAAE,uBAAuB;IA+BzC,kEAAkE;IAC5D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAuG5B,6CAA6C;IAC7C,aAAa,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAIvC,gFAAgF;IAChF,WAAW,IAAI,MAAM;IAIrB,6CAA6C;IAC7C,IAAI,aAAa,qDAEhB;IAED,sDAAsD;IACtD,UAAU,IAAI,IAAI;IAIlB,8EAA8E;IAC9E,YAAY,CAAC,cAAc,UAAQ,GAAG,IAAI;IAa1C,6CAA6C;IAC7C,IAAI,QAAQ,IAAI,SAAS,CAGxB;IAED,KAAK,IAAI,IAAI;CAgCd"}

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

@@ -0,0 +1,341 @@
+// src/audio/audio-render-pipeline.ts
+import { MmtpDecodePipeline } from "@blockcast/mmt-container/mmtp-decode-pipeline";
+
+// src/pacing/frame-pacer.ts
+var FrameCountPacer = class {
+  #frameCount = 0;
+  #anchorWallMs = 0;
+  #anchored = false;
+  constructor(opts) {
+    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 (!this.#anchored) {
+      this.#anchorWallMs = now();
+      this.#anchored = true;
+    }
+    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 (!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() {
+    this.#frameCount = 0;
+    this.#anchorWallMs = 0;
+    this.#anchored = false;
+  }
+  get snapshot() {
+    const mediaMs = this.#frameCount * this.frameDurationMs;
+    const wallMs = this.#anchored ? now() - this.#anchorWallMs : 0;
+    return {
+      frameCount: this.#frameCount,
+      mediaMs,
+      wallMs,
+      aheadMs: mediaMs - wallMs,
+      thresholdMs: this.thresholdMs,
+      anchored: this.#anchored
+    };
+  }
+};
+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 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) {
+    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);
+    this.#pacer = new FrameCountPacer({
+      frameDurationMs: auDurationMs,
+      mapper: opts.mapper,
+      warmupFrames: this.#warmupFrames
+    });
+  }
+  /** Load worklet module + create decoder + pipeline. Call once. */
+  async ready() {
+    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) {
+    this.#pipeline?.feedMoqObject(packet);
+  }
+  /** ms to sleep before the next object read. 0 when not anchored / not ahead. */
+  paceSleepMs() {
+    return this.#pacer.computeSleepMs();
+  }
+  /** Pacer snapshot (for diagnostics / UI). */
+  get pacerSnapshot() {
+    return this.#pacer.snapshot;
+  }
+  /** Reset pacer on source switch (MoQ ↔ multicast). */
+  resetPacer() {
+    this.#pacer.reset();
+  }
+  /** Drop queued PCM and its timestamp epoch at an explicit source boundary. */
+  resetPlayout(startUnstalled = false) {
+    this.#pacer.reset();
+    this.#startupReleased = true;
+    const message = {
+      type: "reset",
+      generation: ++this.#workletGeneration,
+      startUnstalled
+    };
+    this.#worklet?.port.postMessage(message);
+  }
+  /** Node to connect to destination / gain. */
+  get rootNode() {
+    if (!this.#worklet) throw new Error("AudioRenderPipeline.ready() must resolve first");
+    return this.#worklet;
+  }
+  close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    try {
+      this.#decoder?.close();
+    } catch {
+    }
+    try {
+      this.#pipeline?.dispose();
+    } catch {
+    }
+    try {
+      this.#worklet?.disconnect();
+    } catch {
+    }
+    this.#decoder = null;
+    this.#pipeline = null;
+    this.#worklet = null;
+  }
+  // ─── Private ─────────────────────────────────────────────────────
+  #onDecoded(sample) {
+    if (this.#closed || !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
+    };
+    this.#worklet.port.postMessage(msg, channelData.map((d) => d.buffer));
+  }
+};
+export {
+  AudioRenderPipeline
+};
+//# sourceMappingURL=audio-render-pipeline.js.map