@blockcast/mmt-container 0.1.0-main.30d2c7ed30b2 → 0.1.0-main.342ee38b60e1

package/dist/browser-runtime.js

@@ -126,7 +126,7 @@ var init_fec_worker_client = __esm({
        */
       feedSource(ssId, data, ts, alta) {
         if (__privateGet(this, _disposed5))
-          return;
+          throw new Error("[FecWorkerClient] feedSource on a disposed client");
         const cmd = alta ? {
           type: "feedSource",
           ssId,
@@ -149,7 +149,7 @@ var init_fec_worker_client = __esm({
        */
       feedRepair(ssStart, ssbLength, rsId, data, ts) {
         if (__privateGet(this, _disposed5))
-          return;
+          throw new Error("[FecWorkerClient] feedRepair on a disposed client");
         __privateGet(this, _worker).postMessage({
           type: "feedRepair",
           ssStart,
@@ -164,7 +164,7 @@ var init_fec_worker_client = __esm({
        */
       relayBlockSig(sbn, sig, hash) {
         if (__privateGet(this, _disposed5))
-          return;
+          throw new Error("[FecWorkerClient] relayBlockSig on a disposed client");
         __privateGet(this, _worker).postMessage({ type: "relayBlockSig", sbn, sig, hash }, [sig, hash]);
       }
       /**
@@ -175,7 +175,7 @@ var init_fec_worker_client = __esm({
        */
       cleanup(currentSbn) {
         if (__privateGet(this, _disposed5))
-          return;
+          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");
         }
@@ -188,7 +188,7 @@ var init_fec_worker_client = __esm({
       /** Reset this track's decoder epoch while preserving Worker configuration. */
       reset() {
         if (__privateGet(this, _disposed5))
-          return;
+          throw new Error("[FecWorkerClient] reset on a disposed client");
         __privateWrapper(this, _pendingResets)._++;
         __privateSet(this, _cleanupInFlight, null);
         __privateGet(this, _queuedCleanupSbns).clear();
@@ -218,6 +218,15 @@ var init_fec_worker_client = __esm({
       onError(cb) {
         __privateSet(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 __privateGet(this, _disposed5);
+      }
       /**
        * Dispose the Worker. Sends dispose command then terminates.
        * Idempotent — safe to call multiple times.
@@ -1020,7 +1029,10 @@ function checkedSampleEnd(offset, byteLength) {
   return Number.isSafeInteger(end) && end <= 4294967295 ? end : null;
 }
 var COMPLETED_ADDRESS_WINDOW_MULTIPLE = 2;
-var _buffers, _timeouts, _activeDataUnits, _pendingContinuations, _emitted, _emittedOrder, _completed, _completedOrder, _timeoutMs, _maxBuffered, _nextAdmissionSeq, _MFUReassembler_instances, addAssociatedFragment_fn, parkContinuation_fn, drainPendingContinuations_fn, incompleteRunCount_fn, evictLeastRecentlyAdmitted_fn, releaseSlot_fn, reject_fn, associateDataUnit_fn, tryReassemble_fn, assemble_fn, setTimeout_fn, clearPendingTimeout_fn, armHeadlessPendingTimeout_fn, deletePendingRun_fn, onPendingTimeout_fn, clearTimeout_fn, markEmitted_fn, markCompleted_fn, orderValue_fn, removeActiveDataUnitForBuffer_fn, openRunAt_fn, onTimeout_fn, pendingDebugSamples_fn;
+function parkedRunHoldsASlot(hasOpenRun, fragmentCount) {
+  return !hasOpenRun && fragmentCount > 0;
+}
+var _buffers, _timeouts, _activeDataUnits, _pendingContinuations, _emitted, _emittedOrder, _completed, _completedOrder, _timeoutMs, _maxBuffered, _nextAdmissionSeq, _MFUReassembler_instances, addAssociatedFragment_fn, parkContinuation_fn, drainPendingContinuations_fn, unopenedParkedRunCount_fn, incompleteRunCount_fn, evictLeastRecentlyAdmitted_fn, releaseSlot_fn, reject_fn, associateDataUnit_fn, tryReassemble_fn, assemble_fn, setTimeout_fn, clearPendingTimeout_fn, armHeadlessPendingTimeout_fn, deletePendingRun_fn, onPendingTimeout_fn, clearTimeout_fn, markEmitted_fn, markCompleted_fn, orderValue_fn, removeActiveDataUnitForBuffer_fn, openRunAt_fn, onTimeout_fn, pendingDebugSamples_fn;
 var MFUReassembler = class {
   constructor(options) {
     __privateAdd(this, _MFUReassembler_instances);
@@ -1086,12 +1098,9 @@ var MFUReassembler = class {
         state.timeoutId = setTimeout(() => __privateMethod(this, _MFUReassembler_instances, onTimeout_fn).call(this, bufferKey), Math.max(0, state.startedAt + ms - now));
       }
     }
-    for (const [address, pending] of __privateGet(this, _pendingContinuations)) {
-      if (pending.timeoutId !== void 0) clearTimeout(pending.timeoutId);
-      delete pending.timeoutId;
-      if (ms !== null && __privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address) === void 0) {
-        pending.timeoutId = setTimeout(() => __privateMethod(this, _MFUReassembler_instances, onPendingTimeout_fn).call(this, address), Math.max(0, pending.startedAt + ms - now));
-      }
+    for (const address of __privateGet(this, _pendingContinuations).keys()) {
+      __privateMethod(this, _MFUReassembler_instances, clearPendingTimeout_fn).call(this, address);
+      __privateMethod(this, _MFUReassembler_instances, armHeadlessPendingTimeout_fn).call(this, address);
     }
   }
   get timeoutMs() {
@@ -1255,14 +1264,26 @@ var MFUReassembler = class {
     this.stats.outOfOrderFragments = 0;
   }
   /**
-   * Get number of pending MFUs
+   * Get number of pending MFUs: engine buffers plus every headless parked data
+   * unit that holds a slot.
+   *
+   * This is not one of the four charging sites, but it shares their second term,
+   * so it takes the same rule — by delegating to `#unopenedParkedRunCount`, the
+   * one site that applies it. Rust's public `buffered_count()` is
+   * `inner.buffered_count() + unopened_parked_run_count()`, and that count is
+   * `parked_run_holds_a_slot` — so filtering here on the open run alone would
+   * report a phantom slot for an empty published queue in TypeScript and not in
+   * Rust, out of a *host-observable* counter (`getStatus().bufferedMFUs`). Same
+   * state, two numbers, decided by which engine the host loaded: the divergence
+   * class this file exists to close, so the public counters have to agree too.
+   *
+   * Distinct from `#incompleteRunCount`, which sums `#activeDataUnits` rather
+   * than `#buffers`. Those are different quantities by design and are not being
+   * merged; only the parked term they share is required to agree, which is what
+   * routing both through one method makes structural rather than conventional.
    */
   get pendingCount() {
-    let count = __privateGet(this, _buffers).size;
-    for (const address of __privateGet(this, _pendingContinuations).keys()) {
-      if (__privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address) === void 0) count++;
-    }
-    return count;
+    return __privateGet(this, _buffers).size + __privateMethod(this, _MFUReassembler_instances, unopenedParkedRunCount_fn).call(this);
   }
   /**
    * Get current buffer status
@@ -1323,29 +1344,33 @@ addAssociatedFragment_fn = function(fragment, runKey, address, startedAt) {
 };
 parkContinuation_fn = function(address, fragment) {
   let pending = __privateGet(this, _pendingContinuations).get(address);
-  if (pending === void 0) {
-    const open = __privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address);
-    const awaitingFirst = open === void 0;
-    if (awaitingFirst && __privateMethod(this, _MFUReassembler_instances, incompleteRunCount_fn).call(this) >= __privateGet(this, _maxBuffered)) {
-      if (!__privateMethod(this, _MFUReassembler_instances, evictLeastRecentlyAdmitted_fn).call(this)) {
-        __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "active-data-unit-limit", "active MFU data-unit limit reached");
-      }
+  const open = __privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address);
+  const alreadyCharged = open !== void 0 || parkedRunHoldsASlot(open !== void 0, pending?.fragments.size ?? 0);
+  if (!alreadyCharged && __privateMethod(this, _MFUReassembler_instances, incompleteRunCount_fn).call(this) >= __privateGet(this, _maxBuffered)) {
+    if (!__privateMethod(this, _MFUReassembler_instances, evictLeastRecentlyAdmitted_fn).call(this)) {
+      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "active-data-unit-limit", "active MFU data-unit limit reached");
     }
-    const startedAt = Date.now();
+  }
+  let armAfterInsert = false;
+  if (pending === void 0) {
     pending = {
       fragments: /* @__PURE__ */ new Map(),
-      startedAt,
-      admissionSeq: open === void 0 ? __privateWrapper(this, _nextAdmissionSeq)._++ : open[1].admissionSeq
+      startedAt: Date.now(),
+      admissionSeq: open !== void 0 ? open[1].admissionSeq : __privateWrapper(this, _nextAdmissionSeq)._++
     };
-    if (awaitingFirst && __privateGet(this, _timeoutMs) !== null) {
-      pending.timeoutId = setTimeout(() => __privateMethod(this, _MFUReassembler_instances, onPendingTimeout_fn).call(this, address), __privateGet(this, _timeoutMs));
-    }
     __privateGet(this, _pendingContinuations).set(address, pending);
+    armAfterInsert = true;
+  } else if (!alreadyCharged) {
+    pending.admissionSeq = __privateWrapper(this, _nextAdmissionSeq)._++;
+    pending.startedAt = Date.now();
+    __privateMethod(this, _MFUReassembler_instances, clearPendingTimeout_fn).call(this, address);
+    armAfterInsert = true;
   }
   if (pending.fragments.has(fragment.fragmentCounter)) {
     __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "fragment-counter-mismatch", "duplicate queued continuation counter would replace retained media");
   }
   pending.fragments.set(fragment.fragmentCounter, fragment);
+  if (armAfterInsert) __privateMethod(this, _MFUReassembler_instances, armHeadlessPendingTimeout_fn).call(this, address);
 };
 drainPendingContinuations_fn = function(address, runKey) {
   while (true) {
@@ -1368,15 +1393,35 @@ drainPendingContinuations_fn = function(address, runKey) {
     }
   }
 };
-/** Every open run plus every headless parked data unit, one slot each.
- * This is the quantity maxBuffered bounds. */
-incompleteRunCount_fn = function() {
-  let count = __privateGet(this, _activeDataUnits).size;
-  for (const address of __privateGet(this, _pendingContinuations).keys()) {
-    if (__privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address) === void 0) count++;
+/** Parked data units that hold a `maxBuffered` slot of their own. Membership
+ * is `parkedRunHoldsASlot`, the same rule #evictLeastRecentlyAdmitted offers
+ * as candidates, so nothing can be counted here that eviction cannot reclaim.
+ *
+ * One site, two callers — `#incompleteRunCount` and `pendingCount` — mirroring
+ * Rust's `unopened_parked_run_count`, which `incomplete_run_count` and
+ * `buffered_count` both delegate to. Both callers used to inline this loop
+ * verbatim, so converging the *rule* moved one copy and left the other as the
+ * divergence (Ally's review of #400). The rule can no longer drift now that
+ * every site routes through `parkedRunHoldsASlot`; keeping the loop itself at
+ * one site is what stops the scaffolding drifting the next time this question
+ * grows an argument. */
+unopenedParkedRunCount_fn = function() {
+  let count = 0;
+  for (const [address, pending] of __privateGet(this, _pendingContinuations)) {
+    if (parkedRunHoldsASlot(__privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address) !== void 0, pending.fragments.size)) {
+      count++;
+    }
   }
   return count;
 };
+/** Every open run plus every headless parked data unit that holds a slot,
+ * one slot each. This is the quantity maxBuffered bounds. The parked term is
+ * `#unopenedParkedRunCount`, whose membership is `parkedRunHoldsASlot` — the
+ * same rule #evictLeastRecentlyAdmitted offers as candidates, so nothing can
+ * be counted here that eviction cannot reclaim. */
+incompleteRunCount_fn = function() {
+  return __privateGet(this, _activeDataUnits).size + __privateMethod(this, _MFUReassembler_instances, unopenedParkedRunCount_fn).call(this);
+};
 /**
  * Drop the incomplete data unit admitted longest ago so a newly arriving one
  * can take its slot. Selection is by monotonic admission ordinal, never by
@@ -1388,6 +1433,12 @@ incompleteRunCount_fn = function() {
  * Returns false only if no slot is charged, which cannot happen at the bound
  * (`maxBuffered` is a positive integer); admission then falls back to the
  * fail-closed `active-data-unit-limit` reject, which stays a stable host code.
+ * That holds because the candidate set here is built from the same
+ * `parkedRunHoldsASlot` rule `#incompleteRunCount` counts by, so reaching the
+ * bound implies at least one candidate. Filtering one and not the other would
+ * make the claim false: a queue counted but not offered charges a slot no
+ * eviction can reclaim, and the receiver refuses every later data unit
+ * permanently.
  */
 evictLeastRecentlyAdmitted_fn = function() {
   let victimAddress;
@@ -1399,7 +1450,9 @@ evictLeastRecentlyAdmitted_fn = function() {
     }
   }
   for (const [address, pending] of __privateGet(this, _pendingContinuations)) {
-    if (__privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address) !== void 0) continue;
+    if (!parkedRunHoldsASlot(__privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address) !== void 0, pending.fragments.size)) {
+      continue;
+    }
     if (pending.admissionSeq < victimSeq) {
       victimSeq = pending.admissionSeq;
       victimAddress = address;
@@ -1434,7 +1487,10 @@ associateDataUnit_fn = function(fragment, runKey, address) {
   const fi = fragment.fragmentationIndicator;
   if (fi === 1) {
     const parked = __privateGet(this, _pendingContinuations).get(address);
-    const inheritsParkedSlot = (parked?.fragments.size ?? 0) > 0;
+    const inheritsParkedSlot = parkedRunHoldsASlot(
+      __privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address) !== void 0,
+      parked?.fragments.size ?? 0
+    );
     const sampleIdentity = hasSampleIdentity(fragment);
     const hasSampleFields = hasAnySampleIdentityField(fragment);
     const hasItemIdentity = fragment.itemId !== void 0;
@@ -1605,11 +1661,19 @@ clearPendingTimeout_fn = function(address) {
 /**
  * A queue whose run closed without completing is headless again and expires
  * from its own first arrival, exactly as it would had the head never come.
+ *
+ * An empty queue is not armed: it holds no data unit that could fail to
+ * complete, so there is nothing for a deadline to expire. Every arming site
+ * reaches this function, which takes that test through `parkedRunHoldsASlot`
+ * rather than filtering on the open run alone, which is how this engine
+ * reaches Rust's answer: its
+ * `next_timeout_at` derives candidate deadlines from the queue's live
+ * entries, so an empty queue yields none (BLO-32420).
  */
 armHeadlessPendingTimeout_fn = function(address) {
   const pending = __privateGet(this, _pendingContinuations).get(address);
   if (pending === void 0 || pending.timeoutId !== void 0 || __privateGet(this, _timeoutMs) === null) return;
-  if (__privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address) !== void 0) return;
+  if (!parkedRunHoldsASlot(__privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address) !== void 0, pending.fragments.size)) return;
   pending.timeoutId = setTimeout(
     () => __privateMethod(this, _MFUReassembler_instances, onPendingTimeout_fn).call(this, address),
     Math.max(0, pending.startedAt + __privateGet(this, _timeoutMs) - Date.now())
@@ -1622,6 +1686,10 @@ deletePendingRun_fn = function(address) {
 onPendingTimeout_fn = function(address) {
   const pending = __privateGet(this, _pendingContinuations).get(address);
   if (pending === void 0) return;
+  if (!parkedRunHoldsASlot(__privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address) !== void 0, pending.fragments.size)) {
+    __privateMethod(this, _MFUReassembler_instances, clearPendingTimeout_fn).call(this, address);
+    return;
+  }
   this.stats.timedOutMFUs++;
   console.warn(
     `[MfuReassembler] timeout: run=${address} fragments=${pending.fragments.size} (continuations awaiting first fragment, discarded)`
@@ -5735,6 +5803,289 @@ function resolveMulticastAuthCatalog(catalog, playerMode) {
   };
 }
 
+// src/repair-layers.ts
+var REPAIR_PRIORITY_MIN = 192;
+var REPAIR_PRIORITY_MAX = 255;
+var DEFAULT_REPAIR_PRIORITY = 240;
+var MAX_RAPTORQ_SOURCE_SYMBOLS = 56403;
+var MAX_REPAIR_SYMBOLS = 16777215;
+var MAX_ENCODING_SYMBOL_ID = 16777215;
+var RepairContractError = class extends Error {
+  constructor(code, path, message) {
+    super(`[repair-layers:${code}] ${path}: ${message}`);
+    this.code = code;
+    this.path = path;
+    this.name = "RepairContractError";
+  }
+};
+var throwRepairContractError = (code, path, message) => {
+  throw new RepairContractError(code, path, message);
+};
+var REPAIR_FIELDS = ["depends", "repairLayer", "repairSymbols", "priority", "scope", "sourceSymbols"];
+var REPAIR_TRACK_GEOMETRY_KEYS = [
+  "mmtpMode",
+  "timescale",
+  "groupDurationMs",
+  "groupDurationTicks",
+  "keyframeIntervalMs",
+  "keyframeIntervalTicks",
+  "fec",
+  "symbolSize",
+  "interleaveDepthMs"
+];
+var REPAIR_TRACK_ONLY_KEYS = ["repairLayer", "repairSymbols", "sourceSymbols", "scope"];
+function rejectRepairTrackGeometry(path, fields, fail) {
+  for (const key of REPAIR_TRACK_GEOMETRY_KEYS) {
+    if (fields[key] !== void 0) {
+      fail(
+        "track_repair_geometry",
+        `${path}.${key}`,
+        "a repair track carries no block geometry; it is shared with the source track's fec object"
+      );
+    }
+  }
+}
+function repairReachability(fecObjects) {
+  let declaresFecSource = false;
+  const layerZeroNames = /* @__PURE__ */ new Set();
+  for (const candidate of fecObjects) {
+    if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) continue;
+    const fec = candidate;
+    if (fec["algorithm"] === "none") continue;
+    declaresFecSource = true;
+    const repairTrack = fec["repairTrack"];
+    if (typeof repairTrack === "string" && repairTrack.length > 0) layerZeroNames.add(repairTrack);
+  }
+  return { declaresFecSource, layerZeroNames };
+}
+function assertRepairTrackReachable(descriptor, reachability, fail) {
+  if (dependsTarget(descriptor) !== void 0) return;
+  if (reachability.declaresFecSource && !reachability.layerZeroNames.has(descriptor.name)) {
+    fail(
+      "track_repair_depends",
+      `${descriptor.path}.depends`,
+      "no source names this repair track in fec.repairTrack and it declares no depends"
+    );
+  }
+}
+function rejectRepairFieldsOnMediaTrack(path, fields, fail) {
+  for (const key of REPAIR_TRACK_ONLY_KEYS) {
+    if (fields[key] !== void 0) {
+      fail("track_repair_layer", `${path}.${key}`, `${key} is a repair track field`);
+    }
+  }
+}
+function describeRepairTrack(name, path, fields) {
+  const descriptor = { name, path };
+  for (const field of REPAIR_FIELDS) {
+    if (field in fields) descriptor[field] = fields[field];
+  }
+  return descriptor;
+}
+function isSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value);
+}
+function positiveInteger(value) {
+  return isSafeInteger(value) && value > 0;
+}
+function dependsTarget(descriptor) {
+  const depends = descriptor.depends;
+  return Array.isArray(depends) && depends.length === 1 && typeof depends[0] === "string" && depends[0].length > 0 ? depends[0] : void 0;
+}
+function validateRepairTrackFields(descriptor, fail) {
+  const { path } = descriptor;
+  if (descriptor.depends !== void 0 && dependsTarget(descriptor) === void 0) {
+    fail("track_repair_depends", `${path}.depends`, "must name exactly one source track");
+  }
+  if (descriptor.repairLayer !== void 0 && (!isSafeInteger(descriptor.repairLayer) || descriptor.repairLayer < 0)) {
+    fail("track_repair_layer", `${path}.repairLayer`, "must be a non-negative integer");
+  }
+  if (descriptor.repairSymbols !== void 0 && (!positiveInteger(descriptor.repairSymbols) || descriptor.repairSymbols > MAX_REPAIR_SYMBOLS)) {
+    fail("track_repair_layer", `${path}.repairSymbols`, `must be a positive integer at most ${MAX_REPAIR_SYMBOLS}`);
+  }
+  if (descriptor.priority !== void 0 && (!isSafeInteger(descriptor.priority) || descriptor.priority < REPAIR_PRIORITY_MIN || descriptor.priority > REPAIR_PRIORITY_MAX)) {
+    fail(
+      "track_repair_priority",
+      `${path}.priority`,
+      `must be an integer from ${REPAIR_PRIORITY_MIN} to ${REPAIR_PRIORITY_MAX} (MoQT scale, lower first)`
+    );
+  }
+  if (descriptor.scope !== void 0) {
+    if (descriptor.scope !== "keyframe") {
+      fail("track_repair_overlay", `${path}.scope`, 'must be "keyframe"');
+    }
+    if (descriptor.repairLayer !== void 0) {
+      fail("track_repair_overlay", `${path}.repairLayer`, "an overlay is a separate FEC instance and carries no repairLayer");
+    }
+    for (const field of ["depends", "sourceSymbols", "repairSymbols", "priority"]) {
+      if (descriptor[field] === void 0) {
+        fail("track_repair_overlay", `${path}.${field}`, `an overlay must declare ${field}`);
+      }
+    }
+  }
+  if (descriptor.sourceSymbols !== void 0) {
+    if (descriptor.scope === void 0) {
+      fail("track_repair_overlay", `${path}.sourceSymbols`, "only an overlay (scope: keyframe) declares its own sourceSymbols");
+    }
+    if (!positiveInteger(descriptor.sourceSymbols) || descriptor.sourceSymbols > MAX_RAPTORQ_SOURCE_SYMBOLS) {
+      fail(
+        "track_fec_bounds",
+        `${path}.sourceSymbols`,
+        `must be a positive integer at most ${MAX_RAPTORQ_SOURCE_SYMBOLS} (RFC 6330 source block limit)`
+      );
+    }
+  }
+  if (isSafeInteger(descriptor.repairLayer) && descriptor.repairLayer >= 1) {
+    for (const field of ["depends", "repairSymbols", "priority"]) {
+      if (descriptor[field] === void 0) {
+        fail("track_repair_layer", `${path}.${field}`, `repair layer ${descriptor.repairLayer} must declare ${field}`);
+      }
+    }
+  }
+}
+function assembleRepairLayers(source, descriptors, fail = throwRepairContractError, options = {}) {
+  const layerZeroName = typeof source.repairTrack === "string" && source.repairTrack.length > 0 ? source.repairTrack : void 0;
+  const layerZero = layerZeroName === void 0 ? void 0 : descriptors.find((d) => d.name === layerZeroName);
+  if (layerZeroName !== void 0 && layerZero === void 0 && options.layerZeroMustBeDeclared) {
+    fail("track_repair_track", `${source.path}.repairTrack`, `unknown FEC repair track ${JSON.stringify(layerZeroName)}`);
+  }
+  const dependents = descriptors.filter((d) => d.name !== layerZeroName && dependsTarget(d) === source.name);
+  const k = positiveInteger(source.sourceSymbols) ? source.sourceSymbols : 0;
+  if (source.algorithm === "raptorq" && k > MAX_RAPTORQ_SOURCE_SYMBOLS) {
+    fail(
+      "track_fec_bounds",
+      `${source.path}.sourceSymbols`,
+      `must be at most ${MAX_RAPTORQ_SOURCE_SYMBOLS} (RFC 6330 source block limit)`
+    );
+  }
+  if (layerZeroName === void 0) {
+    if (dependents.length === 0) return void 0;
+    fail(
+      "track_repair_layer",
+      `${dependents[0].path}.depends`,
+      `repair layers of ${JSON.stringify(source.name)} require a layer 0 (fec.repairTrack) on the source`
+    );
+  }
+  const layered = dependents.length > 0;
+  let layerZeroSymbols = 0;
+  if (positiveInteger(source.repairSymbols)) {
+    layerZeroSymbols = source.repairSymbols;
+  } else if (layered) {
+    fail("track_fec", `${source.path}.repairSymbols`, "layered or overlay repair needs a positive integer repairSymbols on layer 0");
+  }
+  if (layered && !positiveInteger(source.sourceSymbols)) {
+    fail("track_fec", `${source.path}.sourceSymbols`, "layered or overlay repair needs a positive integer sourceSymbols on the source");
+  }
+  if (layered && source.algorithm !== "raptorq") {
+    fail(
+      "track_fec",
+      `${source.path}.algorithm`,
+      "repair layers and overlays are defined only for raptorq: a block code fixes its codeword length, so symbols of a larger P are not symbols of the code a receiver holding fewer layers decodes"
+    );
+  }
+  let layerZeroPriority = DEFAULT_REPAIR_PRIORITY;
+  if (layerZero !== void 0) {
+    if (layerZero.depends !== void 0 && dependsTarget(layerZero) !== source.name) {
+      fail(
+        "track_repair_depends",
+        `${layerZero.path}.depends`,
+        `layer 0 of ${JSON.stringify(source.name)} must depend on that source`
+      );
+    }
+    if (layerZero.repairLayer !== void 0 && layerZero.repairLayer !== 0) {
+      fail("track_repair_layer", `${layerZero.path}.repairLayer`, "the track named by fec.repairTrack is layer 0");
+    }
+    if (layerZero.scope !== void 0) {
+      fail("track_repair_overlay", `${layerZero.path}.scope`, "the track named by fec.repairTrack is base layer 0, not an overlay");
+    }
+    if (layerZero.repairSymbols !== void 0 && layerZero.repairSymbols !== layerZeroSymbols) {
+      fail(
+        "track_repair_layer",
+        `${layerZero.path}.repairSymbols`,
+        `must agree with the source's fec.repairSymbols (${layerZeroSymbols})`
+      );
+    }
+    if (typeof layerZero.priority === "number") layerZeroPriority = layerZero.priority;
+  }
+  const baseLayers = [
+    { layer: 0, repairTrackName: layerZeroName, repairSymbols: layerZeroSymbols, rsIdOffset: 0, priority: layerZeroPriority }
+  ];
+  const overlays = [];
+  for (const d of dependents) {
+    if (d.scope === void 0 && d.repairLayer === void 0) {
+      fail(
+        "track_repair_layer",
+        `${d.path}.repairLayer`,
+        `a repair track that depends on ${JSON.stringify(source.name)} must declare repairLayer (1..n) or scope: "keyframe"`
+      );
+    }
+  }
+  const layerTracks = dependents.filter((d) => d.scope === void 0).sort((a, b) => a.repairLayer - b.repairLayer);
+  for (const d of dependents) {
+    if (d.scope !== "keyframe") continue;
+    if (overlays.length === 1) {
+      fail(
+        "track_repair_overlay",
+        `${d.path}.scope`,
+        `${JSON.stringify(source.name)} already has keyframe overlay ${JSON.stringify(overlays[0].repairTrackName)}: a RAP packet carries exactly two Source FEC Payload IDs (base, then overlay), so one overlay per source`
+      );
+    }
+    const sourceSymbols = d.sourceSymbols;
+    const repairSymbols = d.repairSymbols;
+    if (sourceSymbols + repairSymbols - 1 > MAX_ENCODING_SYMBOL_ID) {
+      fail(
+        "track_fec_bounds",
+        `${d.path}.repairSymbols`,
+        `overlay sourceSymbols + repairSymbols - 1 exceeds the 24-bit ESI space (${MAX_ENCODING_SYMBOL_ID})`
+      );
+    }
+    overlays.push({ repairTrackName: d.name, scope: "keyframe", sourceSymbols, repairSymbols, priority: d.priority });
+  }
+  let offset = layerZeroSymbols;
+  let previousPriority = layerZeroPriority;
+  layerTracks.forEach((d, i) => {
+    const expected = i + 1;
+    if (d.repairLayer === 0) {
+      fail("track_repair_layer", `${d.path}.repairLayer`, `layer 0 of ${JSON.stringify(source.name)} is ${JSON.stringify(layerZeroName)}, named by fec.repairTrack`);
+    }
+    if (d.repairLayer !== expected) {
+      fail(
+        "track_repair_layer",
+        `${d.path}.repairLayer`,
+        i > 0 && d.repairLayer === layerTracks[i - 1].repairLayer ? `repair layer ${d.repairLayer} is declared twice for ${JSON.stringify(source.name)}` : `repair layers must be contiguous from 1: expected ${expected}, found ${d.repairLayer}`
+      );
+    }
+    const priority = d.priority;
+    if (priority < previousPriority) {
+      fail(
+        "track_repair_priority",
+        `${d.path}.priority`,
+        `must be at least ${previousPriority}, the priority of layer ${expected - 1}: priority is monotonic non-decreasing with layer index`
+      );
+    }
+    previousPriority = priority;
+    const repairSymbols = d.repairSymbols;
+    baseLayers.push({ layer: expected, repairTrackName: d.name, repairSymbols, rsIdOffset: offset, priority });
+    offset += repairSymbols;
+  });
+  const totalBaseRepairSymbols = offset;
+  if (totalBaseRepairSymbols > MAX_REPAIR_SYMBOLS) {
+    fail(
+      "track_fec_bounds",
+      `${layerTracks.length === 0 ? source.path : layerTracks[layerTracks.length - 1].path}.repairSymbols`,
+      `total repair symbols across base layers exceeds the 24-bit RS_ID space (${MAX_REPAIR_SYMBOLS})`
+    );
+  }
+  if (k + totalBaseRepairSymbols - 1 > MAX_ENCODING_SYMBOL_ID) {
+    fail(
+      "track_fec_bounds",
+      `${source.path}.sourceSymbols`,
+      `sourceSymbols + total base repair symbols - 1 exceeds the 24-bit ESI space (${MAX_ENCODING_SYMBOL_ID})`
+    );
+  }
+  return { sourceTrackName: source.name, baseLayers, overlays, totalBaseRepairSymbols };
+}
+
 // src/carp-catalog.ts
 var VALID_ROLE_SUFFIXES = /* @__PURE__ */ new Set(["base", "delta", "repair"]);
 function parseTrackRole(trackName) {
@@ -5861,7 +6212,7 @@ function validateCmsfMmtpCatalog(value) {
   const tracks = catalog["tracks"];
   const trackRecords = [];
   const effective = (track, field) => track[field] ?? common[field];
-  const positiveInteger = (input) => Number.isSafeInteger(input) && input > 0;
+  const positiveInteger2 = (input) => Number.isSafeInteger(input) && input > 0;
   const positiveNumber = (input) => typeof input === "number" && Number.isFinite(input) && input > 0;
   for (let index = 0; index < tracks.length; index++) {
     const raw = tracks[index];
@@ -5897,21 +6248,27 @@ function validateCmsfMmtpCatalog(value) {
     const groupDurationTicks = effective(track, "groupDurationTicks");
     const keyframeIntervalMs = effective(track, "keyframeIntervalMs");
     const keyframeIntervalTicks = effective(track, "keyframeIntervalTicks");
-    if (groupDurationMs !== void 0 && !positiveInteger(groupDurationMs)) {
+    if (groupDurationMs !== void 0 && !positiveInteger2(groupDurationMs)) {
       catalogError("track_group_duration_ms", `${path}.groupDurationMs`, "must be a positive integer");
     }
-    if (groupDurationTicks !== void 0 && !positiveInteger(groupDurationTicks)) {
+    if (groupDurationTicks !== void 0 && !positiveInteger2(groupDurationTicks)) {
       catalogError("track_group_duration_ticks", `${path}.groupDurationTicks`, "must be a positive integer");
     }
-    if (keyframeIntervalMs !== void 0 && !positiveNumber(keyframeIntervalMs) || keyframeIntervalTicks !== void 0 && !positiveInteger(keyframeIntervalTicks)) {
+    if (keyframeIntervalMs !== void 0 && !positiveNumber(keyframeIntervalMs) || keyframeIntervalTicks !== void 0 && !positiveInteger2(keyframeIntervalTicks)) {
       catalogError("track_keyframe_interval", path, "keyframe interval fields must be positive numbers");
     }
+    if (packaging === "fec-repair") {
+      rejectRepairTrackGeometry(path, track, catalogError);
+      validateRepairTrackFields(describeRepairTrack(name, path, track), catalogError);
+    } else {
+      rejectRepairFieldsOnMediaTrack(path, track, catalogError);
+    }
     if (packaging === "mmtp") {
       const mmtpMode = effective(track, "mmtpMode");
       if (mmtpMode !== "mpu" && mmtpMode !== "mfu") {
         catalogError("track_mmtp_mode", `${path}.mmtpMode`, "must be mpu or mfu");
       }
-      if (!positiveInteger(timescale)) {
+      if (!positiveInteger2(timescale)) {
         catalogError("track_timescale", `${path}.timescale`, "must be a positive integer");
       }
       if (groupDurationMs === void 0 && groupDurationTicks === void 0) {
@@ -5938,12 +6295,19 @@ function validateCmsfMmtpCatalog(value) {
       if ("interleaveDepth" in config || "interleaveMs" in config) {
         catalogError("track_fec", `${path}.fec`, "interleaveDepthMs is the only supported interleave field");
       }
-      if (config["interleaveDepthMs"] !== void 0 && !positiveInteger(config["interleaveDepthMs"])) {
+      if ("enhancementRepair" in config) {
+        catalogError(
+          "track_fec",
+          `${path}.fec.enhancementRepair`,
+          "repair layers are self-describing fec-repair tracks (depends, repairLayer); fec.enhancementRepair is not supported"
+        );
+      }
+      if (config["interleaveDepthMs"] !== void 0 && !positiveInteger2(config["interleaveDepthMs"])) {
         catalogError("track_fec", `${path}.fec.interleaveDepthMs`, "must be a positive integer");
       }
       if (algorithm !== "none") {
         for (const field of ["sourceSymbols", "repairSymbols", "symbolSize"]) {
-          if (!positiveInteger(config[field])) {
+          if (!positiveInteger2(config[field])) {
             catalogError("track_fec", `${path}.fec.${field}`, "must be a positive integer");
           }
         }
@@ -5953,15 +6317,43 @@ function validateCmsfMmtpCatalog(value) {
       }
     }
   }
+  const repairDescriptors = trackRecords.flatMap(
+    (track, index) => effective(track, "packaging") === "fec-repair" ? [describeRepairTrack(track["name"], `$.tracks[${index}]`, track)] : []
+  );
+  const reachability = repairReachability(
+    trackRecords.filter((track) => effective(track, "packaging") !== "fec-repair").map((track) => track["fec"])
+  );
+  for (const descriptor of repairDescriptors) {
+    assertRepairTrackReachable(descriptor, reachability, catalogError);
+    const target = dependsTarget(descriptor);
+    if (target === void 0) continue;
+    const source = trackRecords.find((candidate) => candidate["name"] === target);
+    const sourceFec = source?.["fec"];
+    if (!source || effective(source, "packaging") !== "mmtp" || !sourceFec || sourceFec["algorithm"] === "none") {
+      catalogError(
+        "track_repair_depends",
+        `${descriptor.path}.depends`,
+        `${JSON.stringify(target)} is not an mmtp track with FEC`
+      );
+    }
+  }
   for (let index = 0; index < trackRecords.length; index++) {
     const track = trackRecords[index];
     const fec = track["fec"];
     if (!fec || fec["algorithm"] === "none") continue;
-    const repairTrack = fec["repairTrack"];
-    const target = trackRecords.find((candidate) => candidate["name"] === repairTrack);
-    if (!target || effective(target, "packaging") !== "fec-repair") {
-      catalogError("track_repair_track", `$.tracks[${index}].fec.repairTrack`, `unknown FEC repair track ${JSON.stringify(repairTrack)}`);
-    }
+    assembleRepairLayers(
+      {
+        name: track["name"],
+        path: `$.tracks[${index}].fec`,
+        algorithm: fec["algorithm"],
+        sourceSymbols: fec["sourceSymbols"],
+        repairSymbols: fec["repairSymbols"],
+        repairTrack: fec["repairTrack"]
+      },
+      repairDescriptors,
+      catalogError,
+      { layerZeroMustBeDeclared: true }
+    );
   }
   const switchingSets = /* @__PURE__ */ new Map();
   for (let index = 0; index < trackRecords.length; index++) {
@@ -7385,6 +7777,7 @@ var MmtpToCmaf = class {
     const samplesPerFrame = __privateGet(this, _audioTimescale) !== 1e6 ? __privateGet(this, _aacFrameSamples) : sampleDuration;
     const scaledTs = __privateGet(this, _audioTimescale) !== 1e6 ? __privateGet(this, _audioSampleCount) * samplesPerFrame : timestamp - __privateGet(this, _audioBaseTs);
     __privateWrapper(this, _audioSampleCount)._++;
+    const scaledCompositionTimeOffset = compositionTimeOffset === void 0 || __privateGet(this, _audioTimescale) === 1e6 ? compositionTimeOffset : Math.round(compositionTimeOffset * __privateGet(this, _audioTimescale) / 1e6);
     return encodeDataSegment(
       sampleData,
       scaledTs,
@@ -7392,7 +7785,7 @@ var MmtpToCmaf = class {
       true,
       __privateWrapper(this, _audioSeq)._++,
       1,
-      compositionTimeOffset
+      scaledCompositionTimeOffset
     );
   }
   /** Convert an ordered audio batch using the caller-owned timeline. */
@@ -8501,6 +8894,15 @@ function deriveFecInterleaveDepth(interleaveDepthMs, mediaUnitDurationMs) {
   }
   return Math.max(1, Math.floor(interleaveDepthMs / mediaUnitDurationMs + 0.5));
 }
+function fecBlockBudgetMs(interleaveDepthMs, reorderToleranceMs) {
+  if (!Number.isFinite(interleaveDepthMs) || !(interleaveDepthMs > 0)) {
+    throw new Error(`[FEC] interleaveDepthMs must be a finite value > 0 (got ${interleaveDepthMs}ms). Fix encoder config.`);
+  }
+  if (!(reorderToleranceMs >= 0) || !Number.isFinite(reorderToleranceMs)) {
+    throw new Error(`[FEC] reorderToleranceMs must be a finite value >= 0 (got ${reorderToleranceMs}ms). It is a catalog value (fec.reorderToleranceMs), not a local default.`);
+  }
+  return Math.ceil(interleaveDepthMs + reorderToleranceMs);
+}
 function parseRepairPacket(packet) {
   const parsed = parseMoqRepairFrame(packet);
   if (!parsed)
@@ -8602,32 +9004,18 @@ function computeFecLossWindowMs(fecInterleaveMs, fecK, jitterBufferMs) {
 function computeFecDeliveryWindowMs(config) {
   const fecInterleaveMs = config.interleaveDepthMs;
   const fecK = config.sourceSymbols;
-  if (fecInterleaveMs <= 0) {
+  if (!Number.isFinite(fecInterleaveMs) || fecInterleaveMs <= 0) {
     throw new Error(
       `[TrackSession] fecInterleaveMs=${fecInterleaveMs}. Derive a positive FEC interleave window from the stream catalog.`
     );
   }
-  if (fecK <= 0) {
+  if (!Number.isFinite(fecK) || 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);
+  if (config.jitterBufferMs === void 0) return Math.ceil(fecInterleaveMs);
+  return fecBlockBudgetMs(fecInterleaveMs, config.jitterBufferMs);
 }
 function computeFecDeliveryWindowMediaUnits(config, timestampTimescale) {
   if (!Number.isFinite(timestampTimescale) || timestampTimescale <= 0) {
@@ -8643,7 +9031,7 @@ function computeFecDeliveryWindowMediaUnits(config, timestampTimescale) {
   }
   return deliveryWindow;
 }
-var _state, _subscription, _hysteresisTimer, _joinDeadlineTimer, _previousPrimary, _manager, _suppressFired, _TrackSession_instances, transition_fn, clearHysteresis_fn, armJoinDeadline_fn, clearJoinDeadline_fn, suppress_fn, unsuppress_fn;
+var _state, _subscription, _hysteresisTimer, _joinDeadlineTimer, _previousPrimary, _manager, _suppressFired, _fecArmed, _TrackSession_instances, transition_fn, clearHysteresis_fn, armJoinDeadline_fn, clearJoinDeadline_fn, armFec_fn, disarmFec_fn, suppress_fn, unsuppress_fn;
 var TrackSession = class {
   constructor(config, manager) {
     __privateAdd(this, _TrackSession_instances);
@@ -8660,6 +9048,12 @@ var TrackSession = class {
     // from `failing` (exactly where a starving track sits) was re-subscribed to
     // unicast with the host's media still muted: MoQ playing into a dead sink.
     __privateAdd(this, _suppressFired, false);
+    // Single FEC authority flag: set by the fec-setup edges (joinStarted,
+    // enterUnicastFallback), cleared by the fec-teardown edge in #transition.
+    // Setup and teardown are paired by construction, so a takeover timeout that
+    // parks the session in `unicast` keeps the decoder the still-joined
+    // transport is feeding, and the later unsubscribe still tears it down.
+    __privateAdd(this, _fecArmed, false);
     this.config = config;
     __privateSet(this, _manager, manager);
   }
@@ -8734,7 +9128,7 @@ var TrackSession = class {
   joinStarted() {
     if (__privateGet(this, _state) !== "unicast") return;
     __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "joining");
-    __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "fec-setup" }, this.config);
+    __privateMethod(this, _TrackSession_instances, armFec_fn).call(this);
   }
   /**
    * any non-fallback state → unicast-fallback. Used when the SSM bridge is
@@ -8755,7 +9149,7 @@ var TrackSession = class {
     __privateMethod(this, _TrackSession_instances, clearHysteresis_fn).call(this);
     __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast-fallback");
     __privateMethod(this, _TrackSession_instances, suppress_fn).call(this);
-    __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "fec-setup" }, this.config);
+    __privateMethod(this, _TrackSession_instances, armFec_fn).call(this);
   }
   /**
    * unicast-fallback → unicast. Called when the SSM bridge appears mid-session
@@ -8786,7 +9180,11 @@ var TrackSession = class {
     if (__privateGet(this, _state) !== "multicast" && __privateGet(this, _state) !== "amt") return;
     __privateSet(this, _previousPrimary, __privateGet(this, _state));
     __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "failing");
-    const hysteresisMs = computeFecLossWindowMs(this.config.fecInterleaveMs, this.config.fecK);
+    const hysteresisMs = computeFecLossWindowMs(
+      this.config.fecInterleaveMs,
+      this.config.fecK,
+      this.config.fecReorderToleranceMs
+    );
     __privateSet(this, _hysteresisTimer, setTimeout(() => {
       this.hysteresisExpired();
     }, hysteresisMs));
@@ -8810,23 +9208,19 @@ var TrackSession = class {
     const prefs = this.config.preferredTransports;
     const currentIdx = current ? prefs.indexOf(current) : -1;
     const nextMode = prefs[currentIdx + 1];
-    if (nextMode) {
-      if (nextMode === "moq") {
-        __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast");
-        __privateMethod(this, _TrackSession_instances, unsuppress_fn).call(this);
-        if (this.config.trackType === "audio") {
-          __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "reset" }, this.config);
-        }
-      } else {
-        __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "joining");
-        __privateMethod(this, _TrackSession_instances, unsuppress_fn).call(this);
-      }
-    } else {
-      __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast");
+    if (nextMode !== void 0 && nextMode !== "moq") {
+      __privateSet(this, _previousPrimary, nextMode);
+      __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "joining");
       __privateMethod(this, _TrackSession_instances, unsuppress_fn).call(this);
-      if (this.config.trackType === "audio") {
-        __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "reset" }, this.config);
-      }
+      return;
+    }
+    const from = __privateGet(this, _state);
+    __privateSet(this, _previousPrimary, null);
+    __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast");
+    __privateMethod(this, _TrackSession_instances, disarmFec_fn).call(this);
+    __privateMethod(this, _TrackSession_instances, unsuppress_fn).call(this);
+    if (from !== "unicast" && this.config.trackType === "audio") {
+      __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "reset" }, this.config);
     }
   }
   /** Hysteresis expired → failback to next transport (Claim 9g). */
@@ -8850,11 +9244,20 @@ var TrackSession = class {
   get isUnicastFallback() {
     return __privateGet(this, _state) === "unicast-fallback";
   }
+  /**
+   * True while this track owns a FEC decoder (fec-setup fired, fec-teardown
+   * not yet). Stays true across a takeover timeout that parked the session in
+   * `unicast`; SessionManager.failbackAll uses it to release such sessions.
+   */
+  get isFecArmed() {
+    return __privateGet(this, _fecArmed);
+  }
   dispose() {
     __privateMethod(this, _TrackSession_instances, clearHysteresis_fn).call(this);
     __privateMethod(this, _TrackSession_instances, clearJoinDeadline_fn).call(this);
     __privateSet(this, _state, "idle");
     __privateSet(this, _subscription, null);
+    __privateMethod(this, _TrackSession_instances, disarmFec_fn).call(this);
   }
 };
 _state = new WeakMap();
@@ -8864,20 +9267,20 @@ _joinDeadlineTimer = new WeakMap();
 _previousPrimary = new WeakMap();
 _manager = new WeakMap();
 _suppressFired = new WeakMap();
+_fecArmed = new WeakMap();
 _TrackSession_instances = new WeakSet();
 // -----------------------------------------------------------------------
 // Internal
 // -----------------------------------------------------------------------
-transition_fn = function(to) {
+transition_fn = function(to, opts) {
   const from = __privateGet(this, _state);
   if (from === to) return;
+  const joinDeadlineMs = to === "joining" ? __privateGet(this, _manager).takeoverDeadlineMs : void 0;
   __privateSet(this, _state, to);
   if (from === "joining") __privateMethod(this, _TrackSession_instances, clearJoinDeadline_fn).call(this);
-  if (to === "joining") __privateMethod(this, _TrackSession_instances, armJoinDeadline_fn).call(this);
+  if (joinDeadlineMs !== void 0) __privateMethod(this, _TrackSession_instances, armJoinDeadline_fn).call(this, joinDeadlineMs);
   const fecActive = (s) => s === "joining" || s === "multicast" || s === "amt" || s === "failing" || s === "unicast-fallback";
-  if (fecActive(from) && !fecActive(to)) {
-    __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "fec-teardown" }, this.config);
-  }
+  if (!fecActive(to) && !opts?.retainFec) __privateMethod(this, _TrackSession_instances, disarmFec_fn).call(this);
   __privateGet(this, _manager).callbacks?.onStateChange?.(this.config.trackName, from, to);
 };
 clearHysteresis_fn = function() {
@@ -8886,14 +9289,13 @@ clearHysteresis_fn = function() {
     __privateSet(this, _hysteresisTimer, null);
   }
 };
-armJoinDeadline_fn = function() {
+armJoinDeadline_fn = function(deadlineMs) {
   __privateMethod(this, _TrackSession_instances, clearJoinDeadline_fn).call(this);
-  const deadlineMs = __privateGet(this, _manager).takeoverDeadlineMs;
-  if (deadlineMs <= 0) return;
+  if (deadlineMs === 0) return;
   __privateSet(this, _joinDeadlineTimer, setTimeout(() => {
     __privateSet(this, _joinDeadlineTimer, null);
     if (__privateGet(this, _state) !== "joining") return;
-    __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast");
+    __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast", { retainFec: true });
     __privateGet(this, _manager).callbacks?.onTakeoverTimeout?.(this.config.trackName);
   }, deadlineMs));
 };
@@ -8903,6 +9305,18 @@ clearJoinDeadline_fn = function() {
     __privateSet(this, _joinDeadlineTimer, null);
   }
 };
+/** Fire fec-setup exactly once per FEC epoch. */
+armFec_fn = function() {
+  if (__privateGet(this, _fecArmed)) return;
+  __privateSet(this, _fecArmed, true);
+  __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "fec-setup" }, this.config);
+};
+/** Fire fec-teardown for an armed decoder; no-op when none is armed. */
+disarmFec_fn = function() {
+  if (!__privateGet(this, _fecArmed)) return;
+  __privateSet(this, _fecArmed, false);
+  __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "fec-teardown" }, this.config);
+};
 /** Fire onSuppress(true) exactly once per suppression epoch. */
 suppress_fn = function() {
   if (__privateGet(this, _suppressFired)) return;
@@ -8915,18 +9329,14 @@ unsuppress_fn = function() {
   __privateSet(this, _suppressFired, false);
   __privateGet(this, _manager).callbacks?.onSuppress?.(this.config.trackName, false);
 };
+var MAX_TAKEOVER_DEADLINE_MS = 2147483647;
+var _takeoverDeadlineMs, _SessionManager_instances, requireTakeoverDeadlineMs_fn;
 var SessionManager = class {
   constructor(poolOptions) {
+    __privateAdd(this, _SessionManager_instances);
     this.sessions = /* @__PURE__ */ new Map();
     this.callbacks = null;
-    /**
-     * Takeover deadline (BLO-9413/D9): max time a session may sit in `joining`
-     * without a RAP before returning to `unicast` and firing onTakeoverTimeout.
-     * MoQ is never suppressed during `joining`, so expiry is a silent abandon —
-     * playback never glitches. Hosts tune per stream (e.g. GOP length); 0
-     * disables.
-     */
-    this.takeoverDeadlineMs = 5e3;
+    __privateAdd(this, _takeoverDeadlineMs);
     this.pool = new TransportPool(poolOptions);
     this.pool.onSubscriptionFailed((sub) => {
       for (const trackName of sub.consumers) {
@@ -8935,18 +9345,56 @@ var SessionManager = class {
       }
     });
   }
+  /**
+   * Takeover deadline (BLO-9413/D9): the time a session may sit in `joining`
+   * without a RAP before returning to `unicast` and firing onTakeoverTimeout.
+   * MoQ is never suppressed during `joining`, so expiry abandons the takeover
+   * without a playback glitch. The host derives it from the catalog (RAP
+   * cadence from groupDurationTicks/timescale plus the signaled FEC delivery
+   * window or reorder tolerance) and sets it before addTrack(). There is no
+   * default: an unset value fails addTrack() closed, and reading the getter
+   * before assignment throws the same way, so no host ever holds a
+   * `number | undefined` it could coalesce back into a default.
+   * `hasTakeoverDeadline` answers whether one was admitted. A declared 0
+   * disables the deadline. The value is an integer number of milliseconds:
+   * setTimeout truncates fractions, so a host that divides ticks by a
+   * timescale must round before assigning.
+   *
+   * Assignment validates, so the diagnostic lands at the host's own call site.
+   * That is what bounds the blast radius: `joining` is entered from
+   * joinStarted(), from the transportFailed() failover branch -- itself
+   * reachable from a setTimeout via hysteresisExpired(), where no caller could
+   * catch a throw -- and from the activateMulticast()/activateAmt()/pool-failure
+   * loops, where a throw on one session would abandon its siblings mid-loop
+   * (the split-brain those loops exist to prevent). Refusing a bad value at
+   * assignment means no host mutation can make an already-admitted session
+   * throw out of a transport edge.
+   */
+  get takeoverDeadlineMs() {
+    return __privateMethod(this, _SessionManager_instances, requireTakeoverDeadlineMs_fn).call(this);
+  }
+  set takeoverDeadlineMs(value) {
+    if (!Number.isInteger(value) || value < 0 || value > MAX_TAKEOVER_DEADLINE_MS) {
+      throw new Error(
+        `[SessionManager] takeoverDeadlineMs must be an integer from 0 to ${MAX_TAKEOVER_DEADLINE_MS} (0 disables it, larger values overflow setTimeout); got ${String(value)}`
+      );
+    }
+    __privateSet(this, _takeoverDeadlineMs, value);
+  }
+  /** True once the host has admitted a deadline; a declared 0 counts. */
+  get hasTakeoverDeadline() {
+    return __privateGet(this, _takeoverDeadlineMs) !== void 0;
+  }
   /** Narrow to MMTP callbacks (onTrackEvent). Safe — optional chaining handles PIM-only consumers. */
   get mmtp() {
     return this.callbacks;
   }
-  // -----------------------------------------------------------------------
-  // Track management
-  // -----------------------------------------------------------------------
   /** Add a track session from catalog config. */
   addTrack(config) {
     if (this.sessions.has(config.trackName)) {
       throw new Error(`[SessionManager] Track "${config.trackName}" already exists`);
     }
+    __privateMethod(this, _SessionManager_instances, requireTakeoverDeadlineMs_fn).call(this);
     const session = new TrackSession(config, this);
     this.sessions.set(config.trackName, session);
     return session;
@@ -8970,8 +9418,9 @@ var SessionManager = class {
    * Prevents split-brain between video and audio.
    *
    * A takeover deadline can return a track from `joining` to `unicast` while
-   * the multicast socket keeps delivering packets. If a valid RAP arrives
-   * later, allow that late-RAP edge to suppress unicast and promote multicast.
+   * the multicast socket keeps delivering packets and the track keeps its FEC
+   * decoder armed. If a valid RAP arrives later, that late-RAP edge suppresses
+   * unicast and promotes multicast without a second fec-setup.
    */
   activateMulticast() {
     for (const [, session] of this.sessions) {
@@ -9003,13 +9452,17 @@ var SessionManager = class {
    * and they must drain uninterrupted across transport-state events.
    *
    * Coherence invariant (BLO-9413): after this returns, every non-fallback
-   * session is `unicast` (or `idle`) AND unsuppressed — unsubscribe() unwinds
-   * any outstanding suppression regardless of the state it tears down from
-   * (`failing` included; see TrackSession.#suppressFired).
+   * session is `unicast` (or `idle`), unsuppressed, and without a FEC decoder.
+   * unsubscribe() unwinds any outstanding suppression regardless of the state
+   * it tears down from (`failing` included; see TrackSession.#suppressFired),
+   * and a session that a takeover timeout parked in `unicast` with its decoder
+   * still armed is cycled too, because this transport edge is what releases
+   * that decoder (unsubscribe fires fec-teardown).
    */
   failbackAll() {
     for (const [, session] of this.sessions) {
-      if (session.state !== "idle" && session.state !== "unicast" && session.state !== "unicast-fallback") {
+      const parkedWithFec = session.state === "unicast" && session.isFecArmed;
+      if (parkedWithFec || session.state !== "idle" && session.state !== "unicast" && session.state !== "unicast-fallback") {
         session.unsubscribe();
         session.subscribe();
       }
@@ -9093,6 +9546,27 @@ var SessionManager = class {
     this.callbacks = null;
   }
 };
+_takeoverDeadlineMs = new WeakMap();
+_SessionManager_instances = new WeakSet();
+// -----------------------------------------------------------------------
+// Track management
+// -----------------------------------------------------------------------
+/**
+ * The admitted takeover deadline. Throws only when the host never set one,
+ * every other invalid value being refused by the setter, and returns a
+ * declared 0 as 0. The getter and addTrack() both route through it, so a
+ * session cannot exist without an admitted deadline, which is what makes
+ * the #transition() read unable to throw on an already-admitted session.
+ */
+requireTakeoverDeadlineMs_fn = function() {
+  const value = __privateGet(this, _takeoverDeadlineMs);
+  if (value === void 0) {
+    throw new Error(
+      "[SessionManager] takeoverDeadlineMs is unset; set a catalog-derived takeover deadline (0 disables it) before adding tracks"
+    );
+  }
+  return value;
+};
 
 // src/fec-manager.ts
 var MIN_INTERLEAVE_DEPTH_MS = 33;
@@ -9111,7 +9585,7 @@ function newFecCounters() {
     greenFillFrames: 0
   };
 }
-var _fecDecoders, _workerClients, _syncDecoderBlockOwners, _decoderBlockOwners, _fecK, _fecSymbolSize, _fecTimeoutMs, _trackConfigs, _fecStats, _fecTrackStats, _fecWorkerStats, _fecStatsObservers, _activeBlocks, _activeBlockDeadlinesMs, _activeBlockTimeoutOwners, _lifecycleTrace, _pendingWorkerCleanups, _pendingWorkerCleanupClients, _blockSourceCounts, _blockSourceEsis, _blockRepairRsIds, _completedBlocks, _seenSymbols, _blockPathCounts, _blockCatalogTrackNames, _startupAlignedPackets, _startupPartialBlocks, _startupRequireRepairReady, _startupRepairReadyPackets, _startupRepairBoundaryCounts, _startupRepairFailOpenPackets, _cleanlyCompletedBlocks, _repairRequestedBlocks, _repairDeadlines, _workerRecoveredBlocks, _fpsDetected, _fecFps, _fecInterleaveDepthMs, _workerErrorCounts, _repairSymbolSizeMismatchCount, _FECManager_instances, streamKey_fn, belongsToPacket_fn, belongsToStream_fn, packetIdsForStreamKeys_fn, blockKey_fn, parseBlockKey_fn, decoderForPacket_fn, workerForPacket_fn, claimDecoderBlock_fn, decoderBlockCatalogTrackName_fn, resetDecoderBlockOwners_fn, discardFecDecoderClient_fn, assertExclusiveDecoderClient_fn, statsForPacket_fn, markPathBlockComplete_fn, clearRepairDeadline_fn, requestRepair_fn, traceLifecycle_fn, defaultTrackConfig_fn, resolveTrackConfig_fn, computeTimeout_fn, repairDeadlineMs_fn, repairGraceMs_fn, armBlockTimeout_fn, upsertTrackConfig_fn, normalizeSymbolData_fn, blockKeysFor_fn, observeBlockCatalogTrackName_fn, markStartupPartial_fn, routeSyncCleanup_fn, failBlock_fn;
+var _fecDecoders, _workerClients, _syncDecoderBlockOwners, _decoderBlockOwners, _fecK, _fecSymbolSize, _fecTimeoutMs, _trackConfigs, _fecStats, _fecTrackStats, _fecWorkerStats, _fecStatsObservers, _activeBlocks, _activeBlockDeadlinesMs, _activeBlockTimeoutOwners, _lifecycleTrace, _pendingWorkerCleanups, _pendingWorkerCleanupClients, _blockSourceCounts, _blockSourceEsis, _blockRepairRsIds, _completedBlocks, _seenSymbols, _blockPathCounts, _blockCatalogTrackNames, _startupAlignedPackets, _startupPartialBlocks, _startupRequireRepairReady, _startupRepairReadyPackets, _startupRepairBoundaryCounts, _startupRepairFailOpenPackets, _cleanlyCompletedBlocks, _repairRequestedBlocks, _repairDeadlines, _workerRecoveredBlocks, _fpsDetected, _fecFps, _fecInterleaveDepthMs, _workerErrorCounts, _decoderUnavailableEvents, _repairSymbolSizeMismatchCount, _FECManager_instances, streamKey_fn, belongsToPacket_fn, belongsToStream_fn, packetIdsForStreamKeys_fn, parseStreamKey_fn, blockKey_fn, parseBlockKey_fn, decoderForPacket_fn, workerForPacket_fn, routableWorkerForPacket_fn, claimDecoderBlock_fn, decoderBlockCatalogTrackName_fn, resetDecoderBlockOwners_fn, discardFecDecoderClient_fn, assertExclusiveDecoderClient_fn, statsForPacket_fn, markPathBlockComplete_fn, clearRepairDeadline_fn, requestRepair_fn, traceLifecycle_fn, defaultTrackConfig_fn, resolveTrackConfig_fn, computeTimeout_fn, repairDeadlineMs_fn, repairGraceMs_fn, armBlockTimeout_fn, upsertTrackConfig_fn, normalizeSymbolData_fn, blockKeysFor_fn, observeBlockCatalogTrackName_fn, markStartupPartial_fn, retireWorker_fn, releaseWorkerClient_fn, settleOwedCleanup_fn, evictDisposedWorker_fn, routeSyncCleanup_fn, failBlock_fn;
 var FECManager = class {
   constructor() {
     __privateAdd(this, _FECManager_instances);
@@ -9215,6 +9689,7 @@ var FECManager = class {
     // validation harness — which caps headless warnings at 500 — fails even
     // though the errors are duplicates of a single underlying event.
     __privateAdd(this, _workerErrorCounts, /* @__PURE__ */ new Map());
+    __privateAdd(this, _decoderUnavailableEvents, 0);
     __privateAdd(this, _repairSymbolSizeMismatchCount, 0);
     // Event callbacks — block lifecycle notifications for MmtpRouter wiring.
     // NOTE: For sync WASM path, recovery routing is handled by MmtpRouter from
@@ -9223,6 +9698,17 @@ var FECManager = class {
     this.onBlockStarted = null;
     this.onBlockComplete = null;
     this.onBlockFailed = null;
+    /**
+     * Fired once per stream when its Worker decoder stops being routable.
+     * `reason` is 'cleared' when clearFecWorker() removed it and 'disposed' when
+     * a symbol or reset found the registered client already disposed and
+     * evicted it. `fallbackDecoder` is 'sync' when a synchronous WASM decoder
+     * registered for the same stream keeps decoding its symbols, and 'none'
+     * when nothing does. Only 'none' leaves the stream unprotected: the host
+     * must then register a decoder again or leave the stream, because counting
+     * its symbols as handled would hide the loss.
+     */
+    this.onDecoderUnavailable = null;
     // D-28 on-demand repair callbacks. When onRepairNeeded is registered, each
     // block arms a one-shot repair deadline after the derived K-symbol source
     // horizon; a block still short of K when it fires requests a per-SBN MoQ
@@ -9256,6 +9742,7 @@ var FECManager = class {
       startupRepairReadyPackets: __privateMethod(this, _FECManager_instances, packetIdsForStreamKeys_fn).call(this, __privateGet(this, _startupRepairReadyPackets)),
       startupRepairFailOpenPackets: __privateMethod(this, _FECManager_instances, packetIdsForStreamKeys_fn).call(this, __privateGet(this, _startupRepairFailOpenPackets)),
       pendingWorkerCleanups: __privateGet(this, _pendingWorkerCleanups).size,
+      decoderUnavailableEvents: __privateGet(this, _decoderUnavailableEvents),
       repairTrackedBlocks: __privateGet(this, _blockRepairRsIds).size,
       lifecycleTrace: __privateGet(this, _lifecycleTrace).map((entry) => ({ ...entry }))
     };
@@ -9390,8 +9877,12 @@ var FECManager = class {
         __privateMethod(this, _FECManager_instances, discardFecDecoderClient_fn).call(this, client);
       }
     }
-    for (const [key, client] of __privateGet(this, _workerClients)) {
+    for (const [key, client] of [...__privateGet(this, _workerClients)]) {
       if (!__privateMethod(this, _FECManager_instances, belongsToStream_fn).call(this, key, packetId, catalogTrackName)) continue;
+      if (client.disposed === true) {
+        __privateMethod(this, _FECManager_instances, evictDisposedWorker_fn).call(this, client);
+        continue;
+      }
       client.reset();
       clients.add(client);
     }
@@ -9611,6 +10102,12 @@ var FECManager = class {
     }
     const streamKey = __privateMethod(this, _FECManager_instances, streamKey_fn).call(this, packetId, catalogTrackName);
     __privateMethod(this, _FECManager_instances, assertExclusiveDecoderClient_fn).call(this, streamKey, client, __privateGet(this, _workerClients), "worker");
+    const incumbent = __privateGet(this, _workerClients).get(streamKey);
+    if (incumbent !== void 0 && incumbent !== client) {
+      throw new Error(
+        `[FECManager] stream ${streamKey} already routes to a Worker; call clearFecWorker before registering another`
+      );
+    }
     if (config) __privateMethod(this, _FECManager_instances, upsertTrackConfig_fn).call(this, packetId, config);
     const workerK = __privateMethod(this, _FECManager_instances, resolveTrackConfig_fn).call(this, packetId).k;
     __privateGet(this, _workerClients).set(streamKey, client);
@@ -9697,14 +10194,7 @@ var FECManager = class {
         const block = __privateMethod(this, _FECManager_instances, parseBlockKey_fn).call(this, key);
         return block.packetId === packetId && block.sbn === sbn && __privateGet(this, _pendingWorkerCleanupClients).get(key) === client;
       });
-      for (const key of cleanupKeys) {
-        __privateGet(this, _pendingWorkerCleanups).delete(key);
-        __privateGet(this, _pendingWorkerCleanupClients).delete(key);
-        if (__privateGet(this, _completedBlocks).has(key)) continue;
-        const block = __privateMethod(this, _FECManager_instances, parseBlockKey_fn).call(this, key);
-        __privateMethod(this, _FECManager_instances, traceLifecycle_fn).call(this, "cleanup-ack", sbn, packetId, block.catalogTrackName);
-        __privateMethod(this, _FECManager_instances, failBlock_fn).call(this, sbn, packetId, false, block.catalogTrackName);
-      }
+      for (const key of cleanupKeys) __privateMethod(this, _FECManager_instances, settleOwedCleanup_fn).call(this, key, "cleanup-ack");
     });
     client.onError((msg, code) => {
       const requestedKind = code ?? msg;
@@ -9720,6 +10210,25 @@ var FECManager = class {
       }
     });
   }
+  /**
+   * Remove a stream's Worker decoder from routing.
+   *
+   * Returns false when no Worker is registered under that exact stream key.
+   * On success every cleanup acknowledgement still owed by the client is
+   * resolved by failing its block now (a Worker that is going away cannot
+   * post it), the client's block ownership is released, and
+   * onDecoderUnavailable fires once with reason 'cleared' and the decoder
+   * that remains for the stream ('sync' or 'none'). Call this before
+   * disposing the client; a client disposed while still registered is
+   * evicted on its next symbol or reset with reason 'disposed'.
+   */
+  clearFecWorker(packetId, catalogTrackName) {
+    const streamKey = __privateMethod(this, _FECManager_instances, streamKey_fn).call(this, packetId, catalogTrackName);
+    const client = __privateGet(this, _workerClients).get(streamKey);
+    if (!client) return false;
+    __privateMethod(this, _FECManager_instances, retireWorker_fn).call(this, streamKey, client, "cleared");
+    return true;
+  }
   /** Called by player when framerate is known (from decoder output). Refines FEC block timeout. */
   setFramerate(fps) {
     if (__privateGet(this, _fpsDetected) || fps <= 0) return;
@@ -9770,7 +10279,7 @@ var FECManager = class {
     const sbn = Math.floor(ssId / this.kForPacket(packetId));
     const blockKey = __privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, packetId, catalogTrackName);
     const syncBlockOwner = __privateGet(this, _syncDecoderBlockOwners).get(blockKey);
-    const workerClient = __privateMethod(this, _FECManager_instances, workerForPacket_fn).call(this, packetId, catalogTrackName);
+    const workerClient = __privateMethod(this, _FECManager_instances, routableWorkerForPacket_fn).call(this, packetId, catalogTrackName);
     if (workerClient && !syncBlockOwner) {
       if (!__privateMethod(this, _FECManager_instances, claimDecoderBlock_fn).call(this, workerClient, sbn, catalogTrackName)) return null;
       const buf = fecData.buffer.slice(
@@ -9847,7 +10356,7 @@ var FECManager = class {
     if (__privateGet(this, _repairRequestedBlocks).has(blockKey)) {
       __privateMethod(this, _FECManager_instances, traceLifecycle_fn).call(this, "repair-arrived", sbn, packetId, catalogTrackName, rsId);
     }
-    const workerClient = __privateMethod(this, _FECManager_instances, workerForPacket_fn).call(this, packetId, catalogTrackName);
+    const workerClient = __privateMethod(this, _FECManager_instances, routableWorkerForPacket_fn).call(this, packetId, catalogTrackName);
     if (workerClient && !syncBlockOwner) {
       if (!__privateMethod(this, _FECManager_instances, claimDecoderBlock_fn).call(this, workerClient, sbn, catalogTrackName)) return null;
       const buf = fecData.buffer.slice(
@@ -10132,6 +10641,7 @@ _fpsDetected = new WeakMap();
 _fecFps = new WeakMap();
 _fecInterleaveDepthMs = new WeakMap();
 _workerErrorCounts = new WeakMap();
+_decoderUnavailableEvents = new WeakMap();
 _repairSymbolSizeMismatchCount = new WeakMap();
 _FECManager_instances = new WeakSet();
 streamKey_fn = function(packetId, catalogTrackName) {
@@ -10151,6 +10661,14 @@ belongsToStream_fn = function(key, packetId, catalogTrackName) {
 packetIdsForStreamKeys_fn = function(keys) {
   return [...new Set([...keys].map((key) => Number(key.split(":", 1)[0])))];
 };
+parseStreamKey_fn = function(key) {
+  const separator = key.indexOf(":");
+  if (separator < 0) return { packetId: Number(key) || 0 };
+  return {
+    packetId: Number(key.slice(0, separator)) || 0,
+    catalogTrackName: decodeURIComponent(key.slice(separator + 1))
+  };
+};
 blockKey_fn = function(sbn, packetId, catalogTrackName) {
   const base = `${packetId}:${sbn}`;
   return catalogTrackName === void 0 ? base : `${base}:${encodeURIComponent(catalogTrackName)}`;
@@ -10170,6 +10688,18 @@ decoderForPacket_fn = function(packetId, catalogTrackName) {
 workerForPacket_fn = function(packetId, catalogTrackName) {
   return __privateGet(this, _workerClients).get(__privateMethod(this, _FECManager_instances, streamKey_fn).call(this, packetId, catalogTrackName)) ?? __privateGet(this, _workerClients).get(__privateMethod(this, _FECManager_instances, streamKey_fn).call(this, packetId));
 };
+/**
+ * The stream's Worker client for routing, or undefined after evicting a
+ * registered client that was already disposed. A disposed client throws on
+ * every command, so it leaves routing here before a symbol reaches it and
+ * the stream reports its decoder unavailable instead.
+ */
+routableWorkerForPacket_fn = function(packetId, catalogTrackName) {
+  const client = __privateMethod(this, _FECManager_instances, workerForPacket_fn).call(this, packetId, catalogTrackName);
+  if (client === void 0 || client.disposed !== true) return client;
+  __privateMethod(this, _FECManager_instances, evictDisposedWorker_fn).call(this, client);
+  return void 0;
+};
 claimDecoderBlock_fn = function(client, sbn, catalogTrackName) {
   let blocks = __privateGet(this, _decoderBlockOwners).get(client);
   if (!blocks) {
@@ -10337,7 +10867,7 @@ armBlockTimeout_fn = function(sbn, packetId, catalogTrackName, delayMs) {
       __privateMethod(this, _FECManager_instances, failBlock_fn).call(this, sbn, packetId, false, catalogTrackName);
       return;
     }
-    const workerClient = __privateMethod(this, _FECManager_instances, workerForPacket_fn).call(this, packetId, catalogTrackName);
+    const workerClient = __privateMethod(this, _FECManager_instances, routableWorkerForPacket_fn).call(this, packetId, catalogTrackName);
     if (workerClient) {
       __privateGet(this, _pendingWorkerCleanups).add(key);
       __privateGet(this, _pendingWorkerCleanupClients).set(key, workerClient);
@@ -10420,6 +10950,59 @@ markStartupPartial_fn = function(blockKey) {
     ));
   }
 };
+/**
+ * Take a Worker client out of routing under one stream key, fail the blocks
+ * whose completion it still owed, and report the stream's decoder
+ * unavailable together with whatever still decodes the stream.
+ */
+retireWorker_fn = function(streamKey, client, reason) {
+  __privateGet(this, _workerClients).delete(streamKey);
+  __privateMethod(this, _FECManager_instances, releaseWorkerClient_fn).call(this, client);
+  __privateWrapper(this, _decoderUnavailableEvents)._++;
+  const stream = __privateMethod(this, _FECManager_instances, parseStreamKey_fn).call(this, streamKey);
+  const fallbackDecoder = __privateMethod(this, _FECManager_instances, decoderForPacket_fn).call(this, stream.packetId, stream.catalogTrackName) ? "sync" : "none";
+  this.onDecoderUnavailable?.({
+    packetId: stream.packetId,
+    ...stream.catalogTrackName === void 0 ? {} : { catalogTrackName: stream.catalogTrackName },
+    reason,
+    fallbackDecoder
+  });
+};
+/**
+ * Fail every block whose Worker cleanup acknowledgement is owed by `client`
+ * and drop its block ownership, so no block waits on a message the Worker
+ * will never post.
+ */
+releaseWorkerClient_fn = function(client) {
+  const owed = [...__privateGet(this, _pendingWorkerCleanupClients)].filter(([, owner]) => owner === client).map(([key]) => key);
+  for (const key of owed) __privateMethod(this, _FECManager_instances, settleOwedCleanup_fn).call(this, key, "decoder-unavailable");
+  __privateGet(this, _decoderBlockOwners).delete(client);
+};
+/**
+ * Resolve one owed Worker cleanup: drop the pending entry and fail the block
+ * unless it already completed. Shared by the cleanup acknowledgement and by
+ * Worker retirement, so the two paths cannot drift in their bookkeeping.
+ */
+settleOwedCleanup_fn = function(key, event) {
+  __privateGet(this, _pendingWorkerCleanups).delete(key);
+  __privateGet(this, _pendingWorkerCleanupClients).delete(key);
+  if (__privateGet(this, _completedBlocks).has(key)) return;
+  const block = __privateMethod(this, _FECManager_instances, parseBlockKey_fn).call(this, key);
+  __privateMethod(this, _FECManager_instances, traceLifecycle_fn).call(this, event, block.sbn, block.packetId, block.catalogTrackName);
+  __privateMethod(this, _FECManager_instances, failBlock_fn).call(this, block.sbn, block.packetId, false, block.catalogTrackName);
+};
+/** Evict a disposed client under every stream key that still maps to it. */
+evictDisposedWorker_fn = function(client) {
+  for (const [key, registered] of [...__privateGet(this, _workerClients)]) {
+    if (registered !== client) continue;
+    const stream = __privateMethod(this, _FECManager_instances, parseStreamKey_fn).call(this, key);
+    const track = stream.catalogTrackName === void 0 ? "" : ` track=${stream.catalogTrackName}`;
+    console.warn(
+      `[FECManager] packetId=${stream.packetId}${track} Worker decoder was disposed while still registered; evicting it`
+    );
+    __privateMethod(this, _FECManager_instances, retireWorker_fn).call(this, key, client, "disposed");
+  }
+};
 routeSyncCleanup_fn = function(decoder, sbn, packetId) {
   let framed;
   try {
@@ -12038,7 +12621,7 @@ buildFrameMeta_fn = function(assembled, packetId, seq, timing, recovered = false
   }
   return meta;
 };
-sequencerFor_fn = function(packetId, _trackType, catalogTrackName) {
+sequencerFor_fn = function(packetId, _trackType2, catalogTrackName) {
   const windowSize = __privateGet(this, _reassemblyPolicy) ? mmtpFrameReorderWindowFrames(__privateGet(this, _reassemblyPolicy), __privateGet(this, _reorderWindow)) : __privateGet(this, _reorderWindow);
   if (windowSize <= 0) return null;
   const streamKey = __privateMethod(this, _MmtpContainerParser_instances, streamKey_fn2).call(this, packetId, catalogTrackName);
@@ -14332,52 +14915,1373 @@ var ReedSolomonCodec = class {
   }
 };
 
-// src/multicast-transport.ts
-var MAX_TRACKED_DROPPED_PIDS = 16;
-function getMulticastGlobals() {
-  return globalThis;
-}
-function hasMulticastGateway() {
-  return typeof getMulticastGlobals().multicast?.subscribe === "function";
-}
-function normalizeResolvedTransport(value) {
-  if (value === "native") return "native";
-  if (value === "amt") return "amt";
-  return void 0;
-}
-var _onPacket, _subscription2, _bytesListener, _transportListener, _resolvedTransport, _videoConfirmed, _audioConfirmed, _watchdog, _failbackWindowMs, _onTakeover, _onFailback, _disposed4, _stats3, _droppedPidCounts, _packetIds, _joinGeneration, _MulticastTransport_instances, releaseSubscription_fn, acceptPacket_fn, recordUnregisteredPidDrop_fn, checkTakeover_fn, resetWatchdog_fn;
-var _MulticastTransport = class _MulticastTransport {
-  constructor(onPacket) {
-    __privateAdd(this, _MulticastTransport_instances);
-    __privateAdd(this, _onPacket);
-    __privateAdd(this, _subscription2, null);
-    __privateAdd(this, _bytesListener, null);
-    __privateAdd(this, _transportListener, null);
-    __privateAdd(this, _resolvedTransport);
-    __privateAdd(this, _videoConfirmed, false);
-    __privateAdd(this, _audioConfirmed, false);
-    __privateAdd(this, _watchdog, null);
-    __privateAdd(this, _failbackWindowMs, null);
-    __privateAdd(this, _onTakeover, null);
-    __privateAdd(this, _onFailback, null);
-    __privateAdd(this, _disposed4, false);
-    __privateAdd(this, _stats3, {
-      packetsReceived: 0,
-      bytesReceived: 0,
-      packetsDroppedUnregisteredPid: 0,
-      packetsDroppedUnparseable: 0
-    });
-    __privateAdd(this, _droppedPidCounts, /* @__PURE__ */ new Map());
-    __privateAdd(this, _packetIds, null);
-    __privateAdd(this, _joinGeneration, 0);
-    __privateSet(this, _onPacket, onPacket);
-  }
-  static isAvailable() {
-    return hasMulticastGateway();
+// node_modules/@blockcast/mmt-transport/dist/types.js
+var MoqFecAlgorithm;
+(function(MoqFecAlgorithm2) {
+  MoqFecAlgorithm2[MoqFecAlgorithm2["None"] = 0] = "None";
+  MoqFecAlgorithm2[MoqFecAlgorithm2["Xor"] = 1] = "Xor";
+  MoqFecAlgorithm2[MoqFecAlgorithm2["RaptorQ"] = 2] = "RaptorQ";
+})(MoqFecAlgorithm || (MoqFecAlgorithm = {}));
+
+// node_modules/@blockcast/mmt-transport/dist/driad-discovery.js
+var DRIADDiscovery = class {
+  constructor() {
+    __publicField(this, "cache", /* @__PURE__ */ new Map());
+    __publicField(this, "cacheExpiry", 3e5);
   }
-  async join(config, context) {
-    const generation = ++__privateWrapper(this, _joinGeneration)._;
-    __privateMethod(this, _MulticastTransport_instances, releaseSubscription_fn).call(this);
+  // 5 minutes
+  /**
+   * Discover AMT relays for a multicast source address (RFC 8777)
+   *
+   * @param source - The multicast source IP address (NOT the group!)
+   * @returns Array of discovered AMT relays that can tunnel traffic from this source
+   */
+  async discoverRelays(source) {
+    const cached = this.cache.get(source);
+    if (cached) {
+      return cached;
+    }
+    try {
+      const reversedSource = source.split(".").reverse().join(".");
+      const queryDomain = `${reversedSource}.amt.in-addr.arpa`;
+      console.log(`[DRIAD] Discovering relays for source ${source} via ${queryDomain}`);
+      const relays = await this.queryDRIADProxy(source);
+      if (relays.length > 0) {
+        this.cache.set(source, relays);
+        setTimeout(() => this.cache.delete(source), this.cacheExpiry);
+      }
+      return relays;
+    } catch (error) {
+      console.warn(`[DRIAD] Discovery failed for source ${source}:`, error);
+      return [];
+    }
+  }
+  /**
+   * Query DRIAD proxy service (browser-compatible)
+   */
+  async queryDRIADProxy(source) {
+    const proxyEndpoints = [
+      "https://driad.amt.net/api/v1/relays",
+      "https://multicast-gateway.cloudflare.com/driad"
+    ];
+    for (const endpoint of proxyEndpoints) {
+      try {
+        const response = await fetch(`${endpoint}?source=${encodeURIComponent(source)}`, {
+          method: "GET",
+          headers: { Accept: "application/json" },
+          signal: AbortSignal.timeout(5e3)
+        });
+        if (response.ok) {
+          const data = await response.json();
+          return data.relays || [];
+        }
+      } catch {
+      }
+    }
+    const dohRelay = await this.queryDNSOverHTTPS(source);
+    if (dohRelay) {
+      return [dohRelay];
+    }
+    return [];
+  }
+  /**
+   * Query DNS-over-HTTPS for DRIAD relay based on source address (RFC 8777)
+   */
+  async queryDNSOverHTTPS(source) {
+    try {
+      const reversedSource = source.split(".").reverse().join(".");
+      const queryName = `${reversedSource}.amt.in-addr.arpa`;
+      const dohUrl = `https://cloudflare-dns.com/dns-query?name=${queryName}&type=A`;
+      const response = await fetch(dohUrl, {
+        headers: { Accept: "application/dns-json" },
+        signal: AbortSignal.timeout(3e3)
+      });
+      if (!response.ok) {
+        return null;
+      }
+      const result = await response.json();
+      if (result.Answer && result.Answer.length > 0) {
+        return {
+          host: result.Answer[0].data,
+          port: 2268,
+          priority: 10,
+          weight: 100,
+          asn: 0
+        };
+      }
+      return null;
+    } catch (error) {
+      console.warn("[DRIAD] DNS-over-HTTPS query failed:", error);
+      return null;
+    }
+  }
+  /**
+   * Select best relay based on RTT measurements
+   */
+  async selectBestRelay(relays) {
+    if (relays.length === 0)
+      return null;
+    const measured = await Promise.all(relays.map(async (relay) => {
+      const rtt = await this.measureRTT(relay.host, relay.port);
+      return { ...relay, rtt };
+    }));
+    measured.sort((a, b) => {
+      if (a.priority !== b.priority)
+        return a.priority - b.priority;
+      return (a.rtt || Infinity) - (b.rtt || Infinity);
+    });
+    console.log(`[DRIAD] Selected relay: ${measured[0].host} (RTT: ${measured[0].rtt}ms)`);
+    return measured[0];
+  }
+  async measureRTT(host, _port) {
+    const start = performance.now();
+    try {
+      await fetch(`https://${host}/health`, {
+        method: "HEAD",
+        signal: AbortSignal.timeout(2e3),
+        mode: "no-cors"
+      });
+      return performance.now() - start;
+    } catch {
+      return Infinity;
+    }
+  }
+  /**
+   * Clear the relay cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Get cached relays for a source address
+   */
+  getCached(source) {
+    return this.cache.get(source);
+  }
+};
+var driadDiscovery = new DRIADDiscovery();
+
+// node_modules/@blockcast/mmt-transport/dist/multicast-tier.js
+function endpointKey(endpoint) {
+  return `${endpoint.sourceAddress ?? ""}|${endpoint.groupAddress}|${endpoint.port}`;
+}
+function selectMulticastTier(endpoints, estimate) {
+  if (endpoints.length <= 1)
+    return endpoints[0];
+  const ranked = endpoints.filter((endpoint) => typeof endpoint.bandwidth === "number" && endpoint.bandwidth > 0).sort((a, b) => a.bandwidth - b.bandwidth);
+  if (ranked.length < 2)
+    return endpoints[0];
+  if (estimate === void 0)
+    return ranked[0];
+  const budget = estimate * 0.8;
+  let selected;
+  for (const endpoint of ranked) {
+    if (endpoint.bandwidth <= budget)
+      selected = endpoint;
+  }
+  return selected ?? ranked[0];
+}
+
+// node_modules/@blockcast/mmt-transport/dist/abr-controller.js
+var QUALITY_LEVELS = [
+  { name: "240p", bitrate: 3e5, width: 426, height: 240, fps: 15 },
+  { name: "360p", bitrate: 5e5, width: 640, height: 360, fps: 24 },
+  { name: "480p", bitrate: 1e6, width: 854, height: 480, fps: 30 },
+  { name: "720p", bitrate: 25e5, width: 1280, height: 720, fps: 30 },
+  { name: "1080p", bitrate: 5e6, width: 1920, height: 1080, fps: 30 },
+  { name: "1440p", bitrate: 8e6, width: 2560, height: 1440, fps: 30 },
+  { name: "4K", bitrate: 15e6, width: 3840, height: 2160, fps: 30 }
+];
+var AdaptiveBitrateController = class {
+  constructor(initialQuality) {
+    __publicField(this, "currentQualityIndex");
+    __publicField(this, "history", []);
+    __publicField(this, "historyWindow", 1e4);
+    // 10 second window
+    __publicField(this, "upgradeThreshold", 0.8);
+    // 80% of target bitrate sustained
+    __publicField(this, "downgradeThreshold", 0.5);
+    // 50% of target bitrate triggers downgrade
+    __publicField(this, "stabilityPeriod", 5e3);
+    // Wait 5s before upgrading
+    __publicField(this, "lastQualityChange", 0);
+    __publicField(this, "onQualityChange");
+    // FEC stats for effective loss rate calculation
+    __publicField(this, "fecStats", {
+      rawLossRate: 0,
+      effectiveLossRate: 0,
+      recoveryRate: 1,
+      fecEnabled: false
+    });
+    this.currentQualityIndex = initialQuality ? QUALITY_LEVELS.findIndex((q) => q.name === initialQuality.name) : 0;
+    if (this.currentQualityIndex < 0)
+      this.currentQualityIndex = 0;
+  }
+  setCallback(callback) {
+    this.onQualityChange = callback;
+  }
+  getCurrentQuality() {
+    return QUALITY_LEVELS[this.currentQualityIndex];
+  }
+  /** Selects the multicast (S,G) tier without replacing a player's unicast ABR manager. */
+  selectMulticastTier(endpoints, estimate = this.getMetrics().measuredBitrate || void 0) {
+    return selectMulticastTier(endpoints, estimate);
+  }
+  /**
+   * Record network sample for bitrate adaptation
+   *
+   * @param bytesReceived - Bytes received in this sample
+   * @param packetsLost - Packets lost (raw, before FEC recovery)
+   */
+  recordSample(bytesReceived, packetsLost) {
+    const now = Date.now();
+    this.history.push({ timestamp: now, bytesReceived, packetsLost });
+    this.history = this.history.filter((s) => now - s.timestamp < this.historyWindow);
+    const { measuredBitrate, lossRate: rawLossRate } = this.calculateMetrics();
+    const currentQuality = this.getCurrentQuality();
+    const effectiveLossRate = this.fecStats.fecEnabled ? this.fecStats.effectiveLossRate : rawLossRate;
+    if (now - this.lastQualityChange < this.stabilityPeriod) {
+      return;
+    }
+    if (effectiveLossRate > 0.05 || measuredBitrate < currentQuality.bitrate * this.downgradeThreshold) {
+      this.downgrade();
+      return;
+    }
+    if (measuredBitrate > currentQuality.bitrate * this.upgradeThreshold && effectiveLossRate < 0.01 && this.currentQualityIndex < QUALITY_LEVELS.length - 1) {
+      this.upgrade();
+    }
+  }
+  /**
+   * Update FEC statistics for ABR decisions
+   *
+   * Per draft-ramadan-moq-fec-00, ABR should use the effective loss rate
+   * (after FEC recovery) rather than raw transport loss rate.
+   *
+   * @param stats - FEC statistics from the FEC decoder
+   */
+  setFecStats(stats) {
+    this.fecStats = stats;
+  }
+  /**
+   * Get current FEC statistics
+   */
+  getFecStats() {
+    return { ...this.fecStats };
+  }
+  calculateMetrics() {
+    if (this.history.length < 2) {
+      return { measuredBitrate: 0, lossRate: 0 };
+    }
+    const totalBytes = this.history.reduce((sum, s) => sum + s.bytesReceived, 0);
+    const totalLost = this.history.reduce((sum, s) => sum + s.packetsLost, 0);
+    const duration = (this.history[this.history.length - 1].timestamp - this.history[0].timestamp) / 1e3;
+    const measuredBitrate = duration > 0 ? totalBytes * 8 / duration : 0;
+    const lossRate = totalLost / (this.history.length + totalLost);
+    return { measuredBitrate, lossRate };
+  }
+  upgrade() {
+    if (this.currentQualityIndex >= QUALITY_LEVELS.length - 1)
+      return;
+    this.currentQualityIndex++;
+    this.lastQualityChange = Date.now();
+    const newQuality = this.getCurrentQuality();
+    console.log(`[ABR] Upgrading to ${newQuality.name} (${newQuality.bitrate / 1e6}Mbps)`);
+    this.onQualityChange?.(newQuality);
+  }
+  downgrade() {
+    if (this.currentQualityIndex <= 0)
+      return;
+    this.currentQualityIndex--;
+    this.lastQualityChange = Date.now();
+    const newQuality = this.getCurrentQuality();
+    console.log(`[ABR] Downgrading to ${newQuality.name} (${newQuality.bitrate / 1e6}Mbps)`);
+    this.onQualityChange?.(newQuality);
+  }
+  /**
+   * Force quality level (for testing)
+   */
+  setQuality(name) {
+    const index = QUALITY_LEVELS.findIndex((q) => q.name === name);
+    if (index >= 0) {
+      this.currentQualityIndex = index;
+      this.lastQualityChange = Date.now();
+      this.onQualityChange?.(this.getCurrentQuality());
+    }
+  }
+  /**
+   * Get current metrics including both raw and effective loss rates
+   */
+  getMetrics() {
+    const { measuredBitrate, lossRate: rawLossRate } = this.calculateMetrics();
+    return {
+      measuredBitrate,
+      rawLossRate,
+      effectiveLossRate: this.fecStats.fecEnabled ? this.fecStats.effectiveLossRate : rawLossRate,
+      fecEnabled: this.fecStats.fecEnabled,
+      sampleCount: this.history.length
+    };
+  }
+  /**
+   * Reset history and start fresh
+   */
+  reset() {
+    this.history = [];
+    this.lastQualityChange = 0;
+  }
+};
+
+// node_modules/@blockcast/mmt-transport/dist/multicast-orchestrator.js
+var DEFAULT_DWELL_MS = 3e3;
+var DEFAULT_JOIN_DEADLINE_MS = 5e3;
+var _state2, _current, _target, _estimate, _favored, _joinStartedAt, _lastCommittedTimestamp, _dwellMs, _joinDeadlineMs, _MulticastOrchestrator_instances, now_fn;
+var MulticastOrchestrator = class {
+  constructor(options) {
+    __privateAdd(this, _MulticastOrchestrator_instances);
+    __publicField(this, "options");
+    __privateAdd(this, _state2, "stable");
+    __privateAdd(this, _current);
+    __privateAdd(this, _target);
+    __privateAdd(this, _estimate);
+    __privateAdd(this, _favored);
+    __privateAdd(this, _joinStartedAt, 0);
+    __privateAdd(this, _lastCommittedTimestamp, Number.NEGATIVE_INFINITY);
+    __privateAdd(this, _dwellMs);
+    __privateAdd(this, _joinDeadlineMs);
+    this.options = options;
+    __privateSet(this, _dwellMs, options.dwellMs ?? DEFAULT_DWELL_MS);
+    __privateSet(this, _joinDeadlineMs, options.joinDeadlineMs ?? DEFAULT_JOIN_DEADLINE_MS);
+    if (!Number.isFinite(__privateGet(this, _dwellMs)) || !Number.isFinite(__privateGet(this, _joinDeadlineMs)) || __privateGet(this, _dwellMs) <= 0 || __privateGet(this, _joinDeadlineMs) <= 0) {
+      throw new Error("Multicast dwell and join deadline must be positive");
+    }
+  }
+  get state() {
+    return __privateGet(this, _state2);
+  }
+  get current() {
+    return __privateGet(this, _current);
+  }
+  get target() {
+    return __privateGet(this, _target);
+  }
+  get estimate() {
+    return __privateGet(this, _estimate);
+  }
+  start() {
+    __privateGet(this, _current) ?? __privateSet(this, _current, this.options.initialEndpoint ?? selectMulticastTier(this.options.endpoints, void 0));
+    return __privateGet(this, _current);
+  }
+  onGoodput(sample) {
+    const bitrate = sample.bitrate;
+    if (!__privateGet(this, _current) || this.options.adaptive === false)
+      return void 0;
+    if (__privateGet(this, _state2) === "joining")
+      return this.poll();
+    if (bitrate === void 0 || !Number.isFinite(bitrate))
+      return void 0;
+    __privateSet(this, _estimate, bitrate);
+    const desired = selectMulticastTier(this.options.endpoints, bitrate);
+    if (!desired)
+      return void 0;
+    const desiredKey = endpointKey(desired);
+    if (desiredKey === endpointKey(__privateGet(this, _current))) {
+      if (__privateGet(this, _favored)?.source === "goodput")
+        __privateSet(this, _favored, void 0);
+      return void 0;
+    }
+    if (typeof desired.bandwidth !== "number" || typeof __privateGet(this, _current).bandwidth !== "number" || desired.bandwidth >= __privateGet(this, _current).bandwidth) {
+      if (__privateGet(this, _favored)?.source === "goodput")
+        __privateSet(this, _favored, void 0);
+      return void 0;
+    }
+    const now = __privateMethod(this, _MulticastOrchestrator_instances, now_fn).call(this);
+    if (!__privateGet(this, _favored) || __privateGet(this, _favored).key !== desiredKey || __privateGet(this, _favored).source !== "goodput") {
+      __privateSet(this, _favored, { key: desiredKey, since: now, source: "goodput" });
+      return void 0;
+    }
+    if (now - __privateGet(this, _favored).since < __privateGet(this, _dwellMs))
+      return void 0;
+    __privateSet(this, _state2, "joining");
+    __privateSet(this, _target, desired);
+    __privateSet(this, _joinStartedAt, now);
+    __privateSet(this, _favored, void 0);
+    return { kind: "join-target", current: __privateGet(this, _current), target: desired };
+  }
+  onHeadroom(sample) {
+    if (!__privateGet(this, _current) || this.options.adaptive === false || __privateGet(this, _state2) === "joining")
+      return void 0;
+    if (!sample.healthy) {
+      if (__privateGet(this, _favored)?.source === "headroom")
+        __privateSet(this, _favored, void 0);
+      return void 0;
+    }
+    if (__privateGet(this, _favored)?.source === "goodput")
+      return void 0;
+    const currentBandwidth = __privateGet(this, _current).bandwidth;
+    if (typeof currentBandwidth !== "number")
+      return void 0;
+    const desired = this.options.endpoints.filter((endpoint) => typeof endpoint.bandwidth === "number" && endpoint.bandwidth > currentBandwidth).sort((a, b) => a.bandwidth - b.bandwidth)[0];
+    if (!desired) {
+      __privateSet(this, _favored, void 0);
+      return void 0;
+    }
+    const desiredKey = endpointKey(desired);
+    if (desiredKey === endpointKey(__privateGet(this, _current))) {
+      __privateSet(this, _favored, void 0);
+      return void 0;
+    }
+    const now = __privateMethod(this, _MulticastOrchestrator_instances, now_fn).call(this);
+    if (!__privateGet(this, _favored) || __privateGet(this, _favored).key !== desiredKey) {
+      __privateSet(this, _favored, { key: desiredKey, since: now, source: "headroom" });
+      return void 0;
+    }
+    if (now - __privateGet(this, _favored).since < __privateGet(this, _dwellMs))
+      return void 0;
+    __privateSet(this, _state2, "joining");
+    __privateSet(this, _target, desired);
+    __privateSet(this, _joinStartedAt, now);
+    __privateSet(this, _favored, void 0);
+    return { kind: "join-target", current: __privateGet(this, _current), target: desired };
+  }
+  onTierPacket(packet) {
+    if (!__privateGet(this, _current))
+      return void 0;
+    if (packet.endpointKey === endpointKey(__privateGet(this, _current)) && Number.isFinite(packet.timestamp)) {
+      __privateSet(this, _lastCommittedTimestamp, Math.max(__privateGet(this, _lastCommittedTimestamp), packet.timestamp));
+    }
+    if (__privateGet(this, _state2) !== "joining" || !__privateGet(this, _target))
+      return void 0;
+    const expired = this.poll();
+    if (expired)
+      return expired;
+    if (packet.endpointKey !== endpointKey(__privateGet(this, _target)) || !packet.keyframe || !packet.hasValidCodecConfig || !Number.isFinite(packet.timestamp) || packet.timestamp < __privateGet(this, _lastCommittedTimestamp))
+      return void 0;
+    const command = {
+      kind: "commit-swap",
+      target: __privateGet(this, _target),
+      old: __privateGet(this, _current)
+    };
+    __privateSet(this, _lastCommittedTimestamp, packet.timestamp);
+    __privateSet(this, _current, __privateGet(this, _target));
+    __privateSet(this, _target, void 0);
+    __privateSet(this, _state2, "stable");
+    return command;
+  }
+  poll() {
+    if (__privateGet(this, _state2) !== "joining" || !__privateGet(this, _target) || !__privateGet(this, _current))
+      return void 0;
+    if (__privateMethod(this, _MulticastOrchestrator_instances, now_fn).call(this) - __privateGet(this, _joinStartedAt) < __privateGet(this, _joinDeadlineMs))
+      return void 0;
+    return this.cancel();
+  }
+  cancel() {
+    if (__privateGet(this, _state2) !== "joining" || !__privateGet(this, _target) || !__privateGet(this, _current))
+      return void 0;
+    const command = {
+      kind: "abandon-join",
+      current: __privateGet(this, _current),
+      target: __privateGet(this, _target)
+    };
+    __privateSet(this, _target, void 0);
+    __privateSet(this, _state2, "stable");
+    return command;
+  }
+};
+_state2 = new WeakMap();
+_current = new WeakMap();
+_target = new WeakMap();
+_estimate = new WeakMap();
+_favored = new WeakMap();
+_joinStartedAt = new WeakMap();
+_lastCommittedTimestamp = new WeakMap();
+_dwellMs = new WeakMap();
+_joinDeadlineMs = new WeakMap();
+_MulticastOrchestrator_instances = new WeakSet();
+now_fn = function() {
+  const now = this.options.now();
+  if (!Number.isFinite(now))
+    throw new Error("Multicast orchestrator clock must be finite");
+  return now;
+};
+
+// node_modules/@blockcast/mmt-transport/dist/endpoint-config.js
+function toWindowMulticastSubscribeConfig(input) {
+  if (input.mode !== void 0 && !["auto", "native", "tunnel"].includes(input.mode)) {
+    throw new TypeError(`Unsupported multicast mode: ${String(input.mode)}`);
+  }
+  const base = {
+    group: input.group,
+    port: input.port,
+    ...input.source?.trim() ? { source: input.source.trim() } : {},
+    consume: "bytes",
+    ...input.packetIds?.length ? { packetIds: [...input.packetIds] } : {}
+  };
+  const relay = input.amtRelay?.trim();
+  const wantsAmt = input.mode === "tunnel" || input.mode !== "native" && relay !== void 0 && relay !== "";
+  if (!wantsAmt) {
+    const native = {
+      ...base,
+      origin: "ip-multicast",
+      ...input.tracks?.length ? { tracks: input.tracks.map(({ name, packetId }) => ({ name, packetId })) } : {}
+    };
+    return native;
+  }
+  const relayPort = input.amtRelayPort;
+  if (!relay || relayPort === void 0 || !isPositivePort(relayPort)) {
+    throw new TypeError("AMT requires a resolved relay and a valid relay port");
+  }
+  return {
+    ...base,
+    origin: "amt",
+    relay,
+    relayPort
+  };
+}
+function isValidMulticastGroupAddress(address) {
+  const value = address?.trim().toLowerCase();
+  if (!value)
+    return false;
+  if (value.startsWith("ff"))
+    return isValidIpv6MulticastAddress(value);
+  const parts = value.split(".");
+  if (parts.length !== 4)
+    return false;
+  const octets = parts.map((part) => {
+    if (!/^\d+$/.test(part))
+      return Number.NaN;
+    const octet = Number(part);
+    return Number.isInteger(octet) && octet >= 0 && octet <= 255 ? octet : Number.NaN;
+  });
+  return octets.every(Number.isInteger) && octets[0] >= 224 && octets[0] <= 239;
+}
+function normalizeMulticastEndpoint(endpoint) {
+  const groupAddress = endpoint.groupAddress.trim().toLowerCase();
+  const sourceAddress = endpoint.sourceAddress?.trim().toLowerCase() || void 0;
+  const amtRelay = endpoint.amtRelay?.trim().toLowerCase() || void 0;
+  if (!isValidMulticastGroupAddress(groupAddress) || !isPositivePort(endpoint.port))
+    return void 0;
+  if (endpoint.mode && !["auto", "native", "tunnel"].includes(endpoint.mode))
+    return void 0;
+  if (endpoint.amtRelayPort !== void 0 && !isPositivePort(endpoint.amtRelayPort))
+    return void 0;
+  return {
+    groupAddress,
+    ...sourceAddress ? { sourceAddress } : {},
+    port: endpoint.port,
+    ...endpoint.mode ? { mode: endpoint.mode } : {},
+    ...amtRelay ? { amtRelay } : {},
+    ...endpoint.amtRelayPort ? { amtRelayPort: endpoint.amtRelayPort } : {}
+  };
+}
+function multicastEndpointKey(endpoint) {
+  const normalized = normalizeMulticastEndpoint(endpoint);
+  if (!normalized)
+    throw new Error("Invalid multicast endpoint");
+  return JSON.stringify([
+    normalized.sourceAddress ?? "",
+    normalized.groupAddress,
+    normalized.port,
+    normalized.mode ?? "auto",
+    normalized.amtRelay ?? "",
+    normalized.amtRelayPort ?? ""
+  ]);
+}
+function isValidIpv6MulticastAddress(value) {
+  if (!/^[0-9a-f:]+$/.test(value))
+    return false;
+  const compressed = value.includes("::");
+  if (value.indexOf("::") !== value.lastIndexOf("::"))
+    return false;
+  const groups = value.split(":").filter(Boolean);
+  if (groups.length === 0 || groups.length > 8)
+    return false;
+  if (!compressed && groups.length !== 8)
+    return false;
+  return groups.every((group) => /^[0-9a-f]{1,4}$/.test(group));
+}
+function isPositivePort(port) {
+  return Number.isInteger(port) && port > 0 && port <= 65535;
+}
+
+// node_modules/@blockcast/mmt-transport/dist/multicast-subscription-pool.js
+var _entries, _gatewayIds, _nextGatewayId, _MulticastSubscriptionPool_instances, createEntry_fn, gatewayId_fn, detach_fn, dispatch_fn;
+var MulticastSubscriptionPool = class {
+  constructor() {
+    __privateAdd(this, _MulticastSubscriptionPool_instances);
+    __privateAdd(this, _entries, /* @__PURE__ */ new Map());
+    __privateAdd(this, _gatewayIds, /* @__PURE__ */ new WeakMap());
+    __privateAdd(this, _nextGatewayId, 1);
+  }
+  async acquire(gateway, config, consumer) {
+    const endpoint = normalizeMulticastEndpoint({
+      groupAddress: config.group,
+      sourceAddress: config.source,
+      port: config.port,
+      mode: config.mode,
+      amtRelay: config.amtRelay,
+      amtRelayPort: config.amtRelayPort
+    });
+    if (!endpoint)
+      throw new Error("Invalid multicast endpoint");
+    if (typeof gateway.subscribe !== "function")
+      throw new Error("window.multicast.subscribe unavailable");
+    const key = multicastEndpointKey(endpoint);
+    const internalKey = `${__privateMethod(this, _MulticastSubscriptionPool_instances, gatewayId_fn).call(this, gateway)}|${key}`;
+    let record = __privateGet(this, _entries).get(internalKey);
+    if (!record) {
+      record = { claims: 0, entry: Promise.resolve(null) };
+      const createdRecord = record;
+      record.entry = __privateMethod(this, _MulticastSubscriptionPool_instances, createEntry_fn).call(this, gateway, endpoint, (entry2) => {
+        if (__privateGet(this, _entries).get(internalKey) === createdRecord)
+          __privateGet(this, _entries).delete(internalKey);
+        __privateMethod(this, _MulticastSubscriptionPool_instances, detach_fn).call(this, entry2);
+      }).catch((error) => {
+        if (__privateGet(this, _entries).get(internalKey) === createdRecord)
+          __privateGet(this, _entries).delete(internalKey);
+        throw error;
+      });
+      __privateGet(this, _entries).set(internalKey, record);
+    }
+    record.claims++;
+    let entry;
+    try {
+      entry = await record.entry;
+    } catch (error) {
+      record.claims--;
+      throw error;
+    }
+    if (entry.closed) {
+      record.claims--;
+      return this.acquire(gateway, config, consumer);
+    }
+    const token = Symbol(key);
+    entry.consumers.set(token, consumer);
+    let released = false;
+    return {
+      key,
+      release: async () => {
+        if (released)
+          return;
+        released = true;
+        entry.consumers.delete(token);
+        record.claims--;
+        if (record.claims > 0)
+          return;
+        if (__privateGet(this, _entries).get(internalKey) === record)
+          __privateGet(this, _entries).delete(internalKey);
+        __privateMethod(this, _MulticastSubscriptionPool_instances, detach_fn).call(this, entry);
+        if (!entry.closed)
+          await entry.subscription.unsubscribe();
+      }
+    };
+  }
+  get size() {
+    return __privateGet(this, _entries).size;
+  }
+};
+_entries = new WeakMap();
+_gatewayIds = new WeakMap();
+_nextGatewayId = new WeakMap();
+_MulticastSubscriptionPool_instances = new WeakSet();
+createEntry_fn = async function(gateway, endpoint, onClosed) {
+  const subscription = await gateway.subscribe(toWindowMulticastSubscribeConfig({
+    group: endpoint.groupAddress,
+    ...endpoint.sourceAddress ? { source: endpoint.sourceAddress } : {},
+    port: endpoint.port,
+    ...endpoint.mode ? { mode: endpoint.mode } : {},
+    ...endpoint.amtRelay ? { amtRelay: endpoint.amtRelay } : {},
+    ...endpoint.amtRelayPort ? { amtRelayPort: endpoint.amtRelayPort } : {}
+  }));
+  const consumers = /* @__PURE__ */ new Map();
+  let entry;
+  const bytesListener = (event) => {
+    __privateMethod(this, _MulticastSubscriptionPool_instances, dispatch_fn).call(this, consumers, (consumer) => consumer.onBytes(event.detail));
+  };
+  const stateListener = (event) => {
+    __privateMethod(this, _MulticastSubscriptionPool_instances, dispatch_fn).call(this, consumers, (consumer) => consumer.onState?.(event.detail));
+    if (event.detail === "closed" && !entry.closed) {
+      entry.closed = true;
+      onClosed(entry);
+    }
+  };
+  const errorListener = (event) => {
+    const error = event.detail instanceof Error ? event.detail : new Error(String(event.detail));
+    __privateMethod(this, _MulticastSubscriptionPool_instances, dispatch_fn).call(this, consumers, (consumer) => consumer.onError?.(error));
+  };
+  entry = { subscription, consumers, bytesListener, stateListener, errorListener, closed: false };
+  subscription.addEventListener("bytes", bytesListener);
+  subscription.addEventListener("state", stateListener);
+  subscription.addEventListener("error", errorListener);
+  return entry;
+};
+gatewayId_fn = function(gateway) {
+  const object = gateway;
+  let id = __privateGet(this, _gatewayIds).get(object);
+  if (!id) {
+    id = __privateWrapper(this, _nextGatewayId)._++;
+    __privateGet(this, _gatewayIds).set(object, id);
+  }
+  return id;
+};
+detach_fn = function(entry) {
+  entry.subscription.removeEventListener("bytes", entry.bytesListener);
+  entry.subscription.removeEventListener("state", entry.stateListener);
+  entry.subscription.removeEventListener("error", entry.errorListener);
+};
+dispatch_fn = function(consumers, callback) {
+  for (const consumer of consumers.values()) {
+    try {
+      callback(consumer);
+    } catch (error) {
+      console.error("[Transport] multicast consumer callback failed", error);
+    }
+  }
+};
+var multicastSubscriptionPool = new MulticastSubscriptionPool();
+
+// node_modules/@blockcast/mmt-transport/dist/transport-manager.js
+var TransportManager = class {
+  constructor() {
+    __publicField(this, "state", {
+      mode: "disconnected",
+      connected: false,
+      packetsReceived: 0,
+      bytesReceived: 0,
+      lastPacketTime: 0
+    });
+    __publicField(this, "capabilities", null);
+    __publicField(this, "subscription", null);
+    __publicField(this, "driad", new DRIADDiscovery());
+    __publicField(this, "abr");
+    __publicField(this, "multicastOrchestrator", null);
+    __publicField(this, "onOrchestratorCommand");
+    __publicField(this, "connectionGeneration", 0);
+    __publicField(this, "onPacket");
+    __publicField(this, "onError");
+    __publicField(this, "onStateChange");
+    this.abr = new AdaptiveBitrateController();
+  }
+  getWindow() {
+    return typeof window === "undefined" ? void 0 : window;
+  }
+  getWindowMulticastGateway() {
+    return this.getWindow()?.multicast;
+  }
+  async getGatewayCapabilities(gateway) {
+    if (!gateway?.capabilities)
+      return void 0;
+    try {
+      return typeof gateway.capabilities === "function" ? await gateway.capabilities() : gateway.capabilities;
+    } catch (error) {
+      console.warn("[Transport] window.multicast capabilities failed:", error);
+      return void 0;
+    }
+  }
+  async gatewaySupportsBytes(gateway) {
+    if (typeof gateway?.subscribe !== "function")
+      return false;
+    if (!gateway.capabilities)
+      return true;
+    const capabilities = await this.getGatewayCapabilities(gateway);
+    if (!capabilities)
+      return false;
+    const consumeModes = capabilities.consumeModes;
+    return !consumeModes || consumeModes.includes("bytes");
+  }
+  /**
+   * Detect available transport capabilities
+   */
+  async detectCapabilities() {
+    if (this.capabilities)
+      return this.capabilities;
+    const gateway = this.getWindowMulticastGateway();
+    const hasGatewayBytes = await this.gatewaySupportsBytes(gateway);
+    const win = this.getWindow();
+    this.capabilities = {
+      nativeSSM: hasGatewayBytes,
+      nativeIGMP: hasGatewayBytes,
+      directSockets: typeof win?.UDPSocket !== "undefined",
+      amt: false,
+      driad: true,
+      // DRIAD uses HTTP proxy, always available
+      fecDecode: false
+    };
+    console.log("[Transport] Capabilities:", this.capabilities);
+    return this.capabilities;
+  }
+  /**
+   * Connect using best available transport
+   *
+   * Promotion hierarchy:
+   * 1. window.multicast gateway bytes
+   * 2. AMT proxy (specified or discovered via DRIAD)
+   * 3. MOQ WebTransport (final fallback)
+   */
+  async connect(config) {
+    const generation = ++this.connectionGeneration;
+    this.subscription?.close();
+    this.subscription = null;
+    this.state = {
+      mode: "disconnected",
+      connected: false,
+      packetsReceived: 0,
+      bytesReceived: 0,
+      lastPacketTime: 0
+    };
+    this.onStateChange?.(this.state);
+    const endpoint = normalizeMulticastEndpoint({
+      groupAddress: config.group,
+      sourceAddress: config.source,
+      port: config.port,
+      mode: config.mode,
+      amtRelay: config.amtRelay,
+      amtRelayPort: config.amtRelayPort
+    });
+    if (!endpoint) {
+      const error = new Error("Invalid multicast endpoint configuration");
+      this.onError?.(error);
+      return false;
+    }
+    config = {
+      ...config,
+      group: endpoint.groupAddress,
+      source: endpoint.sourceAddress ?? "",
+      mode: endpoint.mode,
+      amtRelay: endpoint.amtRelay,
+      amtRelayPort: endpoint.amtRelayPort
+    };
+    const caps = await this.detectCapabilities();
+    if (generation !== this.connectionGeneration)
+      return false;
+    if (config.initialQuality) {
+      this.abr = new AdaptiveBitrateController(config.initialQuality);
+    }
+    this.abr.setCallback((quality) => {
+      this.state.quality = quality;
+      this.subscription?.onqualitychange?.(quality);
+      this.onStateChange?.(this.state);
+    });
+    let connected = false;
+    if (caps.nativeSSM || caps.nativeIGMP) {
+      console.log("[Transport] Attempting window.multicast...");
+      connected = await this.connectWindowMulticast(config, generation);
+      if (connected) {
+        if (generation !== this.connectionGeneration)
+          return false;
+        this.state.mode = "multicast";
+        return true;
+      }
+    }
+    if (!connected) {
+      console.log("[Transport] Attempting AMT tunnel...");
+      connected = await this.connectAmt(config, generation);
+      if (connected) {
+        if (generation !== this.connectionGeneration)
+          return false;
+        this.state.mode = "amt";
+        return true;
+      }
+    }
+    console.log("[Transport] All multicast transports failed, falling back to MOQ");
+    return false;
+  }
+  /**
+   * Connect via the lowercase window.multicast bytes gateway.
+   */
+  async connectWindowMulticast(config, generation) {
+    try {
+      const gateway = this.getWindowMulticastGateway();
+      if (typeof gateway?.subscribe !== "function")
+        return false;
+      const lease = await multicastSubscriptionPool.acquire(gateway, config, {
+        onBytes: (data) => {
+          if (generation === this.connectionGeneration)
+            this.handlePacket(data);
+        },
+        onState: (state) => {
+          if (generation !== this.connectionGeneration)
+            return;
+          this.state.connected = state !== "closed";
+          this.onStateChange?.(this.state);
+        },
+        onError: (error) => {
+          if (generation !== this.connectionGeneration)
+            return;
+          console.error("[Transport] window.multicast error:", error);
+          this.onError?.(error);
+        }
+      });
+      if (generation !== this.connectionGeneration) {
+        await lease.release();
+        return false;
+      }
+      this.subscription = {
+        id: lease.key,
+        config,
+        close: () => {
+          void lease.release();
+        }
+      };
+      this.state = {
+        mode: "multicast",
+        connected: true,
+        group: config.group,
+        source: config.source,
+        quality: this.abr.getCurrentQuality(),
+        packetsReceived: 0,
+        bytesReceived: 0,
+        lastPacketTime: 0
+      };
+      console.log(`[Transport] Connected via window.multicast: (${config.source}, ${config.group})`);
+      this.onStateChange?.(this.state);
+      return true;
+    } catch (error) {
+      console.warn("[Transport] window.multicast failed:", error);
+      return false;
+    }
+  }
+  /**
+   * Connect via AMT proxy (with optional DRIAD discovery)
+   */
+  async connectAmt(config, generation) {
+    try {
+      let amtRelay = config.amtRelay;
+      if (!amtRelay && config.driadEnabled !== false && config.source) {
+        console.log(`[Transport] Discovering AMT relay via DRIAD for source ${config.source}...`);
+        const relays = await this.driad.discoverRelays(config.source);
+        if (generation !== this.connectionGeneration)
+          return false;
+        const bestRelay = await this.driad.selectBestRelay(relays);
+        if (generation !== this.connectionGeneration)
+          return false;
+        if (bestRelay) {
+          amtRelay = bestRelay.host;
+          this.state.amtRelay = amtRelay;
+        }
+      }
+      if (!amtRelay) {
+        console.warn("[Transport] No AMT relay available (DRIAD requires source address for SSM)");
+        return false;
+      }
+      return await this.connectAmtProxy(config, amtRelay, generation);
+    } catch (error) {
+      console.warn("[Transport] AMT connection failed:", error);
+      return false;
+    }
+  }
+  /**
+   * Connect via WebSocket-based AMT proxy (browser fallback)
+   */
+  async connectAmtProxy(config, amtRelay, generation) {
+    try {
+      const relayHost = amtRelay.includes(":") && !amtRelay.startsWith("[") ? `[${amtRelay}]` : amtRelay;
+      const relayAuthority = config.amtRelayPort ? `${relayHost}:${config.amtRelayPort}` : relayHost;
+      const wsUrl = new URL(`wss://${relayAuthority}/amt-proxy`);
+      wsUrl.searchParams.set("group", config.group);
+      wsUrl.searchParams.set("source", config.source || "");
+      wsUrl.searchParams.set("port", String(config.port));
+      const ws = new WebSocket(wsUrl);
+      return new Promise((resolve, reject) => {
+        ws.binaryType = "arraybuffer";
+        const timeout = setTimeout(() => {
+          ws.close();
+          reject(new Error("AMT proxy connection timeout"));
+        }, 1e4);
+        ws.onopen = () => {
+          clearTimeout(timeout);
+          if (generation !== this.connectionGeneration) {
+            ws.close();
+            resolve(false);
+            return;
+          }
+          console.log(`[Transport] Connected to AMT proxy: ${amtRelay}`);
+          this.subscription = {
+            id: `amt-proxy-${Date.now()}`,
+            config,
+            close: () => ws.close()
+          };
+          this.state = {
+            mode: "amt",
+            connected: true,
+            group: config.group,
+            source: config.source,
+            amtRelay,
+            quality: this.abr.getCurrentQuality(),
+            packetsReceived: 0,
+            bytesReceived: 0,
+            lastPacketTime: 0
+          };
+          this.onStateChange?.(this.state);
+          resolve(true);
+        };
+        ws.onmessage = (event) => {
+          if (generation === this.connectionGeneration && event.data instanceof ArrayBuffer) {
+            this.handlePacket(event.data);
+          }
+        };
+        ws.onerror = (error) => {
+          clearTimeout(timeout);
+          if (generation !== this.connectionGeneration) {
+            resolve(false);
+            return;
+          }
+          console.error("[Transport] AMT proxy error:", error);
+          reject(error);
+        };
+        ws.onclose = () => {
+          clearTimeout(timeout);
+          if (generation !== this.connectionGeneration) {
+            resolve(false);
+            return;
+          }
+          this.state.connected = false;
+          this.onStateChange?.(this.state);
+          resolve(false);
+        };
+      });
+    } catch (error) {
+      console.warn("[Transport] AMT proxy failed:", error);
+      return false;
+    }
+  }
+  /**
+   * Handle received packet
+   */
+  handlePacket(data) {
+    this.state.packetsReceived++;
+    this.state.bytesReceived += data.byteLength;
+    this.state.lastPacketTime = Date.now();
+    this.abr.recordSample(data.byteLength, 0);
+    this.onPacket?.(data);
+  }
+  /**
+   * Get current transport state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Get current quality level
+   */
+  getQuality() {
+    return this.abr.getCurrentQuality();
+  }
+  /**
+   * Force quality level
+   */
+  setQuality(name) {
+    this.abr.setQuality(name);
+  }
+  /** Configures multicast-only ABR while leaving the caller's MoQ ABR untouched. */
+  configureMulticastTiers(options, onCommand) {
+    this.dispatchOrchestratorCommand(this.multicastOrchestrator?.cancel());
+    this.multicastOrchestrator = new MulticastOrchestrator(options);
+    this.onOrchestratorCommand = onCommand;
+    return this.multicastOrchestrator.start();
+  }
+  recordMulticastGoodput(bitrate) {
+    return this.dispatchOrchestratorCommand(this.multicastOrchestrator?.onGoodput({ bitrate }));
+  }
+  recordMulticastHeadroom(healthy) {
+    return this.dispatchOrchestratorCommand(this.multicastOrchestrator?.onHeadroom({ healthy }));
+  }
+  recordMulticastTierPacket(packet) {
+    return this.dispatchOrchestratorCommand(this.multicastOrchestrator?.onTierPacket(packet));
+  }
+  pollMulticastTierSwitch() {
+    return this.dispatchOrchestratorCommand(this.multicastOrchestrator?.poll());
+  }
+  /**
+   * Set packet callback
+   */
+  setPacketCallback(callback) {
+    this.onPacket = callback;
+  }
+  /**
+   * Set error callback
+   */
+  setErrorCallback(callback) {
+    this.onError = callback;
+  }
+  /**
+   * Set state change callback
+   */
+  setStateCallback(callback) {
+    this.onStateChange = callback;
+  }
+  /**
+   * Disconnect
+   */
+  disconnect() {
+    this.connectionGeneration++;
+    this.subscription?.close();
+    this.subscription = null;
+    this.dispatchOrchestratorCommand(this.multicastOrchestrator?.cancel());
+    this.multicastOrchestrator = null;
+    this.onOrchestratorCommand = void 0;
+    this.state = {
+      mode: "disconnected",
+      connected: false,
+      packetsReceived: 0,
+      bytesReceived: 0,
+      lastPacketTime: 0
+    };
+    this.onStateChange?.(this.state);
+  }
+  dispatchOrchestratorCommand(command) {
+    if (command)
+      this.onOrchestratorCommand?.(command);
+    return command;
+  }
+};
+var transportManager = new TransportManager();
+
+// node_modules/@blockcast/mmt-transport/dist/moqt-priority.js
+var MAX_MOQT_PRIORITY = 255;
+function moqtPriority(value, field) {
+  if (!Number.isInteger(value) || value < 0 || value > MAX_MOQT_PRIORITY) {
+    throw new RangeError(`${field} must be an integer in [0, ${MAX_MOQT_PRIORITY}], got ${value}`);
+  }
+  return value;
+}
+function moqtSubscriberPriority(value) {
+  return moqtPriority(value, "MOQT subscriber priority");
+}
+function moqtPublisherPriority(value) {
+  return moqtPriority(value, "MOQT publisher priority");
+}
+var MOQT_SUBSCRIBER_PRIORITY = Object.freeze({
+  catalog: moqtSubscriberPriority(0),
+  deadlineRepair: moqtSubscriberPriority(0),
+  audio: moqtSubscriberPriority(1),
+  video: moqtSubscriberPriority(2),
+  backgroundRepair: moqtSubscriberPriority(3)
+});
+var MOQT_PUBLISHER_PRIORITY = Object.freeze({
+  catalog: moqtPublisherPriority(32),
+  source: moqtPublisherPriority(128),
+  repair: moqtPublisherPriority(240)
+});
+
+// node_modules/@blockcast/mmt-transport/dist/amt-gateway.js
+var DEFAULT_AMT_PORT = 2268;
+var AMTGatewayManager = class {
+  constructor() {
+    __publicField(this, "subscriptions", /* @__PURE__ */ new Map());
+    __publicField(this, "messageHandler");
+    __publicField(this, "pendingPackets", /* @__PURE__ */ new Map());
+    __publicField(this, "driad", new DRIADDiscovery());
+    this.messageHandler = (event) => {
+      const data = event.data;
+      console.log(`[AMT] SW message received:`, data.type);
+      if (data.type === "UDP_PACKET") {
+        this.handlePacket(data);
+      } else if (data.type === "SOCKET_ERROR") {
+        this.handleSocketError(data);
+      } else if (data.type === "DEBUG_LOG") {
+        console.log(`[AMT SW Debug] ${data.message}`);
+      }
+    };
+    if (typeof navigator !== "undefined" && navigator.serviceWorker) {
+      navigator.serviceWorker.addEventListener("message", this.messageHandler);
+      console.log("[AMT] Registered service worker message handler");
+    } else {
+      console.warn("[AMT] Service worker not available");
+    }
+  }
+  /**
+   * Subscribe via AMT tunnel
+   */
+  async subscribe(config) {
+    const { key } = config;
+    const keyStr = this.getKeyString(key);
+    if (this.subscriptions.has(keyStr)) {
+      console.log(`[AMT] Reusing existing subscription to ${keyStr}`);
+      return keyStr;
+    }
+    try {
+      let relayAddress;
+      let discoveryMethod;
+      const relayPort = config.relayPort || DEFAULT_AMT_PORT;
+      if (config.relayAddress) {
+        relayAddress = config.relayAddress;
+        discoveryMethod = "manual";
+        console.log(`[AMT] Using configured relay ${relayAddress}:${relayPort}`);
+      } else if (key.source) {
+        console.log(`[AMT] No relay configured, discovering via DRIAD for source ${key.source}...`);
+        const relays = await this.driad.discoverRelays(key.source);
+        const bestRelay = await this.driad.selectBestRelay(relays);
+        if (!bestRelay) {
+          throw new Error(`AMT relay discovery failed for source ${key.source}. Please specify a relay address in the subscription configuration.`);
+        }
+        relayAddress = bestRelay.host;
+        discoveryMethod = "driad";
+        console.log(`[AMT] Discovered relay via DRIAD: ${relayAddress}:${relayPort}`);
+      } else {
+        throw new Error(`AMT relay discovery requires a source address for SSM (RFC 8777). Please specify either a relay address or source address.`);
+      }
+      const subscriptionId = keyStr;
+      this.pendingPackets.set(subscriptionId, []);
+      const subscription = {
+        key,
+        subscriptionId,
+        config,
+        handshakeComplete: false,
+        relay: {
+          address: relayAddress,
+          port: relayPort,
+          discoveryMethod,
+          discoveredAt: Date.now()
+        }
+      };
+      this.subscriptions.set(keyStr, subscription);
+      console.log(`[AMT] Subscription created for ${keyStr} via ${relayAddress}:${relayPort}`);
+      return keyStr;
+    } catch (error) {
+      const subscription = this.subscriptions.get(keyStr);
+      if (subscription) {
+        this.subscriptions.delete(keyStr);
+        this.pendingPackets.delete(subscription.subscriptionId);
+      }
+      throw new Error(`Failed to subscribe via AMT: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * Unsubscribe from AMT tunnel
+   */
+  async unsubscribe(handle) {
+    const subscription = this.subscriptions.get(handle);
+    if (!subscription) {
+      throw new Error(`Subscription ${handle} not found`);
+    }
+    try {
+      if (subscription.keepAliveTimer) {
+        clearInterval(subscription.keepAliveTimer);
+      }
+      console.log(`[AMT] Unsubscribed from ${handle}`);
+    } catch (error) {
+      console.error("[AMT] Error during unsubscribe:", error);
+    } finally {
+      this.subscriptions.delete(handle);
+      this.pendingPackets.delete(subscription.subscriptionId);
+    }
+  }
+  /**
+   * Get list of active subscriptions
+   */
+  getSubscriptions() {
+    return Array.from(this.subscriptions.keys());
+  }
+  /**
+   * Handle packet from service worker
+   */
+  handlePacket(message) {
+    const { subscriptionId, data } = message;
+    if (!subscriptionId)
+      return;
+    const subscription = this.subscriptions.get(subscriptionId);
+    if (!subscription) {
+      console.warn(`[AMT] Received packet for unknown subscription: ${subscriptionId}`);
+      return;
+    }
+    if (!subscription.handshakeComplete) {
+      const queue = this.pendingPackets.get(subscriptionId);
+      const packetData2 = data;
+      if (queue) {
+        queue.push({
+          data: packetData2.data,
+          remoteAddress: packetData2.remoteAddress,
+          remotePort: packetData2.remotePort
+        });
+      }
+      return;
+    }
+    const packetData = data;
+    const metadata = {
+      sourceAddress: subscription.relay?.address || "unknown",
+      sourcePort: subscription.relay?.port || 0,
+      transport: "tunnel",
+      timestamp: performance.now()
+    };
+    subscription.config.onPacket(packetData.data, metadata);
+  }
+  /**
+   * Handle socket error from service worker
+   */
+  handleSocketError(message) {
+    const { subscriptionId, error } = message;
+    if (!subscriptionId)
+      return;
+    const subscription = this.subscriptions.get(subscriptionId);
+    if (!subscription) {
+      console.warn(`[AMT] Received error for unknown subscription: ${subscriptionId}`);
+      return;
+    }
+    subscription.config.onError(new Error(error || "Unknown error"));
+  }
+  /**
+   * Cleanup on destroy
+   */
+  destroy() {
+    if (this.messageHandler && typeof navigator !== "undefined" && navigator.serviceWorker) {
+      navigator.serviceWorker.removeEventListener("message", this.messageHandler);
+    }
+    const handles = Array.from(this.subscriptions.keys());
+    for (const handle of handles) {
+      this.unsubscribe(handle).catch((err) => {
+        console.error(`[AMT] Error unsubscribing ${handle}:`, err);
+      });
+    }
+  }
+  /**
+   * Get key string for HashMap
+   */
+  getKeyString(key) {
+    const source = key.source ? `@${key.source}` : "";
+    return `${key.group}:${key.port}${source}`;
+  }
+};
+var amtGatewayManager = new AMTGatewayManager();
+
+// src/multicast-transport.ts
+var MAX_TRACKED_DROPPED_PIDS = 16;
+function getMulticastGlobals() {
+  return globalThis;
+}
+function hasMulticastGateway() {
+  return typeof getMulticastGlobals().multicast?.subscribe === "function";
+}
+var _onPacket, _subscription2, _bytesListener, _resolvedTransport, _videoConfirmed, _audioConfirmed, _watchdog, _failbackWindowMs, _onTakeover, _onFailback, _disposed4, _stats3, _droppedPidCounts, _packetIds, _joinGeneration, _MulticastTransport_instances, releaseSubscription_fn, acceptPacket_fn, recordUnregisteredPidDrop_fn, checkTakeover_fn, resetWatchdog_fn;
+var _MulticastTransport = class _MulticastTransport {
+  constructor(onPacket) {
+    __privateAdd(this, _MulticastTransport_instances);
+    __privateAdd(this, _onPacket);
+    __privateAdd(this, _subscription2, null);
+    __privateAdd(this, _bytesListener, null);
+    __privateAdd(this, _resolvedTransport);
+    __privateAdd(this, _videoConfirmed, false);
+    __privateAdd(this, _audioConfirmed, false);
+    __privateAdd(this, _watchdog, null);
+    __privateAdd(this, _failbackWindowMs, null);
+    __privateAdd(this, _onTakeover, null);
+    __privateAdd(this, _onFailback, null);
+    __privateAdd(this, _disposed4, false);
+    __privateAdd(this, _stats3, {
+      packetsReceived: 0,
+      bytesReceived: 0,
+      packetsDroppedUnregisteredPid: 0,
+      packetsDroppedUnparseable: 0
+    });
+    __privateAdd(this, _droppedPidCounts, /* @__PURE__ */ new Map());
+    __privateAdd(this, _packetIds, null);
+    __privateAdd(this, _joinGeneration, 0);
+    __privateSet(this, _onPacket, onPacket);
+  }
+  static isAvailable() {
+    return hasMulticastGateway();
+  }
+  async join(config, context) {
+    const generation = ++__privateWrapper(this, _joinGeneration)._;
+    __privateMethod(this, _MulticastTransport_instances, releaseSubscription_fn).call(this);
     if (__privateGet(this, _disposed4)) return false;
     if (!_MulticastTransport.isAvailable()) {
       console.warn("[MulticastTransport] Multicast API not available");
@@ -14388,17 +16292,17 @@ var _MulticastTransport = class _MulticastTransport {
       console.log(
         `[MulticastTransport] window.multicast.subscribe(${config.sourceAddress}, ${config.groupAddress}, ${config.port})`
       );
-      const subscription = await getMulticastGlobals().multicast.subscribe({
+      const subscribeConfig = toWindowMulticastSubscribeConfig({
         source: config.sourceAddress,
         group: config.groupAddress,
         port: config.port,
-        consume: "bytes",
         mode: config.mode,
         amtRelay: config.amtRelay,
         amtRelayPort: config.amtRelayPort,
         packetIds: config.packetIds,
-        tracks: config.tracks?.map(({ name, packetId }) => ({ name, packetId }))
+        tracks: config.tracks
       });
+      const subscription = await getMulticastGlobals().multicast.subscribe(subscribeConfig);
       console.log(`[MulticastTransport] window.multicast.subscribe returned:`, !!subscription);
       if (__privateGet(this, _disposed4) || generation !== __privateGet(this, _joinGeneration)) {
         void subscription.unsubscribe();
@@ -14420,18 +16324,11 @@ var _MulticastTransport = class _MulticastTransport {
         __privateGet(this, _onPacket).call(this, packet, context);
         __privateMethod(this, _MulticastTransport_instances, resetWatchdog_fn).call(this);
       };
-      const onTransportChange = (event) => {
-        if (__privateGet(this, _disposed4) || generation !== __privateGet(this, _joinGeneration)) return;
-        const transport = normalizeResolvedTransport(event.detail);
-        if (transport) __privateSet(this, _resolvedTransport, transport);
-      };
       __privateSet(this, _subscription2, subscription);
       __privateSet(this, _bytesListener, onBytes);
-      __privateSet(this, _transportListener, onTransportChange);
       __privateSet(this, _packetIds, packetIds);
-      __privateSet(this, _resolvedTransport, normalizeResolvedTransport(subscription.transport));
+      __privateSet(this, _resolvedTransport, subscribeConfig.origin === "amt" ? "amt" : "native");
       subscription.addEventListener("bytes", onBytes);
-      subscription.addEventListener("transportchange", onTransportChange);
       __privateMethod(this, _MulticastTransport_instances, resetWatchdog_fn).call(this);
       console.log(
         `[MulticastTransport] Joined ${config.groupAddress}:${config.port}`
@@ -14499,7 +16396,6 @@ var _MulticastTransport = class _MulticastTransport {
 _onPacket = new WeakMap();
 _subscription2 = new WeakMap();
 _bytesListener = new WeakMap();
-_transportListener = new WeakMap();
 _resolvedTransport = new WeakMap();
 _videoConfirmed = new WeakMap();
 _audioConfirmed = new WeakMap();
@@ -14520,14 +16416,10 @@ releaseSubscription_fn = function() {
     if (__privateGet(this, _bytesListener)) {
       __privateGet(this, _subscription2).removeEventListener("bytes", __privateGet(this, _bytesListener));
     }
-    if (__privateGet(this, _transportListener)) {
-      __privateGet(this, _subscription2).removeEventListener("transportchange", __privateGet(this, _transportListener));
-    }
     void __privateGet(this, _subscription2).unsubscribe();
   }
   __privateSet(this, _subscription2, null);
   __privateSet(this, _bytesListener, null);
-  __privateSet(this, _transportListener, null);
   __privateSet(this, _resolvedTransport, void 0);
   __privateSet(this, _packetIds, null);
 };
@@ -14603,12 +16495,22 @@ function createDefaultRepairLifecycleEvent(detail, options) {
 function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function isRepairBlockIdentity(value) {
+function isRepairStreamIdentity(value) {
   if (!isRecord(value)) return false;
   const packetId = value["packetId"];
   const catalogTrackName = value["catalogTrackName"];
+  return Number.isSafeInteger(packetId) && packetId >= 0 && (catalogTrackName === null || typeof catalogTrackName === "string" && catalogTrackName.length > 0);
+}
+function isRepairBlockIdentity(value) {
+  if (!isRecord(value)) return false;
   const sbn = value["sbn"];
-  return Number.isSafeInteger(packetId) && packetId >= 0 && (catalogTrackName === null || typeof catalogTrackName === "string" && catalogTrackName.length > 0) && Number.isSafeInteger(sbn) && sbn >= 0;
+  return isRepairStreamIdentity(value) && Number.isSafeInteger(sbn) && sbn >= 0;
+}
+function isDecoderUnavailableReason(value) {
+  return value === "cleared" || value === "disposed";
+}
+function isFecFallbackDecoder(value) {
+  return value === "sync" || value === "none";
 }
 function isRepairLifecycleEvent(value) {
   if (!isRecord(value)) return false;
@@ -14616,7 +16518,11 @@ function isRepairLifecycleEvent(value) {
   const type = value["type"];
   const block = value["block"];
   const symbols = value["symbols"];
-  if (version !== 1 || type !== "requested" && type !== "recovered" && type !== "failed" || !isRepairBlockIdentity(block)) {
+  if (version !== 1) return false;
+  if (type === "decoder-unavailable") {
+    return isRepairStreamIdentity(value["stream"]) && isDecoderUnavailableReason(value["reason"]) && isFecFallbackDecoder(value["fallbackDecoder"]) && block === void 0 && symbols === void 0;
+  }
+  if (type !== "requested" && type !== "recovered" && type !== "failed" || !isRepairBlockIdentity(block) || value["stream"] !== void 0 || value["reason"] !== void 0 || value["fallbackDecoder"] !== void 0) {
     return false;
   }
   if (type === "requested") return symbols === void 0;
@@ -14635,22 +16541,25 @@ function forwardRepairLifecycleEvents(source, target, options = {}) {
     target.dispatchEvent(forwardedEvent);
   });
 }
-function repairBlockIdentity(packetId, sbn, catalogTrackName) {
+function repairStreamIdentity(packetId, catalogTrackName) {
   if (!Number.isSafeInteger(packetId) || packetId < 0) {
     throw new TypeError("packetId must be a non-negative safe integer");
   }
-  if (!Number.isSafeInteger(sbn) || sbn < 0) {
-    throw new TypeError("sbn must be a non-negative safe integer");
-  }
   if (catalogTrackName !== void 0 && (typeof catalogTrackName !== "string" || catalogTrackName.length === 0)) {
     throw new TypeError("catalogTrackName must be a non-empty string when provided");
   }
   return {
     packetId,
-    catalogTrackName: catalogTrackName ?? null,
-    sbn
+    catalogTrackName: catalogTrackName ?? null
   };
 }
+function repairBlockIdentity(packetId, sbn, catalogTrackName) {
+  const stream = repairStreamIdentity(packetId, catalogTrackName);
+  if (!Number.isSafeInteger(sbn) || sbn < 0) {
+    throw new TypeError("sbn must be a non-negative safe integer");
+  }
+  return { ...stream, sbn };
+}
 function assertPositiveGeometry(label, value) {
   if (value === void 0) return;
   if (!Number.isFinite(value) || value <= 0) {
@@ -14820,6 +16729,15 @@ var MulticastManager = class {
         }
       });
     };
+    __privateGet(this, _fec).onDecoderUnavailable = (event) => {
+      __privateMethod(this, _MulticastManager_instances, emitRepairLifecycle_fn).call(this, {
+        version: 1,
+        type: "decoder-unavailable",
+        stream: repairStreamIdentity(event.packetId, event.catalogTrackName),
+        reason: event.reason,
+        fallbackDecoder: event.fallbackDecoder
+      });
+    };
   }
   // ---------------------------------------------------------------------------
   // Decomposed component accessors (for new code)
@@ -14874,6 +16792,17 @@ var MulticastManager = class {
     __privateMethod(this, _MulticastManager_instances, configureTrackMapper_fn).call(this, packetId, config);
     __privateGet(this, _router).setPacketIdType(packetId, trackType);
   }
+  /**
+   * Stop routing a stream's symbols to its Worker decoder. Returns false when
+   * none is registered; on success one `decoder-unavailable` repair lifecycle
+   * event with reason 'cleared' reaches every observer, carrying whether a
+   * synchronous WASM decoder still serves the stream. The packet mapping and
+   * track type are untouched: the track still exists, it just has no Worker
+   * decoder. Call this before disposing the client.
+   */
+  clearFecWorker(packetId, catalogTrackName) {
+    return __privateGet(this, _fec).clearFecWorker(packetId, catalogTrackName);
+  }
   /** Register callback for Worker-level FecTrackStats updates. */
   setOnFecStatsUpdate(cb) {
     __privateGet(this, _fec).onFecStatsUpdate = cb;
@@ -14919,8 +16848,9 @@ var MulticastManager = class {
       repairSymbols: config.fecRepairSymbols,
       symbolSize: config.fecSymbolSize,
       mediaUnitsPerSecond: config.fps,
-      bandwidthBps: config.bandwidth
-    }) + (config.fecReorderToleranceMs ?? 0) : void 0;
+      bandwidthBps: config.bandwidth,
+      jitterBufferMs: config.fecReorderToleranceMs
+    }) : void 0;
     const fecConfig = {
       k: config.fecK,
       symbolSize: config.fecSymbolSize,
@@ -14957,8 +16887,9 @@ var MulticastManager = class {
       repairSymbols: config.fecRepairSymbols,
       symbolSize: config.fecSymbolSize,
       mediaUnitsPerSecond: config.fps,
-      bandwidthBps: config.bandwidth
-    }) + (config.fecReorderToleranceMs ?? 0) : void 0;
+      bandwidthBps: config.bandwidth,
+      jitterBufferMs: config.fecReorderToleranceMs
+    }) : void 0;
     __privateGet(this, _fec).configure({
       k: config.fecK,
       symbolSize: config.fecSymbolSize,
@@ -15475,11 +17406,13 @@ applyStreamGlobalFecTiming_fn = function() {
 };
 _onTrackTypeDiscovered = new WeakMap();
 emitRepairLifecycle_fn = function(event) {
-  const immutableEvent = Object.freeze({
-    ...event,
-    block: Object.freeze({ ...event.block }),
-    ...event.type === "requested" ? {} : { symbols: Object.freeze({ ...event.symbols }) }
-  });
+  const immutableEvent = Object.freeze(
+    event.type === "decoder-unavailable" ? { ...event, stream: Object.freeze({ ...event.stream }) } : {
+      ...event,
+      block: Object.freeze({ ...event.block }),
+      ...event.type === "requested" ? {} : { symbols: Object.freeze({ ...event.symbols }) }
+    }
+  );
   console.info(
     `${REPAIR_LIFECYCLE_LOG_PREFIX}${JSON.stringify(immutableEvent)}`
   );
@@ -15503,7 +17436,8 @@ async function setupFecWorkerForTrack(opts) {
     sourceSymbols: opts.fecK,
     repairSymbols: opts.fecRepairCount,
     symbolSize: opts.fecSymbolSize,
-    mediaUnitsPerSecond: 1e3 / opts.mediaUnitDurationMs
+    mediaUnitsPerSecond: 1e3 / opts.mediaUnitDurationMs,
+    jitterBufferMs: opts.fecReorderToleranceMs
   });
   const origin = typeof location !== "undefined" && location.origin ? location.origin : "http://localhost";
   const workerUrl = new URL(opts.assetUrls.fecWorker, origin);
@@ -15549,15 +17483,23 @@ async function setupFecWorkerForTrack(opts) {
     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);
+  try {
+    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);
+  } catch (e) {
+    try {
+      client.dispose();
+    } catch {
+    }
+    throw e;
+  }
   let disposed = false;
   return {
     client,
@@ -15565,6 +17507,11 @@ async function setupFecWorkerForTrack(opts) {
     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 {
@@ -16448,7 +18395,7 @@ _readIndex = new WeakMap();
 _stalled = new WeakMap();
 
 // src/mmtp-decode-pipeline.ts
-var _parser2, _fecClient, _frameCb2, _initCb2, _needsKeyframe, _codec, _gateDropped, _gateEmitted, _fedObjects, _warnedNoParser, _feedOutcomes, _MmtpDecodePipeline_instances, gatedEmit_fn;
+var _parser2, _fecClient, _frameCb2, _initCb2, _needsKeyframe, _codec, _trackType, _gateDropped, _gateEmitted, _fedObjects, _warnedNoParser, _feedOutcomes, _MmtpDecodePipeline_instances, tag_fn, gatedEmit_fn;
 var MmtpDecodePipeline = class {
   constructor() {
     __privateAdd(this, _MmtpDecodePipeline_instances);
@@ -16457,7 +18404,11 @@ var MmtpDecodePipeline = class {
     __privateAdd(this, _frameCb2, null);
     __privateAdd(this, _initCb2, null);
     __privateAdd(this, _needsKeyframe, false);
-    __privateAdd(this, _codec, "");
+    __privateAdd(this, _codec, null);
+    /** Set together with #codec at configure(). Also the diagnostic label: a
+     *  player builds one pipeline per track, and codec alone does not say which
+     *  role a line belongs to at a glance. */
+    __privateAdd(this, _trackType, null);
     /** Diagnostic counters. The keyframe gate drops silently, so a parser that
      *  never marks a frame as a keyframe stalls the whole pipeline with no
      *  output anywhere: frames are fed, frames are parsed, and nothing is
@@ -16486,6 +18437,7 @@ var MmtpDecodePipeline = class {
     __privateSet(this, _warnedNoParser, false);
     __privateSet(this, _codec, config.codec);
     const trackType = isVideoCodec(config.codec) ? "video" : "audio";
+    __privateSet(this, _trackType, trackType);
     const trackInfo = {
       type: trackType,
       codec: config.codec,
@@ -16529,6 +18481,24 @@ var MmtpDecodePipeline = class {
   get reorderStats() {
     return __privateGet(this, _parser2)?.reorderStats ?? null;
   }
+  /**
+   * Feed tallies for this track. A fresh snapshot per call, not a live view.
+   *
+   * Unlike reorderStats this never returns null: the counters belong to the
+   * pipeline rather than the parser, so they survive dispose(). That is
+   * deliberate — a wedged pipeline is usually read after teardown, which is
+   * exactly when the parser is already gone.
+   */
+  get feedStats() {
+    return {
+      trackType: __privateGet(this, _trackType),
+      codec: __privateGet(this, _codec),
+      fedObjects: __privateGet(this, _fedObjects),
+      emitted: __privateGet(this, _gateEmitted),
+      gateDropped: __privateGet(this, _gateDropped),
+      outcomes: Object.fromEntries(__privateGet(this, _feedOutcomes))
+    };
+  }
   /**
    * Feed a raw MoQ object payload (one MMTP packet per MoQ object).
    * Optionally feeds source symbols to FEC client before parsing.
@@ -16537,33 +18507,37 @@ var MmtpDecodePipeline = class {
     if (!__privateGet(this, _parser2)) {
       if (!__privateGet(this, _warnedNoParser)) {
         __privateSet(this, _warnedNoParser, true);
-        console.warn("[mmtp-pipeline] feedMoqObject called with NO PARSER configured \u2014 packet dropped");
+        console.warn(`[mmtp-pipeline] feedMoqObject called with NO PARSER configured ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} \u2014 packet dropped`);
       }
       return;
     }
     __privateSet(this, _fedObjects, __privateGet(this, _fedObjects) + 1);
     if (__privateGet(this, _fedObjects) === 1) {
-      console.log(`[mmtp-pipeline] first object fed codec=${__privateGet(this, _codec)} bytes=${packet.length}`);
+      console.log(`[mmtp-pipeline] first object fed ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} bytes=${packet.length}`);
     }
-    if (__privateGet(this, _fecClient)?.addSourceSymbol) {
-      const info = __privateGet(this, _parser2).parseHeader(packet);
-      if (info?.fecPayloadId) {
-        __privateGet(this, _fecClient).addSourceSymbol(info.fecPayloadId.ssId, packet);
+    let outcomeKind = "threw";
+    try {
+      if (__privateGet(this, _fecClient)?.addSourceSymbol) {
+        const info = __privateGet(this, _parser2).parseHeader(packet);
+        if (info?.fecPayloadId) {
+          __privateGet(this, _fecClient).addSourceSymbol(info.fecPayloadId.ssId, packet);
+        }
+      }
+      const record = __privateGet(this, _parser2).feed(packet);
+      outcomeKind = record?.kind ?? "null(parse-or-extract-failed)";
+    } finally {
+      const seen = (__privateGet(this, _feedOutcomes).get(outcomeKind) ?? 0) + 1;
+      __privateGet(this, _feedOutcomes).set(outcomeKind, seen);
+      if (seen === 1) {
+        console.log(
+          `[mmtp-pipeline] feed outcome FIRST '${outcomeKind}' ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} at object #${__privateGet(this, _fedObjects)} bytes=${packet.length}`
+        );
       }
-    }
-    const record = __privateGet(this, _parser2).feed(packet);
-    const kind = record?.kind ?? "null(parse-or-extract-failed)";
-    const seen = (__privateGet(this, _feedOutcomes).get(kind) ?? 0) + 1;
-    __privateGet(this, _feedOutcomes).set(kind, seen);
-    if (seen === 1) {
-      console.log(
-        `[mmtp-pipeline] feed outcome FIRST '${kind}' at object #${__privateGet(this, _fedObjects)} bytes=${packet.length}`
-      );
     }
     if (__privateGet(this, _fedObjects) % 200 === 0) {
       const hist = [...__privateGet(this, _feedOutcomes)].map(([k, v]) => `${k}=${v}`).join(" ");
       console.log(
-        `[mmtp-pipeline] feed histogram @${__privateGet(this, _fedObjects)}: ${hist} | emitted=${__privateGet(this, _gateEmitted)} gateDropped=${__privateGet(this, _gateDropped)}`
+        `[mmtp-pipeline] feed histogram ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} @${__privateGet(this, _fedObjects)}: ${hist} | emitted=${__privateGet(this, _gateEmitted)} gateDropped=${__privateGet(this, _gateDropped)}`
       );
     }
   }
@@ -16583,7 +18557,10 @@ var MmtpDecodePipeline = class {
       ...meta.mmtpTimestamp === void 0 ? {} : { mmtpTimestamp: meta.mmtpTimestamp },
       keyframe: meta.keyframe,
       packetId: meta.packetId,
-      trackType: isVideoCodec(__privateGet(this, _codec)) ? "video" : "audio",
+      // Same derivation as configure(), read from the field it set rather than
+      // recomputed. Pre-configure the parser is null and routeFrame below is a
+      // no-op, so the fallback is unreachable in practice.
+      trackType: __privateGet(this, _trackType) ?? "audio",
       packetSequenceNumber: meta.packetSequenceNumber
     };
     if (meta.sourceDiscontinuity) frameMeta.sourceDiscontinuity = true;
@@ -16609,7 +18586,7 @@ var MmtpDecodePipeline = class {
     const droppedFrames = (__privateGet(this, _parser2)?.reorderStats.droppedOnLiveDispose ?? droppedBefore) - droppedBefore;
     if (droppedFrames > 0) {
       console.warn(
-        `[MmtpDecodePipeline] live dispose dropped ${droppedFrames} buffered frame(s); finite inputs must use dispose({ flush: true })`
+        `[MmtpDecodePipeline] live dispose ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} dropped ${droppedFrames} buffered frame(s); finite inputs must use dispose({ flush: true })`
       );
     }
     __privateSet(this, _parser2, null);
@@ -16624,12 +18601,19 @@ _frameCb2 = new WeakMap();
 _initCb2 = new WeakMap();
 _needsKeyframe = new WeakMap();
 _codec = new WeakMap();
+_trackType = new WeakMap();
 _gateDropped = new WeakMap();
 _gateEmitted = new WeakMap();
 _fedObjects = new WeakMap();
 _warnedNoParser = new WeakMap();
 _feedOutcomes = new WeakMap();
 _MmtpDecodePipeline_instances = new WeakSet();
+/** Identity prefix for diagnostics: one pipeline per track means two
+ *  instances write to the same console, and unlabelled lines interleave into
+ *  a single unreadable stream. */
+tag_fn = function() {
+  return `track=${__privateGet(this, _trackType) ?? "unconfigured"} codec=${__privateGet(this, _codec) ?? "none"}`;
+};
 gatedEmit_fn = function(data, meta) {
   var _a;
   let sourceDiscontinuity = false;
@@ -16638,7 +18622,7 @@ gatedEmit_fn = function(data, meta) {
       __privateSet(this, _gateDropped, __privateGet(this, _gateDropped) + 1);
       if (__privateGet(this, _gateDropped) <= 3 || __privateGet(this, _gateDropped) % 200 === 0) {
         console.warn(
-          `[mmtp-pipeline] keyframe gate DROP #${__privateGet(this, _gateDropped)} codec=${__privateGet(this, _codec)} bytes=${data.length} fed=${__privateGet(this, _fedObjects)} emitted=${__privateGet(this, _gateEmitted)}`
+          `[mmtp-pipeline] keyframe gate DROP #${__privateGet(this, _gateDropped)} ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} bytes=${data.length} fed=${__privateGet(this, _fedObjects)} emitted=${__privateGet(this, _gateEmitted)}`
         );
       }
       return;
@@ -16646,12 +18630,12 @@ gatedEmit_fn = function(data, meta) {
     __privateSet(this, _needsKeyframe, false);
     sourceDiscontinuity = true;
     console.log(
-      `[mmtp-pipeline] keyframe gate OPENED codec=${__privateGet(this, _codec)} after ${__privateGet(this, _gateDropped)} drops, fed=${__privateGet(this, _fedObjects)}`
+      `[mmtp-pipeline] keyframe gate OPENED ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} after ${__privateGet(this, _gateDropped)} drops, fed=${__privateGet(this, _fedObjects)}`
     );
   }
   __privateSet(this, _gateEmitted, __privateGet(this, _gateEmitted) + 1);
   if (__privateGet(this, _gateEmitted) === 1) {
-    console.log(`[mmtp-pipeline] first frame emitted codec=${__privateGet(this, _codec)} bytes=${data.length}`);
+    console.log(`[mmtp-pipeline] first frame emitted ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} bytes=${data.length}`);
   }
   const outMeta = sourceDiscontinuity ? { ...meta, sourceDiscontinuity: true } : meta;
   (_a = __privateGet(this, _frameCb2)) == null ? void 0 : _a.call(this, data, outMeta);
@@ -17325,12 +19309,140 @@ emit_fn = function(params) {
 };
 
 // src/catalog-fec-params.ts
+var MAX_SAFE_TICKS_PER_HZ = Number.MAX_SAFE_INTEGER / 1e3;
+function timescaleHz(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
+}
+function catalogGroupDurationMs(rendition) {
+  if (!rendition) return void 0;
+  const ticks = numericField(rendition.groupDurationTicks);
+  const ms = numericField(rendition.groupDurationMs);
+  const timescale = timescaleHz(rendition.container?.kind === "mmtp" ? rendition.container.timescale : void 0) ?? timescaleHz(rendition.timescale);
+  if (ticks !== void 0 && timescale !== void 0 && Number.isSafeInteger(ticks) && ticks <= timescale * MAX_SAFE_TICKS_PER_HZ) {
+    return resolveGroupDurationMs({ groupDurationTicks: ticks }, timescale);
+  }
+  return ms;
+}
+function resolveCatalogTrackGroupDurationMs(catalog, track) {
+  const renditions = track.type === "audio" ? catalog?.audio?.renditions : catalog?.video?.renditions;
+  return catalogGroupDurationMs(renditions?.[track.name]);
+}
 var NO_FEC = {
   fecK: 0,
   fecRepairCount: 0,
+  fecTotalRepairCount: 0,
   fecSymbolSize: 0,
   fecInterleaveMs: 0
 };
+function recordOf(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function msfTracks(catalog) {
+  const raw = catalog.tracks;
+  if (!Array.isArray(raw)) return void 0;
+  const common = recordOf(catalog.commonTrackFields) ?? {};
+  return { tracks: raw.map((t) => recordOf(t) ?? {}), common };
+}
+function resolveRepairLayers(catalog, source) {
+  if (!catalog) return void 0;
+  const sourceName = typeof source === "string" ? source : source.name;
+  const hang = catalog;
+  const roles = typeof source === "string" ? ["video", "audio"] : source.type === "audio" ? ["audio"] : source.type === "video" ? ["video"] : ["video", "audio"];
+  const role = roles.find((r) => recordOf(hang[r]?.renditions?.[sourceName]) !== void 0);
+  if (role !== void 0) {
+    const renditionPath = `$.${role}.renditions[${JSON.stringify(sourceName)}]`;
+    const rendition = recordOf(hang[role].renditions[sourceName]);
+    rejectRepairFieldsOnMediaTrack(renditionPath, rendition, throwRepairContractError);
+    const repairRenditions = recordOf(hang.repair?.renditions) ?? {};
+    const descriptors2 = Object.entries(repairRenditions).map(([name, entry]) => {
+      const path = `$.repair.renditions[${JSON.stringify(name)}]`;
+      const fields = recordOf(entry);
+      if (fields === void 0) {
+        throwRepairContractError("track_repair_layer", path, "a repair rendition must be an object");
+      }
+      rejectRepairTrackGeometry(path, fields, throwRepairContractError);
+      return describeRepairTrack(name, path, fields);
+    });
+    const fecOfRendition = (entry) => {
+      const fec2 = recordOf(recordOf(entry)?.["fec"]);
+      return fec2 !== void 0 && fec2["algorithm"] !== "none" ? fec2 : void 0;
+    };
+    const mediaRenditions = [
+      ...Object.values(recordOf(hang.video?.renditions) ?? {}),
+      ...Object.values(recordOf(hang.audio?.renditions) ?? {})
+    ];
+    const reachability2 = repairReachability(mediaRenditions.map((entry) => recordOf(entry)?.["fec"]));
+    for (const d of descriptors2) {
+      validateRepairTrackFields(d, throwRepairContractError);
+      assertRepairTrackReachable(d, reachability2, throwRepairContractError);
+      const target = dependsTarget(d);
+      if (target === void 0) continue;
+      const targetFec = fecOfRendition(hang.video?.renditions?.[target]) ?? fecOfRendition(hang.audio?.renditions?.[target]);
+      if (targetFec === void 0) {
+        throwRepairContractError(
+          "track_repair_depends",
+          `${d.path}.depends`,
+          `${JSON.stringify(target)} is not a video or audio rendition with FEC`
+        );
+      }
+    }
+    return assembleRepairLayers(
+      geometryOf(sourceName, `${renditionPath}.fec`, recordOf(rendition["fec"])),
+      descriptors2,
+      throwRepairContractError
+    );
+  }
+  const msf = msfTracks(catalog);
+  const msfIndex = msf ? msf.tracks.findIndex((t) => t["name"] === sourceName) : -1;
+  if (!msf || msfIndex < 0) return void 0;
+  const track = msf.tracks[msfIndex];
+  const fec = recordOf(track["fec"]);
+  const packagingOf = (t) => t["packaging"] ?? msf.common["packaging"];
+  const fecOfTrack = (t) => {
+    const trackFec = recordOf(t?.["fec"]);
+    return trackFec !== void 0 && trackFec["algorithm"] !== "none" ? trackFec : void 0;
+  };
+  const descriptors = [];
+  const mediaTracks = [];
+  msf.tracks.forEach((t, i) => {
+    const path = `$.tracks[${i}]`;
+    if (packagingOf(t) === "fec-repair") {
+      rejectRepairTrackGeometry(path, t, throwRepairContractError);
+      if (typeof t["name"] === "string") descriptors.push(describeRepairTrack(t["name"], path, t));
+      return;
+    }
+    rejectRepairFieldsOnMediaTrack(path, t, throwRepairContractError);
+    mediaTracks.push(t);
+  });
+  const reachability = repairReachability(mediaTracks.map((t) => t["fec"]));
+  for (const d of descriptors) {
+    validateRepairTrackFields(d, throwRepairContractError);
+    assertRepairTrackReachable(d, reachability, throwRepairContractError);
+    const target = dependsTarget(d);
+    if (target === void 0) continue;
+    const targetTrack = msf.tracks.find((t) => t["name"] === target);
+    if (targetTrack === void 0 || packagingOf(targetTrack) !== "mmtp" || fecOfTrack(targetTrack) === void 0) {
+      throwRepairContractError(
+        "track_repair_depends",
+        `${d.path}.depends`,
+        `${JSON.stringify(target)} is not an mmtp track with FEC`
+      );
+    }
+  }
+  return assembleRepairLayers(geometryOf(sourceName, `$.tracks[${msfIndex}].fec`, fec), descriptors, throwRepairContractError, {
+    layerZeroMustBeDeclared: true
+  });
+}
+function geometryOf(name, path, fec) {
+  return {
+    name,
+    path,
+    algorithm: fec?.["algorithm"],
+    sourceSymbols: fec?.["sourceSymbols"],
+    repairSymbols: fec?.["repairSymbols"],
+    repairTrack: fec?.["repairTrack"]
+  };
+}
 function numericField(value) {
   const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
   return Number.isFinite(n) && n > 0 ? n : void 0;
@@ -17339,13 +19451,16 @@ function nonNegativeField(value) {
   const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
   return Number.isFinite(n) && n >= 0 ? n : void 0;
 }
-function fecParams(rendition, fps, sampleRate) {
+function fecParams(catalog, track, rendition, fps, sampleRate) {
   const mediaRate = sampleRate === void 0 ? { fps } : { fps, sampleRate };
   const fec = rendition?.fec;
   if (!fec) return { ...NO_FEC, ...mediaRate };
+  const repair = track ? resolveRepairLayers(catalog, track) : void 0;
   return {
     fecK: fec.sourceSymbols ?? 0,
     fecRepairCount: fec.repairSymbols ?? 0,
+    // The wire RSB_length: every base layer's packets carry the base total (§7.1).
+    fecTotalRepairCount: repair?.totalBaseRepairSymbols ?? fec.repairSymbols ?? 0,
     fecSymbolSize: fec.symbolSize ?? 0,
     // interleaveDepthMs is the FEC block span in MILLISECONDS (§5.1) — the
     // only interleave key the catalog carries post-BLO-14526. Receivers
@@ -17357,6 +19472,8 @@ function fecParams(rendition, fps, sampleRate) {
     // so it cannot be reused here — a declared 0 is a legitimate value.
     fecReorderToleranceMs: nonNegativeField(fec.reorderToleranceMs),
     repairTrackName: fec.repairTrack,
+    repairLayers: repair?.baseLayers,
+    repairOverlays: repair?.overlays,
     ...mediaRate
   };
 }
@@ -17370,8 +19487,14 @@ function resolveCatalogTrackFec(catalog, tracks) {
   const catalogFps = numericField(video?.framerate);
   const sampleRate = numericField(audio?.sampleRate ?? audio?.samplerate);
   const audioFps = sampleRate ? sampleRate / 1024 : void 0;
-  const videoParams = fecParams(video, catalogFps);
-  const audioParams = fecParams(audio, audioFps, sampleRate);
+  const videoParams = fecParams(catalog, videoTrackName ? { name: videoTrackName, type: "video" } : void 0, video, catalogFps);
+  const audioParams = fecParams(
+    catalog,
+    audioTrackName ? { name: audioTrackName, type: "audio" } : void 0,
+    audio,
+    audioFps,
+    sampleRate
+  );
   return {
     videoTrackName,
     audioTrackName,
@@ -17534,6 +19657,7 @@ export {
   CmafGroupBatcher,
   CmcdProducer,
   CmsfCatalogValidationError,
+  DEFAULT_REPAIR_PRIORITY,
   FECManager,
   FEC_ESI_MAX,
   FEC_SBN_MAX,
@@ -17541,6 +19665,10 @@ export {
   FecStarvationDetector,
   KEYFRAME_LOST_TIMEOUT_SLACK,
   LOCHeaderExtensionId,
+  MAX_ENCODING_SYMBOL_ID,
+  MAX_RAPTORQ_SOURCE_SYMBOLS,
+  MAX_REPAIR_SYMBOLS,
+  MAX_TAKEOVER_DEADLINE_MS,
   MFUReassembler,
   MediaRouter,
   MfuReassemblyError,
@@ -17555,7 +19683,12 @@ export {
   NoneCodec,
   REPAIR_LIFECYCLE_EVENT_TYPE,
   REPAIR_LIFECYCLE_LOG_PREFIX,
+  REPAIR_PRIORITY_MAX,
+  REPAIR_PRIORITY_MIN,
+  REPAIR_TRACK_GEOMETRY_KEYS,
+  REPAIR_TRACK_ONLY_KEYS,
   ReedSolomonCodec,
+  RepairContractError,
   SampleCombineError,
   SampleCombiner,
   SessionManager,
@@ -17566,11 +19699,14 @@ export {
   WasmMfuReassembler,
   annexBToAvcc,
   asSeconds,
+  assembleRepairLayers,
+  assertRepairTrackReachable,
   avccToAnnexB,
   buildAudioInitSegment,
   buildVideoInitSegment,
   catalogAmtNetworkSource,
   catalogFecInterleaveMs,
+  catalogGroupDurationMs,
   classifyH264Keyframe,
   classifyPacket,
   codecStringFromAvcC,
@@ -17585,6 +19721,8 @@ export {
   decodeLocHeader,
   decodeLocTimestamp,
   decodeTimestamp,
+  dependsTarget,
+  describeRepairTrack,
   detectH264Keyframe,
   driftCheck,
   encodeDataSegment,
@@ -17638,12 +19776,17 @@ export {
   parseAacSampleRate,
   parseOpusFrameSamples,
   processMMTPWithReassembly,
+  rejectRepairFieldsOnMediaTrack,
+  rejectRepairTrackGeometry,
   reliableMoqMfuReassembly,
   removeEmulationPrevention,
+  repairReachability,
   resolveCatalogTrackFec,
+  resolveCatalogTrackGroupDurationMs,
   resolveGlobalMmtWasmBindings,
   resolveGroupDurationMs,
   resolveGroupDurationTicks,
+  resolveRepairLayers,
   secondsFromTicks,
   setupFecWorkerForTrack,
   setupTrackPipeline,
@@ -17653,6 +19796,7 @@ export {
   unwrapMulticastPacket,
   validateCmsfMmtpCatalog,
   validateMulticastContainerContract,
+  validateRepairTrackFields,
   validateSwitchingSetTiming,
   wireRepairFetch,
   wrapAdtsFrame