@blockcast/mmt-container 0.1.0-main.149f78a4adae

package/dist/fec-worker-setup.js

@@ -0,0 +1,603 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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 });
+};
+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);
+  }
+});
+
+// ../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 _worker, _onFrame, _onSnapshot, _onBlockUpdate, _onGreenFill, _onCleanupComplete, _onError, _cleanupInFlight, _queuedCleanupSbns, _pendingResets, _resetFailed, _disposed, _FecWorkerClient_instances, postCleanup_fn, handleEvent_fn, FecWorkerClient;
+var init_fec_worker_client = __esm({
+  "../fec-worker/dist/fec-worker-client.js"() {
+    "use strict";
+    FecWorkerClient = class {
+      /**
+       * Create a FecWorkerClient.
+       * @param workerOrUrl - Either a Worker instance (for testing) or a URL to create one
+       */
+      constructor(workerOrUrl) {
+        __privateAdd(this, _FecWorkerClient_instances);
+        __privateAdd(this, _worker);
+        __privateAdd(this, _onFrame, null);
+        __privateAdd(this, _onSnapshot, null);
+        __privateAdd(this, _onBlockUpdate, null);
+        __privateAdd(this, _onGreenFill, null);
+        __privateAdd(this, _onCleanupComplete, null);
+        __privateAdd(this, _onError, null);
+        __privateAdd(this, _cleanupInFlight, null);
+        __privateAdd(this, _queuedCleanupSbns, /* @__PURE__ */ new Set());
+        __privateAdd(this, _pendingResets, 0);
+        __privateAdd(this, _resetFailed, false);
+        __privateAdd(this, _disposed, false);
+        if (workerOrUrl instanceof URL) {
+          __privateSet(this, _worker, new Worker(workerOrUrl, { type: "module" }));
+        } else {
+          __privateSet(this, _worker, workerOrUrl);
+        }
+        __privateGet(this, _worker).onmessage = (e) => __privateMethod(this, _FecWorkerClient_instances, handleEvent_fn).call(this, e.data);
+        __privateGet(this, _worker).onerror = (e) => {
+          var _a;
+          (_a = __privateGet(this, _onError)) == null ? void 0 : _a.call(this, formatWorkerError(e), "worker-runtime");
+        };
+        __privateGet(this, _worker).onmessageerror = (e) => {
+          var _a;
+          (_a = __privateGet(this, _onError)) == null ? void 0 : _a.call(this, 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 (__privateGet(this, _disposed))
+          throw new Error("[FecWorkerClient] disposed");
+        const cmd = {
+          type: "configure",
+          config,
+          wasmModule,
+          altaPublicKey,
+          altaWasmModule
+        };
+        const transferList = [];
+        if (altaPublicKey)
+          transferList.push(altaPublicKey);
+        __privateGet(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 detached.
+       *
+       * 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 (__privateGet(this, _disposed))
+          return;
+        const cmd = alta ? {
+          type: "feedSource",
+          ssId,
+          data,
+          ts,
+          altaAuth: alta.auth,
+          altaPayloadEnd: alta.payloadEnd
+        } : { type: "feedSource", ssId, data, ts };
+        const transfer = alta ? [data, alta.auth] : [data];
+        __privateGet(this, _worker).postMessage(cmd, transfer);
+      }
+      /**
+       * 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 * SSB_length)
+       * - ssbLength: K for this block
+       * - rsId:      repair symbol index within the block
+       */
+      feedRepair(ssStart, ssbLength, rsId, data, ts) {
+        if (__privateGet(this, _disposed))
+          return;
+        __privateGet(this, _worker).postMessage({
+          type: "feedRepair",
+          ssStart,
+          ssbLength,
+          rsId,
+          data,
+          ts
+        }, [data]);
+      }
+      /**
+       * Submit relay block signature for verification. sig and hash are transferred.
+       */
+      relayBlockSig(sbn, sig, hash) {
+        if (__privateGet(this, _disposed))
+          return;
+        __privateGet(this, _worker).postMessage({ type: "relayBlockSig", sbn, sig, hash }, [sig, hash]);
+      }
+      /**
+       * Trigger cleanup after a block's inactivity deadline.
+       *
+       * 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 (__privateGet(this, _disposed))
+          return;
+        if (!Number.isInteger(currentSbn) || currentSbn < 0 || currentSbn > 4294967295) {
+          throw new Error("[FecWorkerClient] cleanup: SBN must be a uint32");
+        }
+        if (__privateGet(this, _cleanupInFlight)) {
+          __privateGet(this, _queuedCleanupSbns).add(currentSbn);
+          return;
+        }
+        __privateMethod(this, _FecWorkerClient_instances, postCleanup_fn).call(this, /* @__PURE__ */ new Set([currentSbn]));
+      }
+      /** Reset this track's decoder epoch while preserving Worker configuration. */
+      reset() {
+        if (__privateGet(this, _disposed))
+          return;
+        __privateWrapper(this, _pendingResets)._++;
+        __privateSet(this, _cleanupInFlight, null);
+        __privateGet(this, _queuedCleanupSbns).clear();
+        __privateGet(this, _worker).postMessage({ type: "reset" });
+      }
+      /** Register callback for decoded/recovered frames (FEC-03). */
+      onFrame(cb) {
+        __privateSet(this, _onFrame, cb);
+      }
+      /** Register callback for periodic stats snapshots (FEC-04). */
+      onSnapshot(cb) {
+        __privateSet(this, _onSnapshot, cb);
+      }
+      /** Register callback for individual block state changes. */
+      onBlockUpdate(cb) {
+        __privateSet(this, _onBlockUpdate, cb);
+      }
+      /** Register callback for green-fill frames. */
+      onGreenFill(cb) {
+        __privateSet(this, _onGreenFill, cb);
+      }
+      /** Register callback fired after the Worker drains all commands queued before cleanup. */
+      onCleanupComplete(cb) {
+        __privateSet(this, _onCleanupComplete, cb);
+      }
+      /** Register callback for Worker errors. */
+      onError(cb) {
+        __privateSet(this, _onError, cb);
+      }
+      /**
+       * Dispose the Worker. Sends dispose command then terminates.
+       * Idempotent — safe to call multiple times.
+       */
+      dispose() {
+        if (__privateGet(this, _disposed))
+          return;
+        __privateSet(this, _disposed, true);
+        __privateSet(this, _cleanupInFlight, null);
+        __privateGet(this, _queuedCleanupSbns).clear();
+        __privateGet(this, _worker).postMessage({ type: "dispose" });
+        __privateGet(this, _worker).terminate();
+      }
+    };
+    _worker = new WeakMap();
+    _onFrame = new WeakMap();
+    _onSnapshot = new WeakMap();
+    _onBlockUpdate = new WeakMap();
+    _onGreenFill = new WeakMap();
+    _onCleanupComplete = new WeakMap();
+    _onError = new WeakMap();
+    _cleanupInFlight = new WeakMap();
+    _queuedCleanupSbns = new WeakMap();
+    _pendingResets = new WeakMap();
+    _resetFailed = new WeakMap();
+    _disposed = new WeakMap();
+    _FecWorkerClient_instances = new WeakSet();
+    postCleanup_fn = function(sbns) {
+      __privateSet(this, _cleanupInFlight, sbns);
+      const orderedSbns = [...sbns].sort((a, b) => a - b);
+      __privateGet(this, _worker).postMessage({ type: "cleanup", sbns: orderedSbns });
+    };
+    handleEvent_fn = function(event) {
+      var _a, _b, _c, _d, _e, _f, _g;
+      if (event.type === "resetComplete") {
+        __privateSet(this, _pendingResets, Math.max(0, __privateGet(this, _pendingResets) - 1));
+        __privateSet(this, _resetFailed, false);
+        return;
+      }
+      if (event.type === "error") {
+        if (event.code === "reset-failed") {
+          __privateSet(this, _pendingResets, Math.max(0, __privateGet(this, _pendingResets) - 1));
+          __privateSet(this, _resetFailed, true);
+        }
+        if (event.code)
+          (_a = __privateGet(this, _onError)) == null ? void 0 : _a.call(this, event.message, event.code);
+        else
+          (_b = __privateGet(this, _onError)) == null ? void 0 : _b.call(this, event.message);
+        return;
+      }
+      if (__privateGet(this, _pendingResets) > 0 || __privateGet(this, _resetFailed))
+        return;
+      switch (event.type) {
+        case "frame":
+          (_c = __privateGet(this, _onFrame)) == null ? void 0 : _c.call(this, event.data, event.meta);
+          break;
+        case "snapshot":
+          (_d = __privateGet(this, _onSnapshot)) == null ? void 0 : _d.call(this, event.stats);
+          break;
+        case "blockUpdate":
+          (_e = __privateGet(this, _onBlockUpdate)) == null ? void 0 : _e.call(this, event.block);
+          break;
+        case "greenFill":
+          (_f = __privateGet(this, _onGreenFill)) == null ? void 0 : _f.call(this, event.sbn, event.data);
+          break;
+        case "cleanupComplete":
+          for (const sbn of event.sbns) {
+            (_g = __privateGet(this, _onCleanupComplete)) == null ? void 0 : _g.call(this, sbn);
+          }
+          __privateSet(this, _cleanupInFlight, null);
+          if (__privateGet(this, _queuedCleanupSbns).size > 0) {
+            const next = __privateGet(this, _queuedCleanupSbns);
+            __privateSet(this, _queuedCleanupSbns, /* @__PURE__ */ new Set());
+            __privateMethod(this, _FecWorkerClient_instances, postCleanup_fn).call(this, 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, _worker2, _onRecovered, _onStats, _onError2, _disposed2, _maxInflight, _sent, _processed, _droppedBackpressure, _ShredWorkerClient_instances, post_fn, handleEvent_fn2, ShredWorkerClient;
+var init_shred_worker_client = __esm({
+  "../fec-worker/dist/shred-worker-client.js"() {
+    "use strict";
+    DEFAULT_MAX_INFLIGHT = 8192;
+    ShredWorkerClient = class {
+      // 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 = {}) {
+        __privateAdd(this, _ShredWorkerClient_instances);
+        __privateAdd(this, _worker2);
+        __privateAdd(this, _onRecovered, null);
+        __privateAdd(this, _onStats, null);
+        __privateAdd(this, _onError2, null);
+        __privateAdd(this, _disposed2, false);
+        /** feedShred in-flight backpressure accounting (see ShredWorkerClientOptions.maxInflight). */
+        __privateAdd(this, _maxInflight);
+        __privateAdd(this, _sent, 0);
+        // frames posted via feedShred (monotonic)
+        __privateAdd(this, _processed, 0);
+        // worker-consumed total from the last stats heartbeat (monotonic)
+        __privateAdd(this, _droppedBackpressure, 0);
+        __privateSet(this, _maxInflight, opts.maxInflight ?? DEFAULT_MAX_INFLIGHT);
+        __privateSet(this, _worker2, workerOrUrl instanceof URL ? new Worker(workerOrUrl, { type: "module" }) : workerOrUrl);
+        __privateGet(this, _worker2).onmessage = (e) => __privateMethod(this, _ShredWorkerClient_instances, handleEvent_fn2).call(this, e.data);
+        __privateGet(this, _worker2).onerror = (e) => {
+          var _a;
+          return (_a = __privateGet(this, _onError2)) == null ? void 0 : _a.call(this, formatWorkerError2(e), "worker-runtime");
+        };
+        __privateGet(this, _worker2).onmessageerror = () => {
+          var _a;
+          return (_a = __privateGet(this, _onError2)) == null ? void 0 : _a.call(this, "failed to deserialize worker message", "worker-message");
+        };
+      }
+      /** Configure the decoder (WASM load + ShredFecBuffer construction happen in the worker). */
+      configure(config) {
+        if (__privateGet(this, _disposed2))
+          throw new Error("[ShredWorkerClient] disposed");
+        __privateMethod(this, _ShredWorkerClient_instances, post_fn).call(this, { 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 (__privateGet(this, _disposed2))
+          return;
+        __privateMethod(this, _ShredWorkerClient_instances, post_fn).call(this, { 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 (__privateGet(this, _disposed2))
+          return;
+        if (__privateGet(this, _maxInflight) > 0 && __privateGet(this, _sent) - __privateGet(this, _processed) >= __privateGet(this, _maxInflight)) {
+          __privateWrapper(this, _droppedBackpressure)._++;
+          return;
+        }
+        __privateWrapper(this, _sent)._++;
+        __privateMethod(this, _ShredWorkerClient_instances, post_fn).call(this, { type: "feedShred", frame }, [frame]);
+      }
+      /** Explicitly drive loss recovery (in addition to the worker's internal timer). */
+      recoverAll(nowMs = Date.now()) {
+        if (__privateGet(this, _disposed2))
+          return;
+        __privateMethod(this, _ShredWorkerClient_instances, post_fn).call(this, { type: "recoverAll", nowMs });
+      }
+      /** Register callback for recovered/completed FEC sets. `data` is a transferred buffer. */
+      onRecovered(cb) {
+        __privateSet(this, _onRecovered, cb);
+      }
+      /** Register callback for the coalesced stats heartbeat. */
+      onStats(cb) {
+        __privateSet(this, _onStats, cb);
+      }
+      /** Register callback for worker errors. */
+      onError(cb) {
+        __privateSet(this, _onError2, 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 __privateGet(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, __privateGet(this, _sent) - __privateGet(this, _processed));
+      }
+      /** Dispose the worker. Idempotent. */
+      dispose() {
+        if (__privateGet(this, _disposed2))
+          return;
+        __privateSet(this, _disposed2, true);
+        try {
+          __privateGet(this, _worker2).postMessage({ type: "dispose" });
+        } catch {
+        }
+        __privateGet(this, _worker2).terminate();
+      }
+    };
+    _worker2 = new WeakMap();
+    _onRecovered = new WeakMap();
+    _onStats = new WeakMap();
+    _onError2 = new WeakMap();
+    _disposed2 = new WeakMap();
+    _maxInflight = new WeakMap();
+    _sent = new WeakMap();
+    _processed = new WeakMap();
+    _droppedBackpressure = new WeakMap();
+    _ShredWorkerClient_instances = new WeakSet();
+    post_fn = function(cmd, transfer = []) {
+      __privateGet(this, _worker2).postMessage(cmd, transfer);
+    };
+    handleEvent_fn2 = function(event) {
+      var _a, _b, _c, _d;
+      switch (event.type) {
+        case "recovered":
+          (_a = __privateGet(this, _onRecovered)) == null ? void 0 : _a.call(this, event.data, event.meta);
+          break;
+        case "stats":
+          __privateSet(this, _processed, event.stats.shredsRx + event.stats.malformed + event.stats.versionMismatch);
+          (_b = __privateGet(this, _onStats)) == null ? void 0 : _b.call(this, event.stats);
+          break;
+        case "error":
+          if (event.code)
+            (_c = __privateGet(this, _onError2)) == null ? void 0 : _c.call(this, event.message, event.code);
+          else
+            (_d = __privateGet(this, _onError2)) == null ? void 0 : _d.call(this, 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();
+  }
+});
+
+// src/fec-worker-setup.ts
+import { deriveFecInterleaveDepth as deriveFecInterleaveDepth2 } from "@blockcast/mmt-fec";
+
+// src/track-session.ts
+import { deriveFecInterleaveDepth } from "@blockcast/mmt-fec";
+function computeFecDeliveryWindowMs(config) {
+  const fecInterleaveMs = config.interleaveDepthMs;
+  const fecK = config.sourceSymbols;
+  if (fecInterleaveMs <= 0) {
+    throw new Error(
+      `[TrackSession] fecInterleaveMs=${fecInterleaveMs}. Derive a positive FEC interleave window from the stream catalog.`
+    );
+  }
+  if (fecK <= 0) {
+    throw new Error(
+      `[TrackSession] fecK=${fecK}. Derive a positive FEC source-symbol count from the stream catalog.`
+    );
+  }
+  const spansMs = [fecInterleaveMs];
+  if (config.mediaUnitsPerSecond && config.mediaUnitsPerSecond > 0) {
+    const mediaUnitMs = 1e3 / config.mediaUnitsPerSecond;
+    const interleaveUnits = deriveFecInterleaveDepth(fecInterleaveMs, mediaUnitMs);
+    const deliverySymbols = fecK + Math.max(0, config.repairSymbols ?? 0);
+    spansMs.push(deliverySymbols * interleaveUnits * mediaUnitMs);
+  }
+  if (config.symbolSize && config.symbolSize > 0 && config.bandwidthBps && config.bandwidthBps > 0) {
+    const repairSymbols = Math.max(0, config.repairSymbols ?? 0);
+    spansMs.push(
+      (fecK + repairSymbols) * config.symbolSize * 8 * 1e3 / config.bandwidthBps
+    );
+  }
+  const coreMs = Math.max(...spansMs);
+  const marginMs = config.jitterBufferMs !== void 0 && config.jitterBufferMs >= 0 ? config.jitterBufferMs : fecInterleaveMs;
+  return Math.ceil(coreMs) + Math.ceil(marginMs);
+}
+
+// src/fec-worker-setup.ts
+async function setupFecWorkerForTrack(opts) {
+  const interleaveDepthBlocks = deriveFecInterleaveDepth2(
+    opts.fecInterleaveMs,
+    opts.mediaUnitDurationMs
+  );
+  const deliveryWindowMs = computeFecDeliveryWindowMs({
+    interleaveDepthMs: opts.fecInterleaveMs,
+    sourceSymbols: opts.fecK,
+    repairSymbols: opts.fecRepairCount,
+    symbolSize: opts.fecSymbolSize,
+    mediaUnitsPerSecond: 1e3 / opts.mediaUnitDurationMs
+  });
+  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",
+    k: opts.fecK,
+    repairCount: 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);
+  opts.multicastManager.setFecWorker(opts.packetId, client, opts.trackType, {
+    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);
+  let disposed = false;
+  return {
+    client,
+    altaEnabled,
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      try {
+        client.dispose();
+      } catch {
+      }
+    }
+  };
+}
+export {
+  setupFecWorkerForTrack
+};
+//# sourceMappingURL=fec-worker-setup.js.map