@blockcast/mmt-container 2.1.0 → 2.2.0-main.079cd7664c0b

package/dist/mmtp-router.js

@@ -149,30 +149,26 @@ function isEmptyOrExactLegacyTrailer(payload, start, end) {
   const authLength = view2.getUint16(2, false);
   return start + LEGACY_TRAILER_HEADER_SIZE + authLength === end;
 }
-function resolveDeclaredTrailers(payload, declaredEnd, fecType, options, rapFlag = false) {
+function resolveDeclaredTrailers(payload, declaredEnd, fecType, options) {
   if (declaredEnd > payload.length)
     return null;
   if (options?.skipFecId) {
-    return isEmptyOrExactLegacyTrailer(payload, declaredEnd, payload.length) ? { hasFecId: false, hasOverlayFecId: false } : null;
+    return isEmptyOrExactLegacyTrailer(payload, declaredEnd, payload.length) ? { hasFecId: false } : null;
   }
-  const overlay = options?.overlayDeclared === true && rapFlag;
   if (fecType === 1) {
-    const fecStart = payload.length - sourceFecTrailerSize(overlay);
+    const fecStart = payload.length - SOURCE_FEC_PAYLOAD_ID_SIZE;
     if (fecStart < declaredEnd || !isEmptyOrExactLegacyTrailer(payload, declaredEnd, fecStart)) {
       return null;
     }
-    return { hasFecId: true, hasOverlayFecId: overlay };
+    return { hasFecId: true };
   }
-  if (fecType !== 0 || overlay)
+  if (fecType !== 0)
     return null;
   if (isEmptyOrExactLegacyTrailer(payload, declaredEnd, payload.length)) {
-    return { hasFecId: false, hasOverlayFecId: false };
+    return { hasFecId: false };
   }
   return null;
 }
-function sourceFecTrailerSize(overlay) {
-  return overlay ? 2 * SOURCE_FEC_PAYLOAD_ID_SIZE : SOURCE_FEC_PAYLOAD_ID_SIZE;
-}
 function planMfuExtraction(mmtpPacket, options, parsedHeader) {
   if (mmtpPacket.length < MMTP_HEADER_SIZE + MPU_HEADER_SIZE) {
     return {
@@ -225,11 +221,11 @@ function planMfuExtraction(mmtpPacket, options, parsedHeader) {
   if ("rejection" in layoutResult)
     return layoutResult;
   const { layout } = layoutResult;
-  const trailerLayout = resolveDeclaredTrailers(payload, layout.dataEnd, header.fecType, options, header.rapFlag);
+  const trailerLayout = resolveDeclaredTrailers(payload, layout.dataEnd, header.fecType, options);
   if (!trailerLayout) {
     if (!options?.skipFecId && header.fecType === 1) {
       const observed = payload.length - layout.dataEnd;
-      const expected = sourceFecTrailerSize(options?.overlayDeclared === true && header.rapFlag);
+      const expected = SOURCE_FEC_PAYLOAD_ID_SIZE;
       if (observed !== expected) {
         return {
           rejection: {
@@ -261,13 +257,10 @@ function extractPlannedMfu(mmtpPacket, result) {
   const mfuDuHeader = mfuDuHeaderPresent && mpu.timedFlag === 1 ? parseTimedMfuDuHeader(payload, MPU_HEADER_SIZE) : null;
   const itemId = mfuDuHeaderPresent && mpu.timedFlag === 0 ? new DataView(payload.buffer, payload.byteOffset + MPU_HEADER_SIZE, 4).getUint32(0, false) : null;
   const data = payload.subarray(mfuOffset, dataEnd);
-  const trailerStart = mmtpPacket.length - sourceFecTrailerSize(trailerLayout.hasOverlayFecId);
-  const ssIdAt = (offset) => ({
-    ssId: new DataView(mmtpPacket.buffer, mmtpPacket.byteOffset + offset, 4).getUint32(0, false)
-  });
-  const fecPayloadId = trailerLayout.hasFecId ? ssIdAt(trailerStart) : null;
-  const overlayFecPayloadId = trailerLayout.hasOverlayFecId ? ssIdAt(trailerStart + SOURCE_FEC_PAYLOAD_ID_SIZE) : null;
-  return { header, mpu, fragmentType, data, mfuDuHeader, itemId, fecPayloadId, overlayFecPayloadId };
+  const fecPayloadId = trailerLayout.hasFecId ? {
+    ssId: new DataView(mmtpPacket.buffer, mmtpPacket.byteOffset + mmtpPacket.length - SOURCE_FEC_PAYLOAD_ID_SIZE, 4).getUint32(0, false)
+  } : null;
+  return { header, mpu, fragmentType, data, mfuDuHeader, itemId, fecPayloadId };
 }
 function sourceFecPayloadIdOf(mmtpPacket, header) {
   if (mmtpPacket.length < MMTP_HEADER_SIZE + MPU_HEADER_SIZE)
@@ -377,6 +370,1422 @@ var RUNTIME_FEC_RECEIVER = Object.freeze({
   overlays: true
 });
 
+// node_modules/@blockcast/mmt-transport/dist/multicast-tier.js
+function endpointKey(endpoint) {
+  return `${endpoint.sourceAddress ?? ""}|${endpoint.groupAddress}|${endpoint.port}`;
+}
+function carriesMedia(endpoint) {
+  return endpoint.carriesMedia !== false;
+}
+function selectMulticastTier(endpoints, estimate) {
+  const media = endpoints.filter(carriesMedia);
+  if (media.length <= 1)
+    return media[0];
+  const ranked = media.filter((endpoint) => typeof endpoint.bandwidth === "number" && endpoint.bandwidth > 0).sort((a, b) => a.bandwidth - b.bandwidth);
+  if (ranked.length < 2)
+    return media[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 = Object.freeze([
+  { 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 }
+].map((level) => Object.freeze(level)));
+function positiveFinite(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function validateQualityLadder(ladder) {
+  if (!Array.isArray(ladder) || ladder.length === 0) {
+    throw new TypeError("[ABR] ladder must list at least one rendition (e.g. the catalog's video tracks)");
+  }
+  const names = /* @__PURE__ */ new Set();
+  for (const level of ladder) {
+    if (typeof level?.name !== "string" || level.name.length === 0) {
+      throw new TypeError("[ABR] every ladder rendition needs a name");
+    }
+    if (!positiveFinite(level.bitrate)) {
+      throw new RangeError(`[ABR] rendition ${level.name}: bitrate must be a positive finite number, got ${String(level.bitrate)}`);
+    }
+    for (const field of ["width", "height", "fps"]) {
+      if (level[field] !== void 0 && !positiveFinite(level[field])) {
+        throw new RangeError(`[ABR] rendition ${level.name}: ${field} must be a positive finite number when stated, got ${String(level[field])}`);
+      }
+    }
+    if (names.has(level.name))
+      throw new RangeError(`[ABR] rendition ${level.name} appears twice in the ladder`);
+    names.add(level.name);
+  }
+  return Object.freeze([...ladder].sort((a, b) => a.bitrate - b.bitrate).map((level) => Object.freeze({ ...level })));
+}
+var AdaptiveBitrateController = class {
+  /** The caller's renditions, ascending by bitrate (`validateQualityLadder`). */
+  ladder;
+  currentQualityIndex;
+  history = [];
+  historyWindow = 1e4;
+  // 10 second window
+  upgradeThreshold = 0.8;
+  // 80% of target bitrate sustained
+  downgradeThreshold = 0.5;
+  // 50% of target bitrate triggers downgrade
+  stabilityPeriod = 5e3;
+  // Wait 5s before upgrading
+  lastQualityChange = 0;
+  onQualityChange;
+  // FEC stats for effective loss rate calculation
+  fecStats = {
+    rawLossRate: 0,
+    effectiveLossRate: 0,
+    recoveryRate: 1,
+    fecEnabled: false
+  };
+  constructor(options) {
+    if (!options || typeof options !== "object") {
+      throw new TypeError("[ABR] AdaptiveBitrateController needs { ladder, initialQuality }");
+    }
+    this.ladder = validateQualityLadder(options.ladder);
+    this.currentQualityIndex = options.initialQuality === void 0 ? 0 : this.ladder.findIndex((q) => q.name === options.initialQuality);
+    if (this.currentQualityIndex < 0) {
+      throw new RangeError(`[ABR] initial rendition ${String(options.initialQuality)} is not in the ladder`);
+    }
+  }
+  setCallback(callback) {
+    this.onQualityChange = callback;
+  }
+  getCurrentQuality() {
+    return this.ladder[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 < this.ladder.length - 1) {
+      this.upgrade();
+    }
+  }
+  /**
+   * Update FEC statistics for ABR decisions
+   *
+   * ABR uses the effective loss rate (after FEC recovery) rather than the
+   * 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 >= this.ladder.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);
+  }
+  /**
+   * Select a ladder rendition: the caller switched to it (a manual override,
+   * or a switch the caller made). Throws for a name the ladder does not carry.
+   */
+  setQuality(name) {
+    const index = this.ladder.findIndex((q) => q.name === name);
+    if (index < 0)
+      throw new RangeError(`[ABR] rendition ${name} is not in the ladder`);
+    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-base/dist/mmtp.js
+var MPU_HEADER_SIZE2 = 8;
+var MPU_LENGTH_FIELD_SIZE2 = 2;
+var MPU_HEADER_REMAINDER_SIZE2 = MPU_HEADER_SIZE2 - MPU_LENGTH_FIELD_SIZE2;
+var MMTP_SIGNALING_PACKET_ID2 = 0;
+var MMTP_PACKET_ID_MAX = 65535;
+
+// node_modules/@blockcast/mmt-base/dist/net-constants.js
+var DEFAULT_AMT_RELAY_PORT = 2268;
+
+// node_modules/@blockcast/mmt-base/dist/ntp-short.js
+var NTP_SHORT_BITS2 = 32;
+var NTP_SHORT_MODULUS2 = 2 ** NTP_SHORT_BITS2;
+var NTP_SHORT_HALF_RANGE2 = 2 ** (NTP_SHORT_BITS2 - 1);
+function isNtpShort(value) {
+  return Number.isInteger(value) && value >= 0 && value < NTP_SHORT_MODULUS2;
+}
+function compareNtpShort(a, b) {
+  if (!isNtpShort(a) || !isNtpShort(b)) {
+    throw new RangeError(`NTP-short values must be integers in [0, 2^${NTP_SHORT_BITS2}), got ${String(a)} and ${String(b)}`);
+  }
+  if (a === b)
+    return "equal";
+  const forward = (a - b + NTP_SHORT_MODULUS2) % NTP_SHORT_MODULUS2;
+  if (forward < NTP_SHORT_HALF_RANGE2)
+    return "after";
+  if (forward > NTP_SHORT_HALF_RANGE2)
+    return "before";
+  return "unordered";
+}
+
+// node_modules/@blockcast/mmt-base/dist/fec-block-profile.js
+var FEC_BLOCK_PROFILES2 = Object.freeze([
+  "iso-ssbg1-v1"
+]);
+
+// node_modules/@blockcast/mmt-base/dist/fec-bindings.js
+var RUNTIME_FEC_RECEIVER2 = Object.freeze({
+  schemes: Object.freeze(["raptorq", "reed-solomon"]),
+  blockProfiles: Object.freeze(["iso-ssbg1-v1"]),
+  overlays: true
+});
+
+// node_modules/@blockcast/mmt-transport/dist/multicast-orchestrator.js
+var DEFAULT_DWELL_MS = 3e3;
+var DEFAULT_JOIN_DEADLINE_MS = 5e3;
+var MulticastOrchestrator = class {
+  options;
+  #state = "stable";
+  #current;
+  #target;
+  #estimate;
+  #favored;
+  #joinStartedAt = 0;
+  /**
+   * Latest active-tier send time (NTP short), or undefined before the first.
+   * "Latest" is serial order, not the numerically largest value: after the
+   * field wraps, the largest value is the stale one.
+   */
+  #highWater;
+  #dwellMs;
+  #joinDeadlineMs;
+  constructor(options) {
+    this.options = options;
+    this.#dwellMs = options.dwellMs ?? DEFAULT_DWELL_MS;
+    this.#joinDeadlineMs = options.joinDeadlineMs ?? DEFAULT_JOIN_DEADLINE_MS;
+    if (!Number.isFinite(this.#dwellMs) || !Number.isFinite(this.#joinDeadlineMs) || this.#dwellMs <= 0 || this.#joinDeadlineMs <= 0) {
+      throw new Error("Multicast dwell and join deadline must be positive");
+    }
+  }
+  get state() {
+    return this.#state;
+  }
+  get current() {
+    return this.#current;
+  }
+  get target() {
+    return this.#target;
+  }
+  get estimate() {
+    return this.#estimate;
+  }
+  start() {
+    this.#current ??= this.options.initialEndpoint ?? selectMulticastTier(this.options.endpoints, void 0);
+    return this.#current;
+  }
+  onGoodput(sample) {
+    const bitrate = sample.bitrate;
+    if (!this.#current)
+      return void 0;
+    if (this.#state === "joining")
+      return this.poll();
+    if (this.options.adaptive === false)
+      return void 0;
+    if (bitrate === void 0 || !Number.isFinite(bitrate))
+      return void 0;
+    this.#estimate = bitrate;
+    const desired = selectMulticastTier(this.options.endpoints, bitrate);
+    if (!desired)
+      return void 0;
+    const desiredKey = endpointKey(desired);
+    if (desiredKey === endpointKey(this.#current)) {
+      if (this.#favored?.source === "goodput")
+        this.#favored = void 0;
+      return void 0;
+    }
+    if (typeof desired.bandwidth !== "number" || typeof this.#current.bandwidth !== "number" || desired.bandwidth >= this.#current.bandwidth) {
+      if (this.#favored?.source === "goodput")
+        this.#favored = void 0;
+      return void 0;
+    }
+    const now = this.#now();
+    if (!this.#favored || this.#favored.key !== desiredKey || this.#favored.source !== "goodput") {
+      this.#favored = { key: desiredKey, since: now, source: "goodput" };
+      return void 0;
+    }
+    if (now - this.#favored.since < this.#dwellMs)
+      return void 0;
+    this.#state = "joining";
+    this.#target = desired;
+    this.#joinStartedAt = now;
+    this.#favored = void 0;
+    return { kind: "join-target", current: this.#current, target: desired };
+  }
+  onHeadroom(sample) {
+    if (!this.#current || this.options.adaptive === false || this.#state === "joining")
+      return void 0;
+    if (!sample.healthy) {
+      if (this.#favored?.source === "headroom")
+        this.#favored = void 0;
+      return void 0;
+    }
+    if (this.#favored?.source === "goodput")
+      return void 0;
+    const currentBandwidth = this.#current.bandwidth;
+    if (typeof currentBandwidth !== "number")
+      return void 0;
+    const desired = this.options.endpoints.filter((endpoint) => carriesMedia(endpoint) && typeof endpoint.bandwidth === "number" && endpoint.bandwidth > currentBandwidth).sort((a, b) => a.bandwidth - b.bandwidth)[0];
+    if (!desired) {
+      this.#favored = void 0;
+      return void 0;
+    }
+    const desiredKey = endpointKey(desired);
+    if (desiredKey === endpointKey(this.#current)) {
+      this.#favored = void 0;
+      return void 0;
+    }
+    const now = this.#now();
+    if (!this.#favored || this.#favored.key !== desiredKey) {
+      this.#favored = { key: desiredKey, since: now, source: "headroom" };
+      return void 0;
+    }
+    if (now - this.#favored.since < this.#dwellMs)
+      return void 0;
+    this.#state = "joining";
+    this.#target = desired;
+    this.#joinStartedAt = now;
+    this.#favored = void 0;
+    return { kind: "join-target", current: this.#current, target: desired };
+  }
+  /**
+   * Join `target` because the viewer selected it, not because goodput or
+   * headroom ranked it. It runs whether or not the orchestrator adapts, and
+   * takes the path an adaptive join takes: commit on the target's RAP at or
+   * beyond the high-water mark, abandon at the join deadline. While it is
+   * pending nothing re-ranks the ladder; goodput only advances the deadline.
+   *
+   * Returns undefined, changing nothing, while another join is pending (cancel
+   * it first), when `target` is the current tier, or when it carries no media.
+   */
+  select(target) {
+    if (!this.#current || this.#state === "joining" || !carriesMedia(target))
+      return void 0;
+    if (endpointKey(target) === endpointKey(this.#current))
+      return void 0;
+    this.#state = "joining";
+    this.#target = target;
+    this.#joinStartedAt = this.#now();
+    this.#favored = void 0;
+    return { kind: "join-target", current: this.#current, target };
+  }
+  /**
+   * Feed a packet from the active tier (to advance the high-water mark) or
+   * from the in-flight target (to find a committable RAP).
+   *
+   * Serial order is only the true order while the compared instants are less
+   * than `NTP_SHORT_HALF_RANGE` (2^15 s, ~9.1 h) apart. Feeding every
+   * active-tier packet keeps the mark that close to the live stream. A mark
+   * refreshed only by commits can fall further behind than that, and a
+   * target RAP may then compare as older, so the join is abandoned.
+   */
+  onTierPacket(packet) {
+    if (!this.#current)
+      return void 0;
+    const sentAt = tierPacketSendTime(packet);
+    if (packet.endpointKey === endpointKey(this.#current) && sentAt !== void 0 && (this.#highWater === void 0 || compareNtpShort(sentAt, this.#highWater) === "after")) {
+      this.#highWater = sentAt;
+    }
+    if (this.#state !== "joining" || !this.#target)
+      return void 0;
+    const expired = this.poll();
+    if (expired)
+      return expired;
+    if (packet.endpointKey !== endpointKey(this.#target) || !packet.keyframe || !packet.hasValidCodecConfig || sentAt === void 0 || !this.#reachesHighWater(sentAt))
+      return void 0;
+    const command = {
+      kind: "commit-swap",
+      target: this.#target,
+      old: this.#current
+    };
+    this.#highWater = sentAt;
+    this.#current = this.#target;
+    this.#target = void 0;
+    this.#state = "stable";
+    return command;
+  }
+  poll() {
+    if (this.#state !== "joining" || !this.#target || !this.#current)
+      return void 0;
+    if (this.#now() - this.#joinStartedAt < this.#joinDeadlineMs)
+      return void 0;
+    return this.cancel();
+  }
+  cancel() {
+    if (this.#state !== "joining" || !this.#target || !this.#current)
+      return void 0;
+    const command = {
+      kind: "abandon-join",
+      current: this.#current,
+      target: this.#target
+    };
+    this.#target = void 0;
+    this.#state = "stable";
+    return command;
+  }
+  /**
+   * Whether a target RAP sent at `sentAt` is at or beyond the active tier's
+   * high-water mark. A pair exactly half the NTP-short space apart has no
+   * serial order, so it cannot show that and does not commit.
+   */
+  #reachesHighWater(sentAt) {
+    if (this.#highWater === void 0)
+      return true;
+    const order = compareNtpShort(sentAt, this.#highWater);
+    return order === "after" || order === "equal";
+  }
+  #now() {
+    const now = this.options.now();
+    if (!Number.isFinite(now))
+      throw new Error("Multicast orchestrator clock must be finite");
+    return now;
+  }
+};
+function tierPacketSendTime(packet) {
+  if (!Number.isFinite(packet.timestamp))
+    return void 0;
+  if (!isNtpShort(packet.timestamp)) {
+    throw new RangeError(`Multicast tier packet timestamp must be an MMTP NTP-short send time, got ${packet.timestamp}`);
+  }
+  return packet.timestamp;
+}
+
+// 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)}`);
+  }
+  if (input.packetIds !== void 0 && !Array.isArray(input.packetIds)) {
+    throw new TypeError(`multicast packetIds must be an array, got ${input.packetIds === null ? "null" : typeof input.packetIds}`);
+  }
+  if (input.packetIds?.some((id) => !isMulticastTrackPacketId(id)) || input.tracks?.some((track) => !isMulticastTrackPacketId(track.packetId))) {
+    throw new RangeError(`multicast packetId must be an integer from 1 to ${MMTP_PACKET_ID_MAX}; packetId 0 is the MMTP signaling flow and is never a track's`);
+  }
+  const source = input.source?.trim() || void 0;
+  const senderAddress = input.senderAddress?.trim() || void 0;
+  if (source && senderAddress) {
+    throw new TypeError("multicast senderAddress is an ASM filter and never appears beside source");
+  }
+  const base = {
+    group: input.group,
+    port: input.port,
+    ...source ? { source } : {},
+    consume: "bytes",
+    ...input.packetIds?.length ? { packetIds: [...input.packetIds] } : {}
+  };
+  const filter = senderAddress ? { senderAddress } : {};
+  if (input.atsc3) {
+    if (senderAddress)
+      throw new TypeError("an ATSC3 tuner request carries no senderAddress");
+    const { frequency, plpId, serviceId } = input.atsc3;
+    if (!Number.isInteger(frequency) || frequency < 1) {
+      throw new TypeError(`ATSC3 tuning requires a positive integer frequency in kHz, got ${String(frequency)}`);
+    }
+    return {
+      ...base,
+      origin: "tuner",
+      standard: "atsc3",
+      frequency,
+      ...plpId !== void 0 ? { plpId } : {},
+      ...serviceId !== void 0 ? { serviceId } : {}
+    };
+  }
+  const relay = input.amtRelay?.trim();
+  const driad = !relay && input.amtDiscovery === "driad";
+  const wantsAmt = input.mode === "tunnel" || input.mode !== "native" && (relay !== void 0 && relay !== "" || driad);
+  if (!wantsAmt) {
+    const native = {
+      ...base,
+      ...filter,
+      origin: "ip-multicast",
+      ...input.tracks?.length ? { tracks: input.tracks.map(({ name, packetId }) => ({ name, packetId })) } : {}
+    };
+    return native;
+  }
+  const relayPort = input.amtRelayPort;
+  if (driad) {
+    if (!base.source)
+      throw new TypeError("AMT DRIAD discovery requires a source address");
+    if (relayPort !== void 0 && !isPositivePort(relayPort)) {
+      throw new TypeError("AMT DRIAD discovery requires a valid relay port when one is given");
+    }
+    return {
+      ...base,
+      source: base.source,
+      origin: "amt",
+      discovery: "driad",
+      ...relayPort !== void 0 ? { relayPort } : {}
+    };
+  }
+  if (!relay || relayPort === void 0 || !isPositivePort(relayPort)) {
+    throw new TypeError("AMT requires a resolved relay and a valid relay port");
+  }
+  return {
+    ...base,
+    ...filter,
+    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 senderAddress = endpoint.senderAddress?.trim().toLowerCase() || void 0;
+  if (sourceAddress && senderAddress)
+    return 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 } : {},
+    ...senderAddress ? { senderAddress } : {},
+    port: endpoint.port,
+    ...endpoint.mode ? { mode: endpoint.mode } : {},
+    ...amtRelay ? { amtRelay } : {},
+    ...endpoint.amtRelayPort ? { amtRelayPort: endpoint.amtRelayPort } : {},
+    ...endpoint.amtDiscovery === "driad" ? { amtDiscovery: "driad" } : {}
+  };
+}
+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 ?? "",
+    // A DRIAD join is a different gateway subscription from a native one.
+    ...normalized.amtDiscovery ? [normalized.amtDiscovery] : [],
+    // An ASM sender filter is a different subscription from the unfiltered join.
+    ...normalized.senderAddress ? [{ senderAddress: normalized.senderAddress }] : []
+  ]);
+}
+function isMulticastTrackPacketId(value) {
+  return Number.isInteger(value) && value > MMTP_SIGNALING_PACKET_ID2 && value <= MMTP_PACKET_ID_MAX;
+}
+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/packet-batch.js
+function subscriptionDeliversPacketBatches(subscription) {
+  return subscription.eventTypes?.includes("packets") === true;
+}
+
+// node_modules/@blockcast/mmt-transport/dist/multicast-subscription-pool.js
+var MulticastSubscriptionPool = class {
+  #entries = /* @__PURE__ */ new Map();
+  #gatewayIds = /* @__PURE__ */ new WeakMap();
+  #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,
+      amtDiscovery: config.amtDiscovery
+    });
+    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 = `${this.#gatewayId(gateway)}|${key}`;
+    let record = this.#entries.get(internalKey);
+    if (!record) {
+      record = { claims: 0, entry: Promise.resolve(null) };
+      const createdRecord = record;
+      record.entry = this.#createEntry(gateway, endpoint, (entry2) => {
+        if (this.#entries.get(internalKey) === createdRecord)
+          this.#entries.delete(internalKey);
+        this.#detach(entry2);
+      }).catch((error) => {
+        if (this.#entries.get(internalKey) === createdRecord)
+          this.#entries.delete(internalKey);
+        throw error;
+      });
+      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 (this.#entries.get(internalKey) === record)
+          this.#entries.delete(internalKey);
+        this.#detach(entry);
+        if (!entry.closed)
+          await entry.subscription.unsubscribe();
+      }
+    };
+  }
+  get size() {
+    return this.#entries.size;
+  }
+  async #createEntry(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 } : {},
+      ...endpoint.amtDiscovery ? { amtDiscovery: endpoint.amtDiscovery } : {}
+    }));
+    const consumers = /* @__PURE__ */ new Map();
+    let entry;
+    const packetListener = subscriptionDeliversPacketBatches(subscription) ? {
+      type: "packets",
+      listener: (event) => {
+        for (const data of event.detail) {
+          this.#dispatch(consumers, (consumer) => consumer.onBytes(data));
+        }
+      }
+    } : {
+      type: "bytes",
+      listener: (event) => {
+        this.#dispatch(consumers, (consumer) => consumer.onBytes(event.detail));
+      }
+    };
+    const stateListener = (event) => {
+      this.#dispatch(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));
+      this.#dispatch(consumers, (consumer) => consumer.onError?.(error));
+    };
+    entry = { subscription, consumers, packetListener, stateListener, errorListener, closed: false };
+    if (packetListener.type === "packets") {
+      subscription.addEventListener("packets", packetListener.listener);
+    } else {
+      subscription.addEventListener("bytes", packetListener.listener);
+    }
+    subscription.addEventListener("state", stateListener);
+    subscription.addEventListener("error", errorListener);
+    return entry;
+  }
+  #gatewayId(gateway) {
+    const object = gateway;
+    let id = this.#gatewayIds.get(object);
+    if (!id) {
+      id = this.#nextGatewayId++;
+      this.#gatewayIds.set(object, id);
+    }
+    return id;
+  }
+  #detach(entry) {
+    const { packetListener } = entry;
+    if (packetListener.type === "packets") {
+      entry.subscription.removeEventListener("packets", packetListener.listener);
+    } else {
+      entry.subscription.removeEventListener("bytes", packetListener.listener);
+    }
+    entry.subscription.removeEventListener("state", entry.stateListener);
+    entry.subscription.removeEventListener("error", entry.errorListener);
+  }
+  #dispatch(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 {
+  state = {
+    mode: "disconnected",
+    connected: false,
+    packetsReceived: 0,
+    bytesReceived: 0,
+    lastPacketTime: 0
+  };
+  capabilities = null;
+  subscription = null;
+  /** Built by `connect()` from the caller's ladder; there is no built-in one. */
+  abr = null;
+  multicastOrchestrator = null;
+  onOrchestratorCommand;
+  connectionGeneration = 0;
+  onPacket;
+  onError;
+  onStateChange;
+  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: hasGatewayBytes,
+      // the gateway runs RFC 8777 discovery
+      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: a configured relay via the AMT proxy, else gateway DRIAD discovery
+   * 3. MOQ WebTransport (final fallback)
+   *
+   * The ABR ladder (`abrLadder`) and initial rendition (`initialQuality`)
+   * are checked first, before anything is torn down. A config that fails is
+   * refused with the same shape as an invalid endpoint, the error to the
+   * error callback and `false` resolved; unlike one, it is caught before the
+   * live subscription closes, so a refused reconnect leaves that subscription,
+   * its state and any connect already in flight untouched.
+   */
+  async connect(config) {
+    let abr;
+    try {
+      abr = new AdaptiveBitrateController({
+        ladder: config.abrLadder,
+        initialQuality: config.initialQuality?.name
+      });
+    } catch (error) {
+      const refused = error instanceof Error ? error : new Error(String(error));
+      if (this.onError)
+        this.onError(refused);
+      else
+        console.error("[Transport] ABR config refused, not connecting:", refused);
+      return false;
+    }
+    const generation = ++this.connectionGeneration;
+    this.subscription?.close();
+    this.subscription = null;
+    this.abr = 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;
+    this.abr = abr;
+    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, mode = "multicast") {
+    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,
+        connected: true,
+        group: config.group,
+        source: config.source,
+        quality: this.requireAbr().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: a configured relay goes through the AMT proxy; with no
+   * relay, the window.multicast gateway discovers one per RFC 8777 (DRIAD).
+   */
+  async connectAmt(config, generation) {
+    try {
+      if (config.amtRelay)
+        return await this.connectAmtProxy(config, config.amtRelay, generation);
+      if (config.driadEnabled === false || !config.source || config.mode === "native") {
+        console.warn("[Transport] No AMT relay available (DRIAD requires source address for SSM)");
+        return false;
+      }
+      console.log(`[Transport] Asking the gateway for a DRIAD relay for source ${config.source}...`);
+      return await this.connectWindowMulticast({ ...config, amtDiscovery: "driad" }, generation, "amt");
+    } 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 wsUrl = new URL(`wss://${relayHost}/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.requireAbr().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 };
+  }
+  /**
+   * The rung of the live connection's `abrLadder` ABR is on; `null` when
+   * there is no ladder (before `connect(config)` succeeds, after
+   * `disconnect()`, or after a reconnect that was torn down and bailed).
+   */
+  getQuality() {
+    return this.abr?.getCurrentQuality() ?? null;
+  }
+  /**
+   * Force the rung named `name` of the live connection's `abrLadder`.
+   * Throws `Error` when there is no ladder (see `getQuality()`), and
+   * `RangeError` when the ladder has no rung of that name; it never falls
+   * back to another rung.
+   */
+  setQuality(name) {
+    this.requireAbr().setQuality(name);
+  }
+  /** The controller `connect()` built; before it there is no ladder to adapt over. */
+  requireAbr() {
+    if (!this.abr)
+      throw new Error("[Transport] ABR has no ladder before connect(config)");
+    return this.abr;
+  }
+  /** 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());
+  }
+  /** Abandon the in-flight tier join, e.g. because the host could not join the target. */
+  cancelMulticastTierJoin() {
+    return this.dispatchOrchestratorCommand(this.multicastOrchestrator?.cancel());
+  }
+  /**
+   * 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.abr = 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/multicast-receiver-gateway.js
+var USER_AGENT_VERIFIED = /* @__PURE__ */ Symbol.for("@blockcast/mmt-transport/user-agent-verified/v1");
+
+// 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),
+  /**
+   * @deprecated A repair FETCH's SUBSCRIBER_PRIORITY is derived per request
+   * from the catalog source and repair priorities (draft-ramadan-moq-fec
+   * §11.4.5), not a player constant. Use the `subscriberPriority` that
+   * `@blockcast/mmt-container`'s `wireRepairFetch` puts on each
+   * `RepairFetchRequest` (`repairFetchSubscriberPriority`).
+   */
+  deadlineRepair: moqtSubscriberPriority(0),
+  audio: moqtSubscriberPriority(1),
+  video: moqtSubscriberPriority(2),
+  /**
+   * @deprecated See `deadlineRepair`: use the request's catalog-derived
+   * `RepairFetchRequest.subscriberPriority` (draft-ramadan-moq-fec §11.4.5).
+   */
+  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 MAX_PENDING_PACKETS = 256;
+var AMTGatewayManager = class {
+  subscriptions = /* @__PURE__ */ new Map();
+  messageHandler;
+  messageListenerRegistered = false;
+  pendingPackets = /* @__PURE__ */ new Map();
+  constructor() {
+    this.messageHandler = (event) => {
+      const data = event.data;
+      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}`);
+      }
+    };
+  }
+  ensureMessageListener() {
+    if (this.messageListenerRegistered || typeof navigator === "undefined" || !navigator.serviceWorker || !this.messageHandler) {
+      return;
+    }
+    navigator.serviceWorker.addEventListener("message", this.messageHandler);
+    this.messageListenerRegistered = true;
+    console.log("[AMT] Registered service worker message handler");
+  }
+  removeMessageListener() {
+    if (!this.messageListenerRegistered)
+      return;
+    if (this.messageHandler && typeof navigator !== "undefined" && navigator.serviceWorker) {
+      navigator.serviceWorker.removeEventListener("message", this.messageHandler);
+    }
+    this.messageListenerRegistered = false;
+  }
+  /**
+   * Subscribe via AMT tunnel
+   */
+  async subscribe(config) {
+    const { key } = config;
+    if (config.protected) {
+      throw new Error("AMTGatewayManager refuses a protected join: it reports no per-datagram sender (multicast-02 7.2.7)");
+    }
+    this.ensureMessageListener();
+    const keyStr = this.getKeyString(key);
+    if (this.subscriptions.has(keyStr)) {
+      console.log(`[AMT] Reusing existing subscription to ${keyStr}`);
+      return keyStr;
+    }
+    try {
+      const relayAddress = config.relayAddress;
+      const relayPort = config.relayPort || DEFAULT_AMT_RELAY_PORT;
+      if (!relayAddress) {
+        throw new Error(`AMT relay address required: this manager does no relay discovery. For RFC 8777 DRIAD discovery, join through window.multicast with amtDiscovery: "driad".`);
+      }
+      console.log(`[AMT] Using configured relay ${relayAddress}:${relayPort}`);
+      const subscriptionId = keyStr;
+      this.pendingPackets.set(subscriptionId, []);
+      const subscription = {
+        key,
+        subscriptionId,
+        config,
+        handshakeComplete: false,
+        relay: {
+          address: relayAddress,
+          port: relayPort,
+          discoveryMethod: "manual",
+          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);
+      }
+      if (this.subscriptions.size === 0)
+        this.removeMessageListener();
+      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);
+      if (this.subscriptions.size === 0)
+        this.removeMessageListener();
+    }
+  }
+  /**
+   * 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)
+      return;
+    if (!subscription.handshakeComplete) {
+      const queue = this.pendingPackets.get(subscriptionId);
+      const packetData2 = data;
+      if (queue && queue.length < MAX_PENDING_PACKETS) {
+        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)
+      return;
+    subscription.config.onError(new Error(error || "Unknown error"));
+  }
+  /**
+   * Cleanup on destroy
+   */
+  destroy() {
+    this.removeMessageListener();
+    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/mfu-reassembler.ts
 function fragmentProvenance(fragment) {
   if (fragment.deliveryProvenance !== void 0) return fragment.deliveryProvenance;
@@ -6268,9 +7677,21 @@ var IsoBmffTimingResolver = class {
   }
   #track = null;
   #fragments = /* @__PURE__ */ new Map();
+  /** First sample of each pending fragment, kept in `#delivered` with its sample count. */
+  #firstSamples = /* @__PURE__ */ new Map();
+  /**
+   * First sample and sample count of the newest fragments whose every slot was
+   * cleared. Abandonment counts: `releaseSample` clears a slot too, which
+   * matches the combiner, since it retires an abandoned sample as well.
+   */
+  #delivered = /* @__PURE__ */ new Map();
   #pendingSamples = 0;
   #evictedSamples = 0;
   #lastMovieFragmentRejection = null;
+  /** True once an FT=0 has bound the track that FT=1 timing is read against. */
+  get initialized() {
+    return this.#track !== null;
+  }
   get pendingSampleCount() {
     return this.#pendingSamples;
   }
@@ -6294,7 +7715,14 @@ var IsoBmffTimingResolver = class {
     this.#track = timing;
     return true;
   }
-  addMovieFragment(mpuSequenceNumber, data, additionalSampleLimit = this.maxPendingSamples) {
+  /**
+   * `recovered` marks an FEC-recovered copy. A recovered block hands back
+   * every FT=1 it holds, the received ones included, so a recovered copy of a
+   * fragment whose samples are all done is a duplicate: admitting it again
+   * would charge stale timing and could displace the live MPU's. A source
+   * copy is still admitted again (a rendition switch re-arms timing that way).
+   */
+  addMovieFragment(mpuSequenceNumber, data, additionalSampleLimit = this.maxPendingSamples, recovered = false) {
     this.#lastMovieFragmentRejection = null;
     if (!Number.isInteger(additionalSampleLimit) || additionalSampleLimit < 0) {
       this.#lastMovieFragmentRejection = "invalid";
@@ -6320,6 +7748,8 @@ var IsoBmffTimingResolver = class {
         (sample, index) => sample !== null && sameSample(sample, parsed.samples[index])
       );
     }
+    const delivered = recovered ? this.#delivered.get(key) : void 0;
+    if (delivered && delivered.sampleCount === parsed.samples.length && sameSample(delivered.first, parsed.samples[0])) return true;
     let freed = 0;
     while (this.#fragments.size > 0 && (this.#pendingSamples + parsed.samples.length > this.maxPendingSamples || parsed.samples.length - freed > additionalSampleLimit)) {
       freed += this.#evictOldestFragment();
@@ -6333,6 +7763,7 @@ var IsoBmffTimingResolver = class {
       return false;
     }
     this.#fragments.set(key, [...parsed.samples]);
+    this.#firstSamples.set(key, parsed.samples[0]);
     this.#pendingSamples += parsed.samples.length;
     return true;
   }
@@ -6390,6 +7821,7 @@ var IsoBmffTimingResolver = class {
     let live = 0;
     for (const sample of samples) if (sample !== null) live++;
     this.#fragments.delete(oldest);
+    this.#firstSamples.delete(oldest);
     this.#pendingSamples -= live;
     this.#evictedSamples += live;
     return live;
@@ -6405,12 +7837,23 @@ var IsoBmffTimingResolver = class {
     if (!samples || !samples[index]) return false;
     samples[index] = null;
     this.#pendingSamples--;
-    if (samples.every((value) => value === null)) this.#fragments.delete(key);
+    if (samples.every((value) => value === null)) {
+      this.#fragments.delete(key);
+      const first = this.#firstSamples.get(key);
+      this.#firstSamples.delete(key);
+      this.#delivered.delete(key);
+      this.#delivered.set(key, { first, sampleCount: samples.length });
+      if (this.#delivered.size > this.maxPendingSamples) {
+        this.#delivered.delete(this.#delivered.keys().next().value);
+      }
+    }
     return true;
   }
   reset() {
     this.#track = null;
     this.#fragments.clear();
+    this.#firstSamples.clear();
+    this.#delivered.clear();
     this.#pendingSamples = 0;
   }
 };
@@ -6892,6 +8335,12 @@ var MmtpContainerParser = class _MmtpContainerParser {
     this.#reclaimedTimingSamples = 0;
     this.#evictedTimingSamples = 0;
     this.#rejectedMovieFragments = 0;
+    this.#recoveredHeadsAwaitingTiming = {
+      held: 0,
+      expired: 0,
+      discarded: 0,
+      superseded: 0
+    };
     this.#sequencers = /* @__PURE__ */ new Map();
     this.#fecGate = null;
     this.#fecSequencer = null;
@@ -7000,6 +8449,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
   #reclaimedTimingSamples;
   #evictedTimingSamples;
   #rejectedMovieFragments;
+  #recoveredHeadsAwaitingTiming;
   #sequencers;
   #fecGate;
   #fecSequencer;
@@ -7120,6 +8570,14 @@ var MmtpContainerParser = class _MmtpContainerParser {
       rejectedMovieFragments: this.#rejectedMovieFragments
     };
   }
+  /** Recovered heads parked for FT=1 timing (BLO-53369). Survives dispose(). */
+  get recoveredHeadsAwaitingTiming() {
+    let pending = 0;
+    for (const { awaitingTiming } of this.#timingStreams.values()) {
+      for (const head of awaitingTiming) if (head.options?.recovered) pending++;
+    }
+    return { ...this.#recoveredHeadsAwaitingTiming, pending };
+  }
   get reorderStats() {
     let bufferedFrames = this.#fecSequencer?.buffered ?? 0;
     for (const { sequencer } of this.#sequencers.values()) bufferedFrames += sequencer.buffered;
@@ -7293,7 +8751,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
     const now = Date.now();
     for (const { awaitingTiming } of this.#timingStreams.values()) {
       while (awaitingTiming.length > 0 && now - awaitingTiming[0].arrivedAt > timeoutMs) {
-        awaitingTiming.shift();
+        this.#leaveAwaitingTiming(awaitingTiming.shift(), "expired");
       }
     }
   }
@@ -7411,11 +8869,16 @@ var MmtpContainerParser = class _MmtpContainerParser {
       if (mpu.fragmentationIndicator !== 0 || mpu.fragmentCounter !== 0)
         return this.#drop("fragment-unexpected-fragmentation");
       const resolver2 = this.#timingResolver(streamKey, info.packetId, false);
-      if (!resolver2) return this.#drop("fragment-no-resolver");
+      if (!resolver2?.initialized) return this.#drop("fragment-no-resolver");
       const pendingBefore = resolver2.pendingSampleCount;
       const evictedBefore = resolver2.evictedSampleCount;
       const remaining = this.#maxPendingTimingSamples - this.#pendingTimingSamples;
-      const admitted = resolver2.addMovieFragment(mpu.mpuSequenceNumber, data, remaining);
+      const admitted = resolver2.addMovieFragment(
+        mpu.mpuSequenceNumber,
+        data,
+        remaining,
+        options?.recovered === true
+      );
       this.#pendingTimingSamples += resolver2.pendingSampleCount - pendingBefore;
       this.#evictedTimingSamples += resolver2.evictedSampleCount - evictedBefore;
       if (!admitted) {
@@ -7435,7 +8898,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
       };
     }
     if (fragmentType !== 2) return this.#drop("unknown-fragment-type");
-    const resolver = this.#timingResolver(streamKey, info.packetId, false);
+    const resolver = this.#timingResolver(streamKey, info.packetId, true);
     if (!resolver) return this.#drop("mfu-no-resolver");
     if (!Number.isSafeInteger(data.byteLength) || data.byteLength <= 0)
       return this.#drop("mfu-empty-payload");
@@ -7456,6 +8919,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
           mpuSequenceNumber: mpu.mpuSequenceNumber,
           movieFragmentSequenceNumber: mfuDuHeader.movieFragmentSequenceNumber,
           sampleNumber: mfuDuHeader.sampleNumber,
+          sequenceNumber: info.sequenceNumber,
           arrivedAt: Date.now()
         });
         return this.#drop("mfu-sample-timing-missing");
@@ -7779,6 +9243,10 @@ var MmtpContainerParser = class _MmtpContainerParser {
     }
     this.#emitFrame(data, meta);
   }
+  /** Whether FT=1 metadata already names this sample, without claiming it. */
+  hasAuthoredTimingFor(packetId, mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber, catalogTrackName) {
+    return this.#timingResolver(this.#streamKey(packetId, catalogTrackName), packetId, false)?.sampleTiming(mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber) != null;
+  }
   /**
    * Claim and return the authored timing for a recovered sample. Recovery does
    * not pass through the ordinary `feed()` completion path, so it must retire
@@ -7840,6 +9308,9 @@ var MmtpContainerParser = class _MmtpContainerParser {
     for (const { sequencer } of this.#sequencers.values()) sequencer.discard();
     this.#sequencers.clear();
     this.#fecSequencer?.discard();
+    for (const { awaitingTiming } of this.#timingStreams.values()) {
+      for (const head of awaitingTiming) this.#leaveAwaitingTiming(head, "discarded");
+    }
     this.#timingStreams.clear();
     this.#pendingTimingSamples = 0;
     this.#reliableMoqStartupGate.clear();
@@ -7858,10 +9329,23 @@ var MmtpContainerParser = class _MmtpContainerParser {
     return resolver;
   }
   #awaitTiming(streamKey, head) {
-    const awaitingTiming = this.#timingStreams.get(streamKey)?.awaitingTiming;
-    if (!awaitingTiming) return;
+    const state = this.#timingStreams.get(streamKey);
+    if (!state) return;
+    if (!head.options?.recovered) {
+      const kept = state.awaitingTiming.filter((queued) => !queued.options?.recovered || queued.sequenceNumber !== head.sequenceNumber);
+      this.#recoveredHeadsAwaitingTiming.superseded += state.awaitingTiming.length - kept.length;
+      state.awaitingTiming = kept;
+    }
+    const awaitingTiming = state.awaitingTiming;
     awaitingTiming.push(head);
-    if (awaitingTiming.length > MAX_AWAITING_TIMING_HEADS) awaitingTiming.shift();
+    if (head.options?.recovered) this.#recoveredHeadsAwaitingTiming.held++;
+    if (awaitingTiming.length > MAX_AWAITING_TIMING_HEADS) {
+      this.#leaveAwaitingTiming(awaitingTiming.shift(), "expired");
+    }
+  }
+  /** Count a recovered head leaving the queue other than by replay or its source copy. */
+  #leaveAwaitingTiming(head, outcome) {
+    if (head.options?.recovered) this.#recoveredHeadsAwaitingTiming[outcome]++;
   }
   /**
    * Feed again the heads whose timing the FT=1 just admitted declares. That
@@ -7889,6 +9373,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
     const state = this.#timingStreams.get(streamKey);
     if (!state) return;
     this.#timingStreams.delete(streamKey);
+    for (const head of state.awaitingTiming) this.#leaveAwaitingTiming(head, "discarded");
     this.#pendingTimingSamples -= state.resolver.pendingSampleCount;
     if (this.#pendingTimingSamples < 0) {
       throw new Error("[MmtpContainerParser] pending timing sample accounting underflow");
@@ -8183,7 +9668,7 @@ function decideGap(input) {
 
 // src/duplicate-ledger.ts
 var COUNT_BOUNDED_GENERATION = 2e3;
-function serial32Precedes2(a, b) {
+function serial32Precedes3(a, b) {
   const distance = b - a >>> 0;
   return distance !== 0 && distance < 2147483648;
 }
@@ -8359,12 +9844,12 @@ var StreamDuplicateLedgers = class {
   predatesHorizon(packetSequenceNumber, ssId) {
     if (this.#retentionMs === null) return false;
     const seqFloor = this.sourceSeqs.horizonFloor;
-    if (seqFloor !== void 0 && serial32Precedes2(packetSequenceNumber, seqFloor) && !this.sourceSeqs.has(packetSequenceNumber)) {
+    if (seqFloor !== void 0 && serial32Precedes3(packetSequenceNumber, seqFloor) && !this.sourceSeqs.has(packetSequenceNumber)) {
       return true;
     }
     if (ssId === void 0) return false;
     const ssIdFloor = this.parsedSymbols.horizonFloor;
-    return ssIdFloor !== void 0 && serial32Precedes2(ssId, ssIdFloor) && !this.parsedSymbols.has(ssId);
+    return ssIdFloor !== void 0 && serial32Precedes3(ssId, ssIdFloor) && !this.parsedSymbols.has(ssId);
   }
   /** Whether the stream keeps ledgers, for its FEC horizon or by count. */
   get retaining() {
@@ -8429,6 +9914,12 @@ function keyframeOverlaySsId(header) {
   if (ext?.type !== KEYFRAME_OVERLAY_EXTENSION_TYPE || ext.data.length !== 4) return void 0;
   return new DataView(ext.data.buffer, ext.data.byteOffset, 4).getUint32(0);
 }
+function overlayBaseSsId(anchor, overlaySsId, restoredPsn, headerPsn) {
+  if (anchor.baseSsId === void 0 || headerPsn !== restoredPsn) return void 0;
+  return serial32Add(anchor.baseSsId, overlaySsId - anchor.overlaySsId | 0);
+}
+var OVERLAY_ROUTED_LIMIT = 1024;
+var OVERLAY_PENDING_LIMIT = 256;
 var OVERLAY_OFFSET_MPUS = 16;
 var OVERLAY_MOQ_HORIZON_BLOCKS = 64;
 function assertStreamIdentity(role, stream) {
@@ -8665,7 +10156,9 @@ var MmtpRouter = class {
     recovered: 0,
     restarts: 0,
     unsequencedDropped: 0,
-    protectedDropped: 0
+    protectedDropped: 0,
+    baseFed: 0,
+    baseUndetermined: 0
   };
   /** Callback fired when a delta-track FEC block completes or fails. */
   #onDeltaBlockCompleteCb = null;
@@ -8838,7 +10331,7 @@ var MmtpRouter = class {
     const cb = this.#getFrameCallback(packetId);
     if (isVideo && !assembler) {
       if (frameMeta.recovered) {
-        this.#routeDirectRecoveredVideo(packetId, data, frameMeta, cb);
+        this.#routeDirectRecoveredVideo(packetId, data, frameMeta, cb, meta.fecSbn);
       } else {
         this.#routeDirectSourceVideo(packetId, data, frameMeta, cb);
       }
@@ -9228,6 +10721,10 @@ var MmtpRouter = class {
   get keyframeOverlayStats() {
     return { ...this.#overlayStats };
   }
+  /** Recovered FT=2 heads held for their FT=1, and how each left the wait (BLO-53369). */
+  get recoveredHeadsAwaitingTiming() {
+    return this.#parser.recoveredHeadsAwaitingTiming;
+  }
   #isOverlayRepair(repairPacketId, repairTrackName) {
     return this.#overlayLegs.has(repairPacketId) || repairTrackName !== void 0 && this.#overlayRepairNames.has(repairTrackName);
   }
@@ -9278,6 +10775,11 @@ var MmtpRouter = class {
    */
   resetKeyframeOverlays(sourcePacketId, catalogTrackName) {
     for (const inst of this.#overlaysForSource(sourcePacketId, catalogTrackName)) this.#resetOverlay(inst);
+    for (const [name, stream] of this.#streams.get(sourcePacketId) ?? []) {
+      if (catalogTrackName !== void 0 && name !== catalogTrackName) continue;
+      stream.overlayToBase.routed.clear();
+      stream.overlayToBase.pending.clear();
+    }
   }
   #resetOverlay(inst) {
     inst.fec.resetTrack(inst.repairPacketId, inst.streamName);
@@ -9334,9 +10836,10 @@ var MmtpRouter = class {
    * A source packet that carries a 0x8B01 overlay SS_ID is also a symbol of
    * every overlay installed for its source, at that SS_ID, with the bytes the
    * base protects: the packet minus its 4-byte SS_ID trailer, extension
-   * included (7.1, 7.4.3).
+   * included (7.1, 7.4.3). `baseSsId` is that trailer's SS_ID, when the base
+   * FEC reads it.
    */
-  #feedOverlaySource(packetId, catalogTrackName, packet, header, sequenceNumber, rapFlag, source) {
+  #feedOverlaySource(packetId, catalogTrackName, packet, header, sequenceNumber, rapFlag, source, baseSsId) {
     if (this.#overlays.size === 0) return;
     const ssId = keyframeOverlaySsId(header);
     if (ssId === void 0) return;
@@ -9345,7 +10848,11 @@ var MmtpRouter = class {
       const identity = MmtpContainerParser.sourcePacketIdentity(packet, header);
       if (identity !== null) {
         inst.offsets.delete(identity.mpuSequenceNumber);
-        inst.offsets.set(identity.mpuSequenceNumber, ssId - sequenceNumber >>> 0);
+        inst.offsets.set(identity.mpuSequenceNumber, {
+          psnOffset: ssId - sequenceNumber >>> 0,
+          overlaySsId: ssId,
+          ...baseSsId === void 0 ? {} : { baseSsId }
+        });
         if (inst.offsets.size > OVERLAY_OFFSET_MPUS) inst.offsets.delete(inst.offsets.keys().next().value);
       }
       const { fec, repairPacketId: pid, streamName: name } = inst;
@@ -9424,12 +10931,17 @@ var MmtpRouter = class {
     const streamKey = this.#mediaStreamKey(sourcePacketId, sourceName);
     const restamped = this.#restampedStreams.has(streamKey);
     const restored = /* @__PURE__ */ new Set();
+    const baseSsIds = /* @__PURE__ */ new Map();
     const symbols = result.symbols.flatMap((sym) => {
-      const offset = inst.offsets.get(sym.fragment.mpuSequenceNumber);
-      if (offset !== void 0) {
-        const packetSequenceNumber = serial32Add(blockStart, sym.index) - offset >>> 0;
+      const anchor = inst.offsets.get(sym.fragment.mpuSequenceNumber);
+      if (anchor !== void 0) {
+        const overlaySsId = serial32Add(blockStart, sym.index);
+        const packetSequenceNumber = overlaySsId - anchor.psnOffset >>> 0;
         restored.add(packetSequenceNumber);
-        return [{ ...sym, packetSequenceNumber }];
+        const out = { ...sym, packetSequenceNumber };
+        const baseSsId = overlayBaseSsId(anchor, overlaySsId, packetSequenceNumber, sym.packetSequenceNumber);
+        if (baseSsId !== void 0) baseSsIds.set(out, baseSsId);
+        return [out];
       }
       if (!restamped) return [sym];
       this.#overlayStats.unsequencedDropped++;
@@ -9440,6 +10952,80 @@ var MmtpRouter = class {
       deliveryProvenance: inst.moqBlocks.has(blockStart) ? "mixed" : "multicast"
     });
     this.#noteOverlayRecoveredRaps(sourcePacketId, sourceName, streamKey, symbols.filter((sym) => restored.has(sym.packetSequenceNumber)));
+    this.#feedOverlayRecoveredToBase(inst, blockStart, symbols, baseSsIds);
+  }
+  /**
+   * Joint decoding (BLO-52085). A packet the overlay rebuilt is a source of
+   * its base block too, once its base SS_ID is determined (overlayBaseSsId),
+   * so it is fed to the base decoder as a rebuilt source
+   * (FECManager.feedRebuiltSourceSymbol): the base block has one erasure
+   * fewer to solve, and its repair can recover the block's other packets.
+   * A base block no repair has stated yet takes it when one does
+   * (#feedPendingRebuilt).
+   *
+   * The overlay route already handled each packet fed (delivered it, or
+   * held an untimed head for its FT=1), so a base recovery routes none of
+   * them again (#routeVerifiedFecSymbols): a second recovered copy of a
+   * held head would wait in the parser for timing its first copy consumed.
+   * Only an overlay block decoded from multicast symbols alone is fed: with
+   * a MoQ symbol in it, the base block's recovery would depend on bytes
+   * that crossed no multicast socket, which the provenance counted from the
+   * block's own arrivals cannot show.
+   */
+  #feedOverlayRecoveredToBase(inst, blockStart, symbols, baseSsIds) {
+    const fec = this.#fecManager;
+    const owner = inst.leg.sourcePacketId;
+    const name = inst.leg.sourceCatalogTrackName;
+    if (!fec?.feedRebuiltSourceSymbol || inst.moqBlocks.has(blockStart)) return;
+    if (this.#classifyPacketId(owner) === null || fec.isTrackConfigured?.(owner) === false) return;
+    const { duplicates, overlayToBase: { routed } } = this.#stream(owner, name);
+    const feeds = [];
+    for (const sym of symbols) {
+      if (duplicates.sourceSeqs.has(sym.packetSequenceNumber)) continue;
+      const ssId = baseSsIds.get(sym);
+      if (ssId === void 0) {
+        this.#overlayStats.baseUndetermined++;
+        continue;
+      }
+      routed.delete(ssId);
+      routed.add(ssId);
+      if (routed.size > OVERLAY_ROUTED_LIMIT) routed.delete(routed.values().next().value);
+      feeds.push([ssId, sym.rawSymbol]);
+    }
+    for (const [ssId, symbolData] of feeds) this.#feedRebuiltToBase(owner, name, ssId, symbolData);
+  }
+  /** Feed one rebuilt source to its base block, or keep it until a repair states that block. */
+  #feedRebuiltToBase(owner, name, ssId, symbolData) {
+    const fec = this.#fecManager;
+    if (!fec?.feedRebuiltSourceSymbol) return;
+    const coords = fec.locateIsoSource?.(owner, name, ssId);
+    if (coords == null) {
+      const pending = this.#stream(owner, name).overlayToBase.pending;
+      pending.delete(ssId);
+      pending.set(ssId, symbolData);
+      if (pending.size > OVERLAY_PENDING_LIMIT) pending.delete(pending.keys().next().value);
+      return;
+    }
+    const fed = fec.feedRebuiltSourceSymbol(owner, ssId, symbolData, name);
+    if (!fed.taken) return;
+    this.#overlayStats.baseFed++;
+    if (fed.recovered === null) return;
+    const sbn = coords.sbn;
+    this.#routeRecoveredBlock(sbn, fed.recovered, owner, name, () => {
+      fec.cancelBlockTimeout(sbn, owner, name);
+      fec.countRecovery(owner, sbn, name);
+      fec.markBlockCompleted(sbn, owner, name);
+    });
+  }
+  /** A repair stated `block`: the rebuilt sources that waited for it join it now. */
+  #feedPendingRebuilt(owner, name, block) {
+    const pending = this.#streams.get(owner)?.get(name)?.overlayToBase.pending;
+    if (pending === void 0 || pending.size === 0) return;
+    for (const [ssId, symbolData] of [...pending]) {
+      if (serial32Distance(block.start, ssId) >= block.length) continue;
+      pending.delete(ssId);
+      this.#feedRebuiltToBase(owner, name, ssId, symbolData);
+    }
   }
   /** fec-multicast-00 §6.6: report each base block whose RAP MFU fragments
    *  the overlay restored, when the keyframe's FT=0 and FT=1 are held too. A
@@ -9571,10 +11157,11 @@ var MmtpRouter = class {
     if (!entry) return;
     entry.receiver.release();
     entry.protected = false;
+    entry.userAgent = false;
     this.#assistBlocks.clear();
     this.#assistFailures.clear();
   }
-  /** MoQ packets of a track a protected flow lists, dropped on its unicast path: duplicate, overflow, or listed by more than one flow. */
+  /** Packets of a track a protected flow lists, dropped unread: a MoQ copy (duplicate, overflow, or listed by more than one flow) or a multicast source datagram that names no flow, of a track a user-agent-admitted flow lists. */
   get unadmittedListedDropCount() {
     return this.#unadmittedListedDrops;
   }
@@ -9615,6 +11202,13 @@ var MmtpRouter = class {
     }
     return false;
   }
+  /** Whether a protected flow the user agent admitted lists `packetId`. */
+  #userAgentGoverns(packetId) {
+    for (const entry of this.#provenance.values()) {
+      if (entry.protected && entry.userAgent && ingressHasPacketId(entry.ingress, packetId)) return true;
+    }
+    return false;
+  }
   /**
    * A MoQ repair symbol no protected flow lists, owned by a source track one
    * does: its FEC instance is governed (7.2.7 step 2) and takes only admitted
@@ -9705,7 +11299,7 @@ var MmtpRouter = class {
       fec.cancelBlockTimeout(blockStart, ownerPacketId, catalogTrackName);
       fec.countRecovery(ownerPacketId, blockStart, catalogTrackName);
       fec.markBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
-    })) {
+    }, true)) {
       this.#unlistedAssistedRecoveries++;
       this.#assistBlocks.delete(key);
       return;
@@ -10047,6 +11641,8 @@ var MmtpRouter = class {
     }
     this.#replayIsoSources(ownerPacketId, catalogTrackName, blockStart, placement.placed);
     if (this.#classifyPacketId(ownerPacketId) === null) return;
+    this.#feedPendingRebuilt(ownerPacketId, catalogTrackName, placement.block);
+    if (this.#classifyPacketId(ownerPacketId) === null) return;
     if (!this.#feedFecTransportSymbol(
       ownerPacketId,
       blockStart,
@@ -10861,6 +12457,12 @@ var MmtpRouter = class {
         debugRouter(`[MmtpRouter] Dropping multicast packet pid=${info.packetId}: flow ${ingress.flow} has no receiver`);
         return;
       }
+      if (ingress.admittedBy === USER_AGENT_VERIFIED) {
+        this.#noteFlowAdmitted(ingress.flow);
+        protectedFlow.userAgent = true;
+        this.#processMMTP(packet, source, true, ingress, overlapCopy);
+        return;
+      }
       const { verdict } = protectedFlow.receiver.onDatagram(packet, "multicast");
       if (verdict === "admitted") {
         this.#noteFlowAdmitted(ingress.flow);
@@ -10878,6 +12480,11 @@ var MmtpRouter = class {
         return;
       }
     }
+    const flowless = source === "multicast" && !manifestAdmitted && ingress?.flow === void 0;
+    if (flowless && !info.isRepair && this.#userAgentGoverns(info.packetId)) {
+      this.#unadmittedListedDrops++;
+      return;
+    }
     if (info.isRepair) {
       const overlay = this.#overlayRepairTarget(info.packetId, catalogTrackNameForPacket(ingress, info.packetId));
       if (overlay !== void 0) {
@@ -10895,7 +12502,7 @@ var MmtpRouter = class {
       );
       if (!repair) return;
       if (ownerPacketId != null && this.#fecManager) {
-        if (source === "moq" && !manifestAdmitted && this.#setAsideUnlistedRepair(ownerPacketId, catalogTrackNameForPacket(ingress, ownerPacketId), repair)) return;
+        if ((flowless && this.#userAgentGoverns(ownerPacketId) || source === "moq" && !manifestAdmitted) && this.#setAsideUnlistedRepair(ownerPacketId, catalogTrackNameForPacket(ingress, ownerPacketId), repair)) return;
         this.#repairPidCounts[info.packetId] = (this.#repairPidCounts[info.packetId] || 0) + 1;
         const count = this.#repairPidCounts[info.packetId];
         if (count <= 2 || count % 500 === 0) {
@@ -11098,7 +12705,8 @@ var MmtpRouter = class {
           parsed.header,
           info.sequenceNumber,
           info.rapFlag,
-          source
+          source,
+          fecPayloadId?.ssId
         );
       }
     }
@@ -11248,7 +12856,8 @@ var MmtpRouter = class {
     if (stream === void 0) {
       stream = {
         key: JSON.stringify([packetId, catalogTrackName ?? null]),
-        duplicates: new StreamDuplicateLedgers(() => this.duplicateHorizonFor(packetId))
+        duplicates: new StreamDuplicateLedgers(() => this.duplicateHorizonFor(packetId)),
+        overlayToBase: { routed: /* @__PURE__ */ new Set(), pending: /* @__PURE__ */ new Map() }
       };
       byName.set(catalogTrackName, stream);
     }
@@ -11363,8 +12972,16 @@ var MmtpRouter = class {
     this.#drainDirectRecoveredVideo(streamKey, packetId, (frame) => frame.timestamp <= meta.timestamp, cb);
     this.#emitDirectVideo(packetId, data, meta, cb);
   }
-  #routeDirectRecoveredVideo(packetId, data, meta, cb) {
+  #routeDirectRecoveredVideo(packetId, data, meta, cb, fecSbn) {
     const streamKey = this.#mediaStreamKey(packetId, meta.catalogTrackName);
+    if (this.#isFecTrack(packetId)) {
+      const high = this.#deliveredVideoHighWaterByStream.get(streamKey);
+      if (fecSbn !== void 0 || high !== void 0 && authoredAdjacent(high, meta)) {
+        this.#drainDirectRecoveredVideo(streamKey, packetId, (frame) => frame.timestamp <= meta.timestamp, cb);
+        this.#emitDirectVideo(packetId, data, meta, cb);
+        return;
+      }
+    }
     this.#enqueueDirectRecoveredVideo(packetId, data, meta);
     const lastSourceTs = this.#lastDirectSourceVideoTsByStream.get(streamKey);
     this.#drainDirectRecoveredVideo(
@@ -11474,7 +13091,7 @@ var MmtpRouter = class {
   }
   // ── Private: FEC recovery routing ───────────────────────────────
   /** Route WASM-recovered block through appropriate path based on container kind. */
-  #routeRecoveredBlock(blockId, recovered, ownerPacketId, catalogTrackName, complete) {
+  #routeRecoveredBlock(blockId, recovered, ownerPacketId, catalogTrackName, complete, assisted = false) {
     const packetSymbolSize = this.#symbolSizeForPacket(ownerPacketId);
     if (ownerPacketId === void 0) {
       throw new Error("[MmtpRouter] a recovered FEC block needs its owner packetId to read its fec.blockProfile");
@@ -11491,7 +13108,7 @@ var MmtpRouter = class {
       ownerPacketId,
       blockProfile
     });
-    return this.#routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, complete);
+    return this.#routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, complete, assisted);
   }
   /**
    * A recovered source packet of a protected flow is admitted on its own
@@ -11503,9 +13120,31 @@ var MmtpRouter = class {
    * recovered packets is refused is unrecovered (7.2.7): its caller leaves it
    * open, so it reaches its FEC deadline and fails by class. Always true
    * outside a protected flow.
+   *
+   * On a flow the user agent admitted, the live decoder's recoveries are kept
+   * without a record: while the flow is protected that decoder takes only
+   * symbols the user agent or a record verified (a flow-less multicast
+   * datagram of a listed track is dropped or set aside in #processMMTP), so
+   * what it recovers is as verified as they are. An `assisted` (scratch-decoder) recovery mixes in
+   * unlisted MoQ repair and still needs a record.
+   * ponytail: per-flow flag; per-block provenance only if a protected flow
+   * ever mixes verified and unverified live inputs.
+   * ponytail: a worker frame computed before the protection reset can still
+   * arrive after it (frames carry no epoch); its inputs are MoQ copies read
+   * and played before protection, so it admits nothing new. Drop pre-reset
+   * frames by epoch only if pre-protection input ever matters.
    */
-  #routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, complete) {
-    const receiver = ownerPacketId == null ? void 0 : this.#provenanceFor(ownerPacketId, catalogTrackName);
+  #routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, complete, assisted = false) {
+    const overlayRouted = ownerPacketId == null ? void 0 : this.#streams.get(ownerPacketId)?.get(catalogTrackName)?.overlayToBase.routed;
+    if (overlayRouted !== void 0 && overlayRouted.size > 0) {
+      result = {
+        ...result,
+        symbols: result.symbols.filter((sym) => !overlayRouted.has(this.#fecAnchorForRecovered(blockId, sym.index)))
+      };
+    }
+    const entry = ownerPacketId == null ? void 0 : this.#provenanceFor(ownerPacketId, catalogTrackName);
+    const receiver = entry === void 0 || entry === "ambiguous" ? entry : entry.receiver;
+    const userAgent = !assisted && entry !== void 0 && entry !== "ambiguous" && entry.protected === true && entry.userAgent === true;
     let recovered = true;
     if (receiver) {
       const parsed = this.#stream(ownerPacketId, catalogTrackName).duplicates.parsedSymbols;
@@ -11517,6 +13156,8 @@ var MmtpRouter = class {
           let admitted = false;
           if (receiver === "ambiguous") {
             this.#ambiguousRecoveredDrops++;
+          } else if (userAgent) {
+            admitted = true;
           } else {
             const wire = new Uint8Array(sym.rawSymbol.byteLength + 4);
             wire.set(sym.rawSymbol);
@@ -11544,12 +13185,12 @@ var MmtpRouter = class {
       catalogTrackName === void 0 || !byName ? byName?.values() : byName.has(catalogTrackName) ? [byName.get(catalogTrackName)] : []
     );
     if (flows.size > 1) return "ambiguous";
-    for (const bound of flows) return this.#provenance.get(bound)?.receiver ?? "ambiguous";
+    for (const bound of flows) return this.#provenance.get(bound) ?? "ambiguous";
     let match;
-    for (const { receiver, ingress } of this.#provenance.values()) {
-      if (ingress.tracks.some((t) => t.packetId === packetId && (catalogTrackName === void 0 || t.name === catalogTrackName))) {
+    for (const entry of this.#provenance.values()) {
+      if (entry.ingress.tracks.some((t) => t.packetId === packetId && (catalogTrackName === void 0 || t.name === catalogTrackName))) {
         if (match) return "ambiguous";
-        match = receiver;
+        match = entry;
       }
     }
     return match;
@@ -11601,6 +13242,29 @@ var MmtpRouter = class {
         }
       );
     }
+    const untimedHead = (sym) => sym.fragmentType === 2 && sym.fragment.fragmentationIndicator === 1 && sym.fragment.movieFragmentSequenceNumber !== void 0 && sym.fragment.sampleNumber !== void 0 && !this.#parser.hasAuthoredTimingFor(
+      ownerPacketId,
+      sym.fragment.mpuSequenceNumber,
+      sym.fragment.movieFragmentSequenceNumber,
+      sym.fragment.sampleNumber,
+      catalogTrackName
+    );
+    for (const sym of result.symbols) {
+      if (!untimedHead(sym) || this.#sourceSeqReceived(ownerPacketId, sym.packetSequenceNumber, catalogTrackName)) continue;
+      this.#feedViaParser(
+        sym.rawSymbol,
+        { packetId: ownerPacketId, sequenceNumber: sym.packetSequenceNumber },
+        void 0,
+        {
+          skipFecPayloadId: true,
+          recovered: true,
+          deliveryProvenance,
+          ...fecSbnOf(sym.index),
+          ...catalogTrackName === void 0 ? {} : { catalogTrackName }
+        }
+      );
+    }
+    result = { ...result, symbols: result.symbols.filter((sym) => !untimedHead(sym)) };
     const gated = this.#isFecTrack(ownerPacketId);
     const assembler = this.#mseAssemblerFor(ownerPacketId, catalogTrackName);
     if (assembler) {