@blockcast/mmt-container 0.1.0 → 0.3.0-main.ef68de90edb3

package/dist/fec-worker-setup.js

@@ -0,0 +1,673 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../fec-worker/dist/fec-worker-client.js
+function formatWorkerError(event) {
+  const parts = ["Worker error"];
+  if (event.message)
+    parts.push(event.message);
+  if (event.filename) {
+    const location2 = [event.filename];
+    if (event.lineno)
+      location2.push(String(event.lineno));
+    if (event.colno)
+      location2.push(String(event.colno));
+    parts.push(`at ${location2.join(":")}`);
+  }
+  if (event.error instanceof Error) {
+    if (event.error.message && event.error.message !== event.message) {
+      parts.push(event.error.message);
+    }
+    if (event.error.stack)
+      parts.push(event.error.stack);
+  } else if (event.error != null) {
+    parts.push(String(event.error));
+  }
+  return parts.join(": ");
+}
+function formatWorkerMessageError(event) {
+  const data = event.data;
+  const detail = data == null ? "" : data instanceof Error ? `: ${data.message}` : `: ${Object.prototype.toString.call(data)}`;
+  return `Worker messageerror: failed to deserialize worker message${detail}`;
+}
+var FecWorkerClient;
+var init_fec_worker_client = __esm({
+  "../fec-worker/dist/fec-worker-client.js"() {
+    "use strict";
+    FecWorkerClient = class {
+      #worker;
+      #onFrame = null;
+      #onSnapshot = null;
+      #onBlockUpdate = null;
+      #onCleanupComplete = null;
+      #onError = null;
+      #cleanupInFlight = null;
+      #queuedCleanupSbns = /* @__PURE__ */ new Set();
+      #pendingResets = 0;
+      #resetFailed = false;
+      #disposed = false;
+      // Symbols fed during the current task, sent as one feedSymbols message
+      // when the task's microtasks run (BLO-36599). A packet stream delivers many
+      // symbols per task, and each postMessage is a structured-clone round trip
+      // on the page thread; the batch boundary is the task, not a size or timer.
+      #pendingSymbols = [];
+      #pendingTransfer = [];
+      #flushQueued = false;
+      // Batching starts only once the Worker announced it accepts feedSymbols.
+      #batchSymbols = false;
+      // The Worker posts blockUpdate events only to a client that subscribed,
+      // which this client does once a callback is registered and the Worker
+      // announced the command (BLO-36599).
+      #blockUpdatesAnnounced = false;
+      #blockUpdatesSubscribed = false;
+      /**
+       * Create a FecWorkerClient.
+       * @param workerOrUrl - Either a Worker instance (for testing) or a URL to create one
+       */
+      constructor(workerOrUrl) {
+        if (workerOrUrl instanceof URL) {
+          this.#worker = new Worker(workerOrUrl, { type: "module" });
+        } else {
+          this.#worker = workerOrUrl;
+        }
+        this.#worker.onmessage = (e) => this.#handleEvent(e.data);
+        this.#worker.onerror = (e) => {
+          this.#onError?.(formatWorkerError(e), "worker-runtime");
+        };
+        this.#worker.onmessageerror = (e) => {
+          this.#onError?.(formatWorkerMessageError(e), "worker-message");
+        };
+      }
+      /**
+       * Configure the Worker with FEC parameters and WASM module.
+       * wasmModule is transferred (not neutered — WebAssembly.Module is shareable).
+       * altaPublicKey is PKCS#8 SPKI DER bytes (self-describing — algorithm detected from OID).
+       *   Transferred (detached from sender).
+       * altaWasmModule is structured-cloneable (NOT transferable — do not add to transfer list).
+       */
+      configure(config, wasmModule, altaPublicKey, altaWasmModule) {
+        if (this.#disposed)
+          throw new Error("[FecWorkerClient] disposed");
+        this.#flushSymbols();
+        const cmd = {
+          type: "configure",
+          config,
+          wasmModule,
+          altaPublicKey,
+          altaWasmModule
+        };
+        const transferList = [];
+        if (altaPublicKey)
+          transferList.push(altaPublicKey);
+        this.#worker.postMessage(cmd, transferList);
+      }
+      /**
+       * Feed a source symbol to the Worker. data ArrayBuffer is transferred (zero-copy).
+       * Caller must not access data after this call — it is transferred with the
+       * task's symbol batch, before any later command of this client.
+       *
+       * Optional `alta` carries the detached ALTA authenticator bytes and the
+       * byte offset in `data` where the signed payload ends. The auth buffer is
+       * transferred zero-copy alongside `data`. Use {@link getMmtpAltaTrailer}
+       * upstream (mmtp-router) to extract it from the wire packet.
+       */
+      feedSource(ssId, data, ts, alta) {
+        if (this.#disposed)
+          throw new Error("[FecWorkerClient] feedSource on a disposed client");
+        if (alta) {
+          this.#queueSymbol({
+            type: "feedSource",
+            ssId,
+            data,
+            ts,
+            altaAuth: alta.auth,
+            altaPayloadEnd: alta.payloadEnd
+          }, data, alta.auth);
+        } else {
+          this.#queueSymbol({ type: "feedSource", ssId, data, ts }, data);
+        }
+      }
+      /**
+       * Feed a repair symbol to the Worker. data ArrayBuffer is transferred (zero-copy).
+       * Caller must not access data after this call — it is detached.
+       *
+       * Carries the wire-level Repair FEC Payload ID fields (ISO 23008-1 §C.5.3):
+       * - ssStart:   SS_ID of first source symbol in the block (= SBN * configured K
+       *              under `k-padded-v1`; any uint32, the block key, under `iso-ssbg1-v1`)
+       * - ssbLength: authored source-symbol count (1..configured K)
+       * - rsId:      repair symbol index within the block
+       */
+      feedRepair(ssStart, ssbLength, rsId, data, ts) {
+        if (this.#disposed)
+          throw new Error("[FecWorkerClient] feedRepair on a disposed client");
+        this.#queueSymbol({ type: "feedRepair", ssStart, ssbLength, rsId, data, ts }, data);
+      }
+      #queueSymbol(symbol, data, auth) {
+        if (!this.#batchSymbols) {
+          this.#worker.postMessage(symbol, auth ? [data, auth] : [data]);
+          return;
+        }
+        this.#pendingSymbols.push(symbol);
+        this.#pendingTransfer.push(data);
+        if (auth)
+          this.#pendingTransfer.push(auth);
+        if (this.#flushQueued)
+          return;
+        this.#flushQueued = true;
+        queueMicrotask(() => {
+          this.#flushQueued = false;
+          this.#flushSymbols();
+        });
+      }
+      /**
+       * Send the symbols fed so far. Every other command calls this first, so a
+       * cleanup barrier, reset or signature still follows all earlier symbols.
+       */
+      #flushSymbols() {
+        if (this.#pendingSymbols.length === 0 || this.#disposed)
+          return;
+        const symbols = this.#pendingSymbols;
+        const transfer = this.#pendingTransfer;
+        this.#pendingSymbols = [];
+        this.#pendingTransfer = [];
+        this.#worker.postMessage({ type: "feedSymbols", symbols }, transfer);
+      }
+      /**
+       * Submit relay block signature for verification. sig and hash are transferred.
+       */
+      relayBlockSig(sbn, sig, hash) {
+        if (this.#disposed)
+          throw new Error("[FecWorkerClient] relayBlockSig on a disposed client");
+        this.#flushSymbols();
+        this.#worker.postMessage({ type: "relayBlockSig", sbn, sig, hash }, [sig, hash]);
+      }
+      /**
+       * Trigger cleanup after a block's inactivity deadline. `currentSbn` is the
+       * block key: the SBN under `k-padded-v1`, the SS_Start under `iso-ssbg1-v1`.
+       *
+       * While one queue-drain barrier is in flight, later SBNs are coalesced into
+       * the next command without losing their individual acknowledgement identity.
+       */
+      cleanup(currentSbn) {
+        if (this.#disposed)
+          throw new Error("[FecWorkerClient] cleanup on a disposed client");
+        if (!Number.isInteger(currentSbn) || currentSbn < 0 || currentSbn > 4294967295) {
+          throw new Error("[FecWorkerClient] cleanup: SBN must be a uint32");
+        }
+        if (this.#cleanupInFlight) {
+          this.#queuedCleanupSbns.add(currentSbn);
+          return;
+        }
+        this.#postCleanup(/* @__PURE__ */ new Set([currentSbn]));
+      }
+      /** Reset this track's decoder epoch while preserving Worker configuration. */
+      reset() {
+        if (this.#disposed)
+          throw new Error("[FecWorkerClient] reset on a disposed client");
+        this.#flushSymbols();
+        this.#pendingResets++;
+        this.#cleanupInFlight = null;
+        this.#queuedCleanupSbns.clear();
+        this.#worker.postMessage({ type: "reset" });
+      }
+      #postCleanup(sbns) {
+        this.#flushSymbols();
+        this.#cleanupInFlight = sbns;
+        const orderedSbns = [...sbns].sort((a, b) => a - b);
+        this.#worker.postMessage({ type: "cleanup", sbns: orderedSbns });
+      }
+      /** Register callback for decoded/recovered frames (FEC-03). */
+      onFrame(cb) {
+        this.#onFrame = cb;
+      }
+      /** Register callback for periodic stats snapshots (FEC-04). */
+      onSnapshot(cb) {
+        this.#onSnapshot = cb;
+      }
+      /**
+       * Register callback for individual block state changes. The Worker posts
+       * them only once asked, so registering subscribes (after the Worker
+       * announces `subscribeBlockUpdates`). An older Worker that does not
+       * announce it posts them unasked.
+       */
+      onBlockUpdate(cb) {
+        this.#onBlockUpdate = cb;
+        this.#subscribeBlockUpdates();
+      }
+      #subscribeBlockUpdates() {
+        if (this.#disposed || this.#blockUpdatesSubscribed || !this.#blockUpdatesAnnounced || !this.#onBlockUpdate)
+          return;
+        this.#blockUpdatesSubscribed = true;
+        this.#worker.postMessage({ type: "subscribeBlockUpdates" });
+      }
+      /** Register callback fired after the Worker drains all commands queued before cleanup. */
+      onCleanupComplete(cb) {
+        this.#onCleanupComplete = cb;
+      }
+      /** Register callback for Worker errors. */
+      onError(cb) {
+        this.#onError = cb;
+      }
+      /**
+       * True once dispose() ran. A disposed client cannot decode, fill, or
+       * acknowledge anything, so routing symbols to it discards them; every
+       * command method (feedSource, feedRepair, relayBlockSig, cleanup, reset)
+       * throws rather than pretend otherwise. Callers check this first.
+       */
+      get disposed() {
+        return this.#disposed;
+      }
+      /**
+       * Dispose the Worker. Sends dispose command then terminates.
+       * Idempotent — safe to call multiple times.
+       */
+      dispose() {
+        if (this.#disposed)
+          return;
+        this.#disposed = true;
+        this.#pendingSymbols = [];
+        this.#pendingTransfer = [];
+        this.#cleanupInFlight = null;
+        this.#queuedCleanupSbns.clear();
+        this.#worker.postMessage({ type: "dispose" });
+        this.#worker.terminate();
+      }
+      #handleEvent(event) {
+        if (event.type === "capabilities") {
+          if (Array.isArray(event.commands) && event.commands.includes("feedSymbols")) {
+            this.#batchSymbols = true;
+          }
+          if (Array.isArray(event.commands) && event.commands.includes("subscribeBlockUpdates")) {
+            this.#blockUpdatesAnnounced = true;
+            this.#subscribeBlockUpdates();
+          }
+          return;
+        }
+        if (event.type === "resetComplete") {
+          this.#pendingResets = Math.max(0, this.#pendingResets - 1);
+          this.#resetFailed = false;
+          return;
+        }
+        if (event.type === "error") {
+          if (event.code === "reset-failed") {
+            this.#pendingResets = Math.max(0, this.#pendingResets - 1);
+            this.#resetFailed = true;
+          }
+          if (event.code)
+            this.#onError?.(event.message, event.code);
+          else
+            this.#onError?.(event.message);
+          return;
+        }
+        if (this.#pendingResets > 0 || this.#resetFailed)
+          return;
+        switch (event.type) {
+          case "frame":
+            this.#onFrame?.(event.data, event.meta);
+            break;
+          case "snapshot":
+            this.#onSnapshot?.(event.stats);
+            break;
+          case "blockUpdate":
+            this.#onBlockUpdate?.(event.block);
+            break;
+          case "cleanupComplete":
+            for (const sbn of event.sbns) {
+              this.#onCleanupComplete?.(sbn);
+            }
+            this.#cleanupInFlight = null;
+            if (this.#queuedCleanupSbns.size > 0) {
+              const next = this.#queuedCleanupSbns;
+              this.#queuedCleanupSbns = /* @__PURE__ */ new Set();
+              this.#postCleanup(next);
+            }
+            break;
+        }
+      }
+    };
+  }
+});
+
+// ../fec-worker/dist/shred-worker-client.js
+function formatWorkerError2(event) {
+  const parts = ["Worker error"];
+  if (event.message)
+    parts.push(event.message);
+  if (event.filename) {
+    const loc = [event.filename];
+    if (event.lineno)
+      loc.push(String(event.lineno));
+    if (event.colno)
+      loc.push(String(event.colno));
+    parts.push(`at ${loc.join(":")}`);
+  }
+  if (event.error instanceof Error && event.error.stack)
+    parts.push(event.error.stack);
+  return parts.join(": ");
+}
+var DEFAULT_MAX_INFLIGHT, ShredWorkerClient;
+var init_shred_worker_client = __esm({
+  "../fec-worker/dist/shred-worker-client.js"() {
+    "use strict";
+    DEFAULT_MAX_INFLIGHT = 8192;
+    ShredWorkerClient = class {
+      #worker;
+      #onRecovered = null;
+      #onStats = null;
+      #onError = null;
+      #disposed = false;
+      /** feedShred in-flight backpressure accounting (see ShredWorkerClientOptions.maxInflight). */
+      #maxInflight;
+      #sent = 0;
+      // frames posted via feedShred (monotonic)
+      #processed = 0;
+      // worker-consumed total from the last stats heartbeat (monotonic)
+      #droppedBackpressure = 0;
+      // frames dropped by the in-flight guard (monotonic)
+      /**
+       * @param workerOrUrl - A URL (a Worker is created internally, `type: module`)
+       *   or a pre-created Worker (for testing via constructor injection).
+       * @param opts - Optional {@link ShredWorkerClientOptions}.
+       */
+      constructor(workerOrUrl, opts = {}) {
+        this.#maxInflight = opts.maxInflight ?? DEFAULT_MAX_INFLIGHT;
+        this.#worker = workerOrUrl instanceof URL ? new Worker(workerOrUrl, { type: "module" }) : workerOrUrl;
+        this.#worker.onmessage = (e) => this.#handleEvent(e.data);
+        this.#worker.onerror = (e) => this.#onError?.(formatWorkerError2(e), "worker-runtime");
+        this.#worker.onmessageerror = () => this.#onError?.("failed to deserialize worker message", "worker-message");
+      }
+      /** Configure the decoder (WASM load + ShredFecBuffer construction happen in the worker). */
+      configure(config) {
+        if (this.#disposed)
+          throw new Error("[ShredWorkerClient] disposed");
+        this.#post({ type: "configure", config });
+      }
+      /**
+       * Hand the worker a stream of raw shred frames to batch-drain. The stream is
+       * transferred — the caller must not use it afterward. One active stream at a
+       * time; attaching a new one cancels the previous.
+       */
+      attachStream(readable) {
+        if (this.#disposed)
+          return;
+        this.#post({ type: "attachStream", readable }, [readable]);
+      }
+      /**
+       * Feed one already-demuxed raw shred frame. `frame` is transferred zero-copy;
+       * the caller must not access it afterward.
+       *
+       * Dropped (frame NOT transferred, so the caller's buffer stays intact) when the
+       * in-flight window is full — i.e. the worker is more than `maxInflight` frames
+       * behind. This is the memory bound: a slow/wedged consumer costs bounded
+       * skip-to-live drops (see {@link droppedBackpressure}), never an unbounded
+       * renderer-heap blow-up.
+       */
+      feedShred(frame) {
+        if (this.#disposed)
+          return;
+        if (this.#maxInflight > 0 && this.#sent - this.#processed >= this.#maxInflight) {
+          this.#droppedBackpressure++;
+          return;
+        }
+        this.#sent++;
+        this.#post({ type: "feedShred", frame }, [frame]);
+      }
+      /** Explicitly drive loss recovery (in addition to the worker's internal timer). */
+      recoverAll(nowMs = Date.now()) {
+        if (this.#disposed)
+          return;
+        this.#post({ type: "recoverAll", nowMs });
+      }
+      /** Register callback for recovered/completed FEC sets. `data` is a transferred buffer. */
+      onRecovered(cb) {
+        this.#onRecovered = cb;
+      }
+      /** Register callback for the coalesced stats heartbeat. */
+      onStats(cb) {
+        this.#onStats = cb;
+      }
+      /** Register callback for worker errors. */
+      onError(cb) {
+        this.#onError = cb;
+      }
+      /**
+       * Frames dropped by the in-flight backpressure guard since construction
+       * (monotonic). Surface this in the UI so sustained loss is visible rather than
+       * silent — a rising counter means the consumer can't keep pace with ingest.
+       */
+      get droppedBackpressure() {
+        return this.#droppedBackpressure;
+      }
+      /**
+       * Frames posted via {@link feedShred} but not yet reported drained by the
+       * worker's last stats heartbeat (best-effort, heartbeat-granular; never < 0).
+       */
+      get inflight() {
+        return Math.max(0, this.#sent - this.#processed);
+      }
+      /** Dispose the worker. Idempotent. */
+      dispose() {
+        if (this.#disposed)
+          return;
+        this.#disposed = true;
+        try {
+          this.#worker.postMessage({ type: "dispose" });
+        } catch {
+        }
+        this.#worker.terminate();
+      }
+      #post(cmd, transfer = []) {
+        this.#worker.postMessage(cmd, transfer);
+      }
+      #handleEvent(event) {
+        switch (event.type) {
+          case "recovered":
+            this.#onRecovered?.(event.data, event.meta);
+            break;
+          case "stats":
+            this.#processed = event.stats.shredsRx + event.stats.malformed + event.stats.versionMismatch;
+            this.#onStats?.(event.stats);
+            break;
+          case "error":
+            if (event.code)
+              this.#onError?.(event.message, event.code);
+            else
+              this.#onError?.(event.message);
+            break;
+        }
+      }
+    };
+  }
+});
+
+// ../fec-worker/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  FecWorkerClient: () => FecWorkerClient,
+  ShredWorkerClient: () => ShredWorkerClient
+});
+var init_dist = __esm({
+  "../fec-worker/dist/index.js"() {
+    "use strict";
+    init_fec_worker_client();
+    init_shred_worker_client();
+  }
+});
+
+// ../mmt-alta-parse/dist/index.js
+var MPU_HEADER_SIZE = 8;
+var MPU_LENGTH_FIELD_SIZE = 2;
+var MPU_HEADER_REMAINDER_SIZE = MPU_HEADER_SIZE - MPU_LENGTH_FIELD_SIZE;
+
+// ../mmt-base/dist/mmtp.js
+var MPU_HEADER_SIZE2 = 8;
+var MPU_LENGTH_FIELD_SIZE2 = 2;
+var MPU_HEADER_REMAINDER_SIZE2 = MPU_HEADER_SIZE2 - MPU_LENGTH_FIELD_SIZE2;
+
+// ../mmt-base/dist/ntp-short.js
+var NTP_SHORT_BITS = 32;
+var NTP_SHORT_MODULUS = 2 ** NTP_SHORT_BITS;
+var NTP_SHORT_HALF_RANGE = 2 ** (NTP_SHORT_BITS - 1);
+
+// ../mmt-base/dist/fec-block-profile.js
+var FEC_BLOCK_PROFILES = Object.freeze([
+  "k-padded-v1",
+  "iso-ssbg1-v1"
+]);
+function isFecBlockProfile(value) {
+  return value === "k-padded-v1" || value === "iso-ssbg1-v1";
+}
+function parseFecBlockProfile(value, where) {
+  if (isFecBlockProfile(value))
+    return value;
+  if (value === void 0) {
+    throw new Error(`${where} is required: name the FEC block profile ("k-padded-v1" or "iso-ssbg1-v1")`);
+  }
+  throw new Error(`${where} must be "k-padded-v1" or "iso-ssbg1-v1" (got ${JSON.stringify(value)})`);
+}
+
+// src/fec-worker-setup.ts
+import { deriveFecRetentionBlocks } from "@blockcast/mmt-fec";
+
+// src/track-session.ts
+import { fecBlockBudgetMs } from "@blockcast/mmt-fec";
+function computeFecDeliveryWindowMs(config) {
+  const fecInterleaveMs = config.interleaveDepthMs;
+  const fecK = config.sourceSymbols;
+  if (!Number.isFinite(fecInterleaveMs) || fecInterleaveMs <= 0) {
+    throw new Error(
+      `[TrackSession] fecInterleaveMs=${fecInterleaveMs}. Derive a positive FEC interleave window from the stream catalog.`
+    );
+  }
+  if (!Number.isFinite(fecK) || fecK <= 0) {
+    throw new Error(
+      `[TrackSession] fecK=${fecK}. Derive a positive FEC source-symbol count from the stream catalog.`
+    );
+  }
+  if (config.jitterBufferMs === void 0) return Math.ceil(fecInterleaveMs);
+  return fecBlockBudgetMs(fecInterleaveMs, config.jitterBufferMs);
+}
+
+// src/fec-worker-setup.ts
+async function setupFecWorkerForTrack(opts) {
+  if (!Number.isFinite(opts.fecInterleaveMs) || opts.fecInterleaveMs <= 0) {
+    throw new Error(
+      `[FEC] interleaveDepthMs (opts.fecInterleaveMs) must be finite and > 0 (got ${opts.fecInterleaveMs})`
+    );
+  }
+  if (!Number.isFinite(opts.mediaUnitDurationMs) || opts.mediaUnitDurationMs <= 0) {
+    throw new Error(
+      `[FEC] mediaUnitDurationMs must be finite and > 0 (got ${opts.mediaUnitDurationMs})`
+    );
+  }
+  const blockProfile = parseFecBlockProfile(
+    opts.fecBlockProfile,
+    `[FEC] ${opts.trackName} fec.blockProfile`
+  );
+  const deliveryWindowMs = computeFecDeliveryWindowMs({
+    interleaveDepthMs: opts.fecInterleaveMs,
+    sourceSymbols: opts.fecK,
+    repairSymbols: opts.fecRepairCount,
+    symbolSize: opts.fecSymbolSize,
+    mediaUnitsPerSecond: 1e3 / opts.mediaUnitDurationMs,
+    jitterBufferMs: opts.fecReorderToleranceMs
+  });
+  const interleaveDepthBlocks = deriveFecRetentionBlocks(
+    deliveryWindowMs,
+    opts.fecInterleaveMs
+  );
+  const origin = typeof location !== "undefined" && location.origin ? location.origin : "http://localhost";
+  const workerUrl = new URL(opts.assetUrls.fecWorker, origin);
+  const FecWorkerCtor = await Promise.resolve().then(() => (init_dist(), dist_exports));
+  const client = opts.clientFactory ? opts.clientFactory(workerUrl) : new FecWorkerCtor.FecWorkerClient(workerUrl);
+  const rqWasm = await WebAssembly.compileStreaming(fetch(opts.assetUrls.rqWasm));
+  let altaKeyBuffer;
+  let altaWasmModule;
+  if (opts.altaPublicKeySpki) {
+    const b64 = opts.altaPublicKeySpki.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = b64.padEnd(Math.ceil(b64.length / 4) * 4, "=");
+    try {
+      const keyBytes = Uint8Array.from(atob(padded), (c) => c.charCodeAt(0));
+      if (keyBytes.length >= 32 && keyBytes.length <= 256) {
+        altaKeyBuffer = keyBytes.buffer;
+        altaWasmModule = await WebAssembly.compileStreaming(fetch(opts.assetUrls.altaWasm));
+      } else {
+        console.warn(
+          `[fec-worker-setup] ALTA SPKI wrong length for "${opts.trackName}": ${keyBytes.length} (expected 32..256) \u2014 ALTA disabled`
+        );
+      }
+    } catch (e) {
+      console.warn(`[fec-worker-setup] ALTA key decode / WASM compile failed for "${opts.trackName}":`, e);
+    }
+  }
+  const altaEnabled = !!(altaKeyBuffer && altaWasmModule);
+  const fecTrackConfig = {
+    codec: opts.codec ?? "unknown",
+    trackName: opts.trackName,
+    trackType: opts.trackType,
+    framerate: opts.framerate,
+    sampleRate: opts.sampleRate,
+    algorithm: "raptor",
+    blockProfile,
+    k: opts.fecK,
+    // P as this receiver joined it, not the catalog total: the worker snapshot
+    // and CMCD `x-bc-fec-p` are read from this. Identity on a single layer.
+    repairCount: opts.joinedRepairCount ?? opts.fecRepairCount,
+    symbolSize: opts.fecSymbolSize,
+    interleaveDepth: interleaveDepthBlocks,
+    interleaveMs: opts.fecInterleaveMs,
+    deliveryWindowMs,
+    fecMode: "subframe",
+    repairTrack: opts.repairTrackName,
+    altaEnabled,
+    relayBlockSigEnabled: false
+  };
+  client.configure(fecTrackConfig, rqWasm, altaKeyBuffer, altaWasmModule);
+  try {
+    opts.multicastManager.setFecWorker(opts.packetId, client, opts.trackType, {
+      blockProfile,
+      k: opts.fecK,
+      symbolSize: opts.fecSymbolSize,
+      interleaveDepthMs: opts.fecInterleaveMs,
+      // FEC timing is expressed in media units. For audio this is the access-unit
+      // cadence (for example 1024/48kHz), not a video-only framerate field.
+      fps: 1e3 / opts.mediaUnitDurationMs,
+      timeoutMs: deliveryWindowMs
+    }, opts.trackName);
+  } catch (e) {
+    try {
+      client.dispose();
+    } catch {
+    }
+    throw e;
+  }
+  let disposed = false;
+  return {
+    client,
+    altaEnabled,
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      if (!opts.multicastManager.clearFecWorker(opts.packetId, opts.trackName)) {
+        console.warn(
+          `[fec-worker-setup] packetId=${opts.packetId} track=${opts.trackName} Worker was not registered when disposed`
+        );
+      }
+      try {
+        client.dispose();
+      } catch {
+      }
+    }
+  };
+}
+export {
+  setupFecWorkerForTrack
+};
+//# sourceMappingURL=fec-worker-setup.js.map