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

package/dist/multicast-transport.js

@@ -0,0 +1,2264 @@
+// 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/node_modules/@blockcast/mmt-alta-parse/dist/index.js
+var MPU_HEADER_SIZE = 8;
+var MPU_LENGTH_FIELD_SIZE = 2;
+var MPU_HEADER_REMAINDER_SIZE = MPU_HEADER_SIZE - MPU_LENGTH_FIELD_SIZE;
+
+// node_modules/@blockcast/mmt-transport/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_ID = 0;
+var MMTP_PACKET_ID_MAX = 65535;
+
+// node_modules/@blockcast/mmt-transport/node_modules/@blockcast/mmt-base/dist/net-constants.js
+var DEFAULT_AMT_RELAY_PORT = 2268;
+
+// node_modules/@blockcast/mmt-transport/node_modules/@blockcast/mmt-base/dist/ntp-short.js
+var NTP_SHORT_BITS = 32;
+var NTP_SHORT_MODULUS = 2 ** NTP_SHORT_BITS;
+var NTP_SHORT_HALF_RANGE = 2 ** (NTP_SHORT_BITS - 1);
+function isNtpShort(value) {
+  return Number.isInteger(value) && value >= 0 && value < NTP_SHORT_MODULUS;
+}
+function compareNtpShort(a, b) {
+  if (!isNtpShort(a) || !isNtpShort(b)) {
+    throw new RangeError(`NTP-short values must be integers in [0, 2^${NTP_SHORT_BITS}), got ${String(a)} and ${String(b)}`);
+  }
+  if (a === b)
+    return "equal";
+  const forward = (a - b + NTP_SHORT_MODULUS) % NTP_SHORT_MODULUS;
+  if (forward < NTP_SHORT_HALF_RANGE)
+    return "after";
+  if (forward > NTP_SHORT_HALF_RANGE)
+    return "before";
+  return "unordered";
+}
+
+// node_modules/@blockcast/mmt-transport/node_modules/@blockcast/mmt-base/dist/fec-block-profile.js
+var FEC_BLOCK_PROFILES = Object.freeze([
+  "k-padded-v1",
+  "iso-ssbg1-v1"
+]);
+
+// node_modules/@blockcast/mmt-transport/dist/driad-discovery.js
+var DRIADDiscovery = class {
+  cache = /* @__PURE__ */ new Map();
+  cacheExpiry = 3e5;
+  // 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: DEFAULT_AMT_RELAY_PORT,
+          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 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
+   *
+   * 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 >= 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-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 || this.options.adaptive === false)
+      return void 0;
+    if (this.#state === "joining")
+      return this.poll();
+    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 };
+  }
+  /**
+   * 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 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 isMulticastTrackPacketId(value) {
+  return Number.isInteger(value) && value > MMTP_SIGNALING_PACKET_ID && 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
+    });
+    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 } : {}
+    }));
+    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;
+  driad = new DRIADDiscovery();
+  /** 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: 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)
+   *
+   * 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) {
+    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.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 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 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());
+  }
+  /**
+   * 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/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 AMTGatewayManager = class {
+  subscriptions = /* @__PURE__ */ new Map();
+  messageHandler;
+  pendingPackets = /* @__PURE__ */ new Map();
+  driad = new DRIADDiscovery();
+  constructor() {
+    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_RELAY_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();
+
+// ../mmt-alta-parse/dist/index.js
+var MPU_HEADER_SIZE3 = 8;
+var MPU_LENGTH_FIELD_SIZE3 = 2;
+var MPU_HEADER_REMAINDER_SIZE3 = MPU_HEADER_SIZE3 - MPU_LENGTH_FIELD_SIZE3;
+
+// ../mmt-base/dist/mmtp.js
+var MMTP_HEADER_SIZE = 12;
+var MPU_HEADER_SIZE4 = 8;
+var MPU_LENGTH_FIELD_SIZE4 = 2;
+var MPU_HEADER_REMAINDER_SIZE4 = MPU_HEADER_SIZE4 - MPU_LENGTH_FIELD_SIZE4;
+var MMTP_SIGNALING_PACKET_ID2 = 0;
+var MMTP_PACKET_ID_MAX2 = 65535;
+function readMMTPPacketId(buffer) {
+  if (buffer.length < MMTP_HEADER_SIZE)
+    return null;
+  const flags = buffer[0];
+  if ((flags >> 6 & 3) !== 0)
+    return null;
+  let offset = MMTP_HEADER_SIZE;
+  if ((flags & 32) !== 0) {
+    if (offset + 4 > buffer.length)
+      return null;
+    offset += 4;
+  }
+  if ((flags & 2) !== 0) {
+    if (offset + 4 > buffer.length)
+      return null;
+    const length = buffer[offset + 2] << 8 | buffer[offset + 3];
+    if (offset + 4 + length > buffer.length)
+      return null;
+  }
+  return buffer[2] << 8 | buffer[3];
+}
+
+// ../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);
+
+// ../mmt-base/dist/fec-block-profile.js
+var FEC_BLOCK_PROFILES2 = Object.freeze([
+  "k-padded-v1",
+  "iso-ssbg1-v1"
+]);
+
+// src/multicast-transport.ts
+var JOIN_SUCCEEDED = Object.freeze({ ok: true });
+function providerErrorOf(error) {
+  if (typeof error !== "object" || error === null) return void 0;
+  const fields = error;
+  let name;
+  let message;
+  let code;
+  try {
+    name = fields.name;
+    message = fields.message;
+    code = fields.code;
+  } catch {
+    return void 0;
+  }
+  if (typeof name !== "string" || typeof message !== "string") return void 0;
+  return Object.freeze(typeof code === "string" ? { name, message, code } : { name, message });
+}
+var MAX_TRACKED_DROPPED_PIDS = 16;
+function getMulticastGlobals() {
+  return globalThis;
+}
+function hasMulticastGateway() {
+  return typeof getMulticastGlobals().multicast?.subscribe === "function";
+}
+function normalizeBytesEventDetail(detail) {
+  const value = detail && typeof detail === "object" && "data" in detail ? detail.data : detail;
+  if (value instanceof Uint8Array) return value;
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  return null;
+}
+function packetFilterUpdater(subscription) {
+  const update = subscription.setPacketIds;
+  return typeof update === "function" ? update.bind(subscription) : void 0;
+}
+function sameIds(a, b) {
+  if (a.size !== b.size) return false;
+  for (const id of a) if (!b.has(id)) return false;
+  return true;
+}
+var MulticastTransport = class _MulticastTransport {
+  #onPacket;
+  #subscription = null;
+  #packetListener = null;
+  #resolvedTransport;
+  #videoConfirmed = false;
+  #audioConfirmed = false;
+  // One armed no-packets timer per silence window (BLO-36599). Packets only
+  // record #lastPacketAtMs; the timer re-arms for the remainder when it wakes
+  // inside the window, instead of a clear+set pair on every packet.
+  #watchdog = null;
+  #lastPacketAtMs = 0;
+  #failbackWindowMs = null;
+  #onTakeover = null;
+  #onFailback = null;
+  // Data-plane-live edge: the first packet this join accepted. Everything
+  // before it is join latency, not silence (see #resetWatchdog).
+  #dataPlaneLive = false;
+  #onDataPlaneLive = null;
+  #errorListener = null;
+  #onDelivery = null;
+  #delivery;
+  #disposed = false;
+  #stats = {
+    packetsReceived: 0,
+    bytesReceived: 0,
+    packetsDroppedUnregisteredPid: 0,
+    packetsDroppedUnparseable: 0,
+    packetsDroppedSignaling: 0
+  };
+  // join() calls by how they resolved; see joinStats.
+  #joinsSucceeded = 0;
+  #joinsDeclined = {
+    disposed: 0,
+    unavailable: 0,
+    superseded: 0,
+    "invalid-request": 0,
+    "provider-rejected": 0,
+    "invalid-subscription": 0,
+    "delivery-hook-failed": 0
+  };
+  // The newest resolved join's outcome (see lastJoinOutcome) and the join
+  // generation it belongs to. Generations are issued in start order, so a
+  // join that resolves after a newer join has recorded leaves it standing.
+  #lastJoinOutcome = void 0;
+  #lastJoinOutcomeGeneration = 0;
+  #droppedPidCounts = /* @__PURE__ */ new Map();
+  // Accepted bytes per MMTP packet_id; see bytesReceivedForPacketIds. Each
+  // value is a mutable cell, so the per-packet update is one lookup and an
+  // in-place add: no insertion once the key exists, and no re-boxed number
+  // per packet once a count outgrows the small-integer range.
+  #acceptedBytesByPacketId = /* @__PURE__ */ new Map();
+  #packetIds = null;
+  // What the live join delivers with each accepted packet. A field, not a
+  // listener closure, so an in-place admission change (setContext) applies
+  // from the next packet on without rejoining.
+  #context = void 0;
+  // The live join's provider-side filter. An in-place widening must reach it,
+  // or the provider never delivers the new ID; null without a live join.
+  #providerFilter = null;
+  // IDs an in-place update withdrew while the provider may still be
+  // delivering them. Their late packets are still counted as filtered, but
+  // they are the expected tail of a deliberate change, not a provisioning
+  // fault, so they are counted apart and do not raise the unadvertised-PID
+  // warning.
+  #withdrawnPacketIds = /* @__PURE__ */ new Set();
+  #withdrawnPacketIdDrops = 0;
+  // Distinct packet IDs dropped as provisioning faults: on the wire but in
+  // no allow-list the join or an in-place update declared. Capped with
+  // droppedPacketIds.
+  #unadvertisedPacketIds = /* @__PURE__ */ new Set();
+  #joinGeneration = 0;
+  constructor(onPacket) {
+    this.#onPacket = onPacket;
+  }
+  static isAvailable() {
+    return hasMulticastGateway();
+  }
+  async join(config, context) {
+    const generation = ++this.#joinGeneration;
+    this.#releaseSubscription();
+    this.#dataPlaneLive = false;
+    if (this.#disposed) return this.#declined(generation, "disposed");
+    if (!_MulticastTransport.isAvailable()) {
+      console.warn("[MulticastTransport] Multicast API not available");
+      return this.#declined(generation, "unavailable");
+    }
+    let failure = "invalid-request";
+    try {
+      const packetIds = config.packetIds?.length ? new Set(config.packetIds) : null;
+      console.log(
+        `[MulticastTransport] window.multicast.subscribe(${config.sourceAddress}, ${config.groupAddress}, ${config.port})`
+      );
+      const subscribeConfig = toWindowMulticastSubscribeConfig({
+        source: config.sourceAddress,
+        group: config.groupAddress,
+        port: config.port,
+        mode: config.mode,
+        amtRelay: config.amtRelay,
+        amtRelayPort: config.amtRelayPort,
+        packetIds: config.packetIds,
+        tracks: config.tracks
+      });
+      failure = "provider-rejected";
+      const subscription = await getMulticastGlobals().multicast.subscribe(subscribeConfig);
+      failure = "invalid-subscription";
+      console.log(`[MulticastTransport] window.multicast.subscribe returned:`, !!subscription);
+      if (this.#disposed || generation !== this.#joinGeneration) {
+        void subscription.unsubscribe();
+        return this.#declined(generation, this.#displacedReason());
+      }
+      if (typeof subscription.addEventListener !== "function") {
+        if (typeof subscription.unsubscribe === "function") {
+          void subscription.unsubscribe();
+        }
+        throw new Error("window.multicast subscription does not support bytes events");
+      }
+      this.#subscription = subscription;
+      const live = () => !this.#disposed && generation === this.#joinGeneration;
+      const packetListener = subscriptionDeliversPacketBatches(subscription) ? {
+        type: "packets",
+        listener: (event) => {
+          if (!live()) return;
+          this.#deliverBatch(event.detail, live);
+        }
+      } : {
+        type: "bytes",
+        listener: (event) => {
+          if (!live()) return;
+          if (this.#deliver(event.detail)) this.#resetWatchdog();
+        }
+      };
+      this.#packetListener = packetListener;
+      this.#packetIds = packetIds;
+      this.#providerFilter = {
+        acknowledged: packetIds,
+        sent: 0,
+        acknowledgedUpdate: 0,
+        inFlight: 0
+      };
+      this.#context = context;
+      if (packetIds) {
+        for (const packetId of packetIds) {
+          if (!this.#acceptedBytesByPacketId.has(packetId)) {
+            this.#acceptedBytesByPacketId.set(packetId, { bytes: 0 });
+          }
+        }
+      }
+      this.#resolvedTransport = subscribeConfig.origin === "amt" ? "amt" : "native";
+      const delivery = subscription.delivery ?? "datagram";
+      if (delivery !== "datagram" && delivery !== "ordered-relay") {
+        throw new Error(
+          `window.multicast subscription declared unknown delivery ${String(delivery)}`
+        );
+      }
+      this.#delivery = delivery;
+      failure = "delivery-hook-failed";
+      this.#onDelivery?.(delivery);
+      failure = "invalid-subscription";
+      const onError = (event) => {
+        if (this.#disposed || generation !== this.#joinGeneration) return;
+        this.#failBackOnSubscriptionError(event.detail);
+      };
+      this.#errorListener = onError;
+      if (packetListener.type === "packets") {
+        subscription.addEventListener("packets", packetListener.listener);
+      } else {
+        subscription.addEventListener("bytes", packetListener.listener);
+      }
+      subscription.addEventListener("error", onError);
+      console.log(
+        `[MulticastTransport] Joined ${config.groupAddress}:${config.port}`
+      );
+      return this.#joined(generation);
+    } catch (err) {
+      if (this.#disposed || generation !== this.#joinGeneration) {
+        return this.#declined(generation, this.#displacedReason());
+      }
+      this.#releaseSubscription();
+      console.error("[MulticastTransport] Failed to join SSM group:", err);
+      return this.#declined(
+        generation,
+        failure,
+        failure === "provider-rejected" ? providerErrorOf(err) : void 0
+      );
+    }
+  }
+  /** Record a join that resolved true; returns its result. */
+  #joined(generation) {
+    this.#joinsSucceeded++;
+    this.#recordJoinOutcome(generation, JOIN_SUCCEEDED);
+    return true;
+  }
+  /** Record a join that resolved false, and why; returns its result. */
+  #declined(generation, reason, providerError) {
+    this.#joinsDeclined[reason]++;
+    this.#recordJoinOutcome(
+      generation,
+      Object.freeze(
+        providerError === void 0 ? { ok: false, reason } : { ok: false, reason, providerError }
+      )
+    );
+    return false;
+  }
+  /**
+   * Why a join that no longer owns the transport resolved false. dispose()
+   * advances the join generation too, so disposal is checked first.
+   */
+  #displacedReason() {
+    return this.#disposed ? "disposed" : "superseded";
+  }
+  #recordJoinOutcome(generation, outcome) {
+    if (generation <= this.#lastJoinOutcomeGeneration) return;
+    this.#lastJoinOutcomeGeneration = generation;
+    this.#lastJoinOutcome = outcome;
+  }
+  /**
+   * One packet from the subscription: filter, count, and hand it to the
+   * callback. Returns whether it was delivered; the caller notes liveness.
+   */
+  #deliver(detail) {
+    const packet = normalizeBytesEventDetail(detail);
+    if (!packet) {
+      this.#stats.packetsDroppedUnparseable++;
+      return false;
+    }
+    if (!this.#acceptPacket(packet)) return false;
+    this.#onPacket(packet, this.#context);
+    return true;
+  }
+  /**
+   * One `packets` event. Each packet is delivered as a `bytes` event would
+   * have delivered it, including isolation: a packet whose callback throws
+   * does not cost the rest of its batch, as it would not have cost the next
+   * `bytes` event. The first failure is rethrown once the batch is done, so
+   * it reaches the event-listener error reporting a `bytes` listener's throw
+   * reached; any further one is rethrown from its own microtask, which the
+   * host reports the same way, so no failure is swallowed. A callback that
+   * disposes the transport or starts another join ends the batch there, as
+   * the per-packet guard would have ignored the remaining events.
+   */
+  #deliverBatch(batch, live) {
+    if (!Array.isArray(batch)) {
+      throw new TypeError("[MulticastTransport] packets event detail must be an array of packets");
+    }
+    let delivered = false;
+    let failures = null;
+    for (let i = 0; i < batch.length; i++) {
+      try {
+        if (this.#deliver(batch[i])) delivered = true;
+      } catch (error) {
+        if (failures === null) failures = [];
+        failures.push(error);
+      }
+      if (!live()) break;
+    }
+    if (delivered && live()) this.#resetWatchdog();
+    if (failures !== null) {
+      for (let i = 1; i < failures.length; i++) {
+        const failure = failures[i];
+        queueMicrotask(() => {
+          throw failure;
+        });
+      }
+      throw failures[0];
+    }
+  }
+  /** Feed a raw packet from an external source (e.g., AMT tunnel or ASM subscription). */
+  feedPacket(data, context) {
+    if (this.#disposed) return;
+    const packet = data instanceof Uint8Array ? data : new Uint8Array(data);
+    if (!this.#acceptPacket(packet)) return;
+    this.#onPacket(packet, context);
+    this.#resetWatchdog();
+  }
+  confirmVideo() {
+    this.#videoConfirmed = true;
+    this.#checkTakeover();
+  }
+  confirmAudio() {
+    this.#audioConfirmed = true;
+    this.#checkTakeover();
+  }
+  onTakeover(cb) {
+    this.#onTakeover = cb;
+  }
+  onFailback(cb) {
+    this.#onFailback = cb;
+  }
+  /**
+   * Called on every successful join, before the joined subscription can
+   * deliver a packet, with how that subscription delivers packets.
+   */
+  onDelivery(cb) {
+    this.#onDelivery = cb;
+  }
+  /** How the current subscription delivers packets, once joined. */
+  get delivery() {
+    return this.#delivery;
+  }
+  /**
+   * Fires once per join, at the first packet the join accepts (after the PID
+   * filter; a rejected packet is not liveness). This is the data-plane-live
+   * edge, where this transport's silence window starts. A join whose source
+   * never sends never reaches it, so a host may start a media-arrival budget
+   * here only if the provider bounds the join phase with a typed subscription
+   * error (see SessionManager.joinActive); otherwise the host starts it when
+   * the subscribe settles.
+   */
+  onDataPlaneLive(cb) {
+    this.#onDataPlaneLive = cb;
+  }
+  /** Whether the current join has accepted a packet (see onDataPlaneLive). */
+  get dataPlaneLive() {
+    return this.#dataPlaneLive;
+  }
+  setFailbackWindowMs(windowMs) {
+    if (!Number.isFinite(windowMs) || windowMs <= 0) {
+      throw new Error(
+        `[MulticastTransport] failbackWindowMs=${windowMs}. Derive a positive failback window from the stream catalog.`
+      );
+    }
+    this.#failbackWindowMs = windowMs;
+    if (this.#watchdog !== null) {
+      clearTimeout(this.#watchdog);
+      const silentMs = performance.now() - this.#lastPacketAtMs;
+      this.#armWatchdog(Math.max(0, Math.ceil(windowMs - silentMs)));
+    }
+  }
+  get stats() {
+    return this.#stats;
+  }
+  /**
+   * How the newest join() to resolve did: `{ ok: true }`, or `{ ok: false }`
+   * with the typed reason it resolved false (and, for `provider-rejected`, the
+   * provider's typed error fields). Undefined until a join resolves. Branch on
+   * `reason` and `providerError.code`, never on log text or
+   * `providerError.message`.
+   *
+   * Newest is by start order: a join that resolves after a newer join has
+   * recorded its outcome does not replace it, so once `await join()` resolves
+   * this names that join's outcome unless a newer join has already resolved.
+   * It records how a join resolved, not whether it is still joined (see
+   * `joined`); a join() that rejects instead of resolving records nothing,
+   * the rejection being its report. Frozen: a later outcome replaces the
+   * object, never changes it.
+   */
+  get lastJoinOutcome() {
+    return this.#lastJoinOutcome;
+  }
+  /**
+   * join() calls by how they resolved (see MulticastJoinStats). A fresh frozen
+   * snapshot on every read, so a later join never changes one already read.
+   * Kept apart from `stats`, which is the live counter object.
+   */
+  get joinStats() {
+    return Object.freeze({
+      succeeded: this.#joinsSucceeded,
+      declined: Object.freeze({ ...this.#joinsDeclined })
+    });
+  }
+  /**
+   * Accepted bytes summed over `packetIds`: the `bytesReceived` share of those
+   * MMTP packet_ids. Counted by the same rule, on every path that counts
+   * `bytesReceived` (only packets that pass the ingress filter; packet_id 0
+   * signaling never), and cumulative for the life of the transport, across
+   * rejoins, as `bytesReceived` is. An id never accepted contributes 0. An
+   * unparseable packet admitted by a join without an allow-list has no
+   * packet_id, so it counts toward `bytesReceived` only.
+   *
+   * Use it to scope an ABR throughput sample to the active tier's source and
+   * repair packet_ids when the join admits more than the active tier (a
+   * shared group joined across rendition switches); `bytesReceived` is then
+   * the whole allow-list's arrival, not the active tier's. A Set, so an id
+   * shared by two tracks of the tier is counted once.
+   *
+   * Monotonic only for a fixed set: each id has counted since it was first
+   * admitted, so after a tier switch the new set's sum is not a continuation
+   * of the old one. A cumulative consumer takes a fresh baseline for the new
+   * set and never differences across sets.
+   */
+  bytesReceivedForPacketIds(packetIds) {
+    let bytes = 0;
+    for (const packetId of packetIds) {
+      bytes += this.#acceptedBytesByPacketId.get(packetId)?.bytes ?? 0;
+    }
+    return bytes;
+  }
+  /**
+   * Per-PID drop breakdown, newest-capped at MAX_TRACKED_DROPPED_PIDS distinct
+   * PIDs.  This is what names the offender: `packetsDroppedUnregisteredPid`
+   * says the ingress filter fired, this says it fired on 0x8001.
+   */
+  get droppedPacketIds() {
+    return this.#droppedPidCounts;
+  }
+  /**
+   * Distinct packet IDs dropped as provisioning faults: arriving on the wire
+   * but in no allow-list the join or an in-place update (setPacketIds)
+   * declared, the drops that raise the unadvertised-PID warning. A packet ID
+   * an in-place update withdrew is not one (see withdrawnPacketIdDrops).
+   * Cumulative across rejoins and capped with droppedPacketIds.
+   */
+  get unadvertisedPacketIds() {
+    return this.#unadvertisedPacketIds;
+  }
+  /**
+   * Packets dropped because an in-place update (setPacketIds) withdrew their
+   * packet ID while the provider may still deliver it: the expected tail of
+   * a deliberate change. A subset of packetsDroppedUnregisteredPid,
+   * cumulative across rejoins.
+   */
+  get withdrawnPacketIdDrops() {
+    return this.#withdrawnPacketIdDrops;
+  }
+  /** Whether a subscription is live: joined, and not yet released or replaced. */
+  get joined() {
+    return this.#subscription !== null;
+  }
+  /**
+   * What the live join delivers with every accepted packet (the join's
+   * `context`, or the last setContext), or undefined without a live join.
+   */
+  get context() {
+    return this.#context;
+  }
+  /**
+   * The live join's page-side packet-ID allow-list, or null when it admits
+   * every packet ID (a join that carried none, or no live join).
+   */
+  get packetIds() {
+    return this.#packetIds;
+  }
+  /**
+   * Replace what the live join delivers with each accepted packet, from the
+   * next packet on. The subscription (socket, group membership, AMT tunnel)
+   * is untouched: this is how an in-place rendition switch moves the router's
+   * ingress identities without leaving and re-joining the group.
+   */
+  setContext(context) {
+    if (this.#subscription === null) {
+      throw new Error(
+        "[MulticastTransport] setContext needs a live join; join() carries the first context"
+      );
+    }
+    this.#context = context;
+  }
+  /**
+   * Replace the live join's packet-ID allow-list in place, without rejoining.
+   *
+   * The page-side filter changes synchronously, before this returns: the
+   * next packet is admitted or dropped by the new list. The provider's own
+   * filter is updated through the subscription's `setPacketIds` when it has
+   * one; the returned promise settles with the provider's acknowledgement of
+   * this update. It resolves at once, telling the provider nothing, only
+   * when the provider cannot be told, or when no earlier update is still in
+   * flight and the provider already forwards exactly this list.
+   *
+   * While an update is in flight the provider's filter is not known, so every
+   * later update is sent: one skipped because it matched the last
+   * acknowledged filter would let the in-flight update land after it, and
+   * leave the provider forwarding a list nobody asked for last. Updates are
+   * numbered in send order and the newest acknowledged one describes the
+   * provider, so an acknowledgement that overtakes an older one is not undone
+   * by it.
+   *
+   * A provider without `setPacketIds` can still be narrowed: its wider filter
+   * keeps delivering the dropped IDs and the page-side filter discards them.
+   * It cannot be widened, since it would never deliver the added IDs; that is
+   * refused with a throw before anything changes. An ID this update withdraws
+   * may keep arriving until the provider applies the narrower list; those
+   * packets are counted as filtered like any other and in
+   * withdrawnPacketIdDrops, but are not unadvertised packet IDs: their
+   * arrival is the expected tail of this change rather than a provisioning
+   * fault.
+   */
+  setPacketIds(packetIds) {
+    const subscription = this.#subscription;
+    const filter = this.#providerFilter;
+    if (subscription === null || filter === null) {
+      throw new Error(
+        "[MulticastTransport] setPacketIds needs a live join; join() carries the first allow-list"
+      );
+    }
+    if (!Array.isArray(packetIds) || packetIds.length === 0) {
+      throw new RangeError(
+        "[MulticastTransport] setPacketIds needs a non-empty packet-ID list: an in-place update names the packet IDs it admits"
+      );
+    }
+    if (!packetIds.every(isMulticastTrackPacketId)) {
+      throw new RangeError(
+        `[MulticastTransport] packetId must be an integer from 1 to ${MMTP_PACKET_ID_MAX2}; packetId 0 is the MMTP signaling flow and is never a track's`
+      );
+    }
+    const next = new Set(packetIds);
+    const provider = filter.acknowledged;
+    const update = packetFilterUpdater(subscription);
+    if (update === void 0 && provider !== null) {
+      const missing = [...next].filter((id) => !provider.has(id));
+      if (missing.length > 0) {
+        throw new Error(
+          `[MulticastTransport] this subscription cannot widen its packet filter in place (the provider exposes no setPacketIds); rejoin to admit ${missing.join(", ")}`
+        );
+      }
+    }
+    const previous = this.#packetIds;
+    this.#packetIds = next;
+    for (const id of next) {
+      this.#withdrawnPacketIds.delete(id);
+      if (!this.#acceptedBytesByPacketId.has(id)) {
+        this.#acceptedBytesByPacketId.set(id, { bytes: 0 });
+      }
+    }
+    if (previous !== null) {
+      for (const id of previous) if (!next.has(id)) this.#withdrawnPacketIds.add(id);
+    }
+    if (update === void 0) return Promise.resolve();
+    if (filter.inFlight === 0 && provider !== null && sameIds(provider, next)) {
+      return Promise.resolve();
+    }
+    const number = ++filter.sent;
+    filter.inFlight++;
+    let applied;
+    try {
+      applied = Promise.resolve(update([...next]));
+    } catch (error) {
+      applied = Promise.reject(error);
+    }
+    return applied.then(
+      () => {
+        if (this.#providerFilter !== filter) return;
+        filter.inFlight--;
+        if (number > filter.acknowledgedUpdate) {
+          filter.acknowledgedUpdate = number;
+          filter.acknowledged = next;
+        }
+      },
+      (error) => {
+        if (this.#providerFilter === filter) filter.inFlight--;
+        throw error;
+      }
+    );
+  }
+  get resolvedTransport() {
+    return this.#resolvedTransport;
+  }
+  dispose() {
+    ++this.#joinGeneration;
+    this.#disposed = true;
+    this.#releaseSubscription();
+  }
+  #releaseSubscription() {
+    if (this.#watchdog) clearTimeout(this.#watchdog);
+    this.#watchdog = null;
+    if (this.#subscription) {
+      const packetListener = this.#packetListener;
+      if (packetListener?.type === "packets") {
+        this.#subscription.removeEventListener("packets", packetListener.listener);
+      } else if (packetListener) {
+        this.#subscription.removeEventListener("bytes", packetListener.listener);
+      }
+      if (this.#errorListener) {
+        this.#subscription.removeEventListener("error", this.#errorListener);
+      }
+      void this.#subscription.unsubscribe();
+    }
+    this.#subscription = null;
+    this.#packetListener = null;
+    this.#errorListener = null;
+    this.#resolvedTransport = void 0;
+    this.#delivery = void 0;
+    this.#packetIds = null;
+    this.#providerFilter = null;
+    this.#context = void 0;
+    this.#withdrawnPacketIds.clear();
+  }
+  /** The ingress filter; an accepted packet is counted here, once. */
+  #acceptPacket(packet) {
+    const packetId = readMMTPPacketId(packet);
+    if (packetId === null) {
+      if (!this.#packetIds) {
+        this.#countAccepted(packet, null);
+        return true;
+      }
+      this.#stats.packetsDroppedUnparseable++;
+      return false;
+    }
+    if (packetId === MMTP_SIGNALING_PACKET_ID2) {
+      this.#stats.packetsDroppedSignaling++;
+      return false;
+    }
+    if (!this.#packetIds || this.#packetIds.has(packetId)) {
+      this.#countAccepted(packet, packetId);
+      return true;
+    }
+    this.#recordUnregisteredPidDrop(packetId);
+    return false;
+  }
+  /** Receive counters for one accepted packet; `packetId` is null when it has none. */
+  #countAccepted(packet, packetId) {
+    this.#stats.packetsReceived++;
+    this.#stats.bytesReceived += packet.byteLength;
+    if (packetId === null) return;
+    const counter = this.#acceptedBytesByPacketId.get(packetId);
+    if (counter !== void 0) {
+      counter.bytes += packet.byteLength;
+    } else {
+      this.#acceptedBytesByPacketId.set(packetId, { bytes: packet.byteLength });
+    }
+  }
+  #recordUnregisteredPidDrop(packetId) {
+    this.#stats.packetsDroppedUnregisteredPid++;
+    const withdrawn = this.#withdrawnPacketIds.has(packetId);
+    if (withdrawn) this.#withdrawnPacketIdDrops++;
+    const seen = this.#droppedPidCounts.get(packetId);
+    if (seen !== void 0) {
+      this.#droppedPidCounts.set(packetId, seen + 1);
+      return;
+    }
+    if (this.#droppedPidCounts.size >= MAX_TRACKED_DROPPED_PIDS) return;
+    this.#droppedPidCounts.set(packetId, 1);
+    if (withdrawn) return;
+    this.#unadvertisedPacketIds.add(packetId);
+    console.warn(
+      `[MulticastTransport] Dropping packetId=${packetId} (0x${packetId.toString(16)}): not in the advertised set [${[...this.#packetIds ?? []].join(", ")}]. If this is an FEC repair leg, the catalog is not advertising its packetId.`
+    );
+  }
+  #checkTakeover() {
+    if (this.#videoConfirmed && this.#audioConfirmed && this.#onTakeover) {
+      const cb = this.#onTakeover;
+      this.#onTakeover = null;
+      cb();
+    }
+  }
+  /**
+   * Note liveness now; arm the no-packets timer if none is armed.
+   *
+   * Called only for accepted packets, so the first call of a join is the
+   * data-plane-live edge and is what first arms the silence window: the window
+   * measures silence of a flowing stream, which is undefined before the stream
+   * has flowed.
+   */
+  #resetWatchdog() {
+    this.#lastPacketAtMs = performance.now();
+    if (!this.#dataPlaneLive) {
+      this.#dataPlaneLive = true;
+      this.#onDataPlaneLive?.();
+    }
+    if (this.#watchdog !== null) return;
+    if (!this.#onFailback) return;
+    if (this.#failbackWindowMs === null) {
+      throw new Error(
+        "[MulticastTransport] Failback watchdog requires a catalog-derived window"
+      );
+    }
+    this.#armWatchdog(this.#failbackWindowMs);
+  }
+  #armWatchdog(delayMs) {
+    this.#watchdog = setTimeout(() => {
+      this.#watchdog = null;
+      if (this.#disposed || !this.#onFailback || this.#failbackWindowMs === null) return;
+      const silentMs = performance.now() - this.#lastPacketAtMs;
+      if (silentMs < this.#failbackWindowMs) {
+        this.#armWatchdog(Math.ceil(this.#failbackWindowMs - silentMs));
+        return;
+      }
+      console.warn(
+        `[MulticastTransport] No packets for ${this.#failbackWindowMs}ms; failing back to MoQ`
+      );
+      this.#onFailback({ kind: "silence", windowMs: this.#failbackWindowMs });
+    }, delayMs);
+  }
+  /** Hand control back to MoQ for a provider-reported subscription failure. */
+  #failBackOnSubscriptionError(error) {
+    if (this.#watchdog !== null) clearTimeout(this.#watchdog);
+    this.#watchdog = null;
+    console.warn("[MulticastTransport] Subscription failed; failing back to MoQ:", error);
+    this.#onFailback?.({ kind: "subscription-error", error });
+  }
+};
+export {
+  MulticastTransport
+};
+//# sourceMappingURL=multicast-transport.js.map