@blockcast/mmt-container 0.1.0-main.342ee38b60e1 → 0.1.0-main.3ca5d1ea196c

package/dist/browser-runtime.js

@@ -1098,9 +1098,12 @@ var MFUReassembler = class {
         state.timeoutId = setTimeout(() => __privateMethod(this, _MFUReassembler_instances, onTimeout_fn).call(this, bufferKey), Math.max(0, state.startedAt + ms - now));
       }
     }
-    for (const address of __privateGet(this, _pendingContinuations).keys()) {
-      __privateMethod(this, _MFUReassembler_instances, clearPendingTimeout_fn).call(this, address);
-      __privateMethod(this, _MFUReassembler_instances, armHeadlessPendingTimeout_fn).call(this, address);
+    for (const [address, pending] of __privateGet(this, _pendingContinuations)) {
+      if (pending.timeoutId !== void 0) clearTimeout(pending.timeoutId);
+      delete pending.timeoutId;
+      if (ms !== null && parkedRunHoldsASlot(__privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address) !== void 0, pending.fragments.size)) {
+        pending.timeoutId = setTimeout(() => __privateMethod(this, _MFUReassembler_instances, onPendingTimeout_fn).call(this, address), Math.max(0, pending.startedAt + ms - now));
+      }
     }
   }
   get timeoutMs() {
@@ -1351,26 +1354,28 @@ parkContinuation_fn = function(address, fragment) {
       __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "active-data-unit-limit", "active MFU data-unit limit reached");
     }
   }
-  let armAfterInsert = false;
+  let reAnchored = false;
   if (pending === void 0) {
     pending = {
       fragments: /* @__PURE__ */ new Map(),
       startedAt: Date.now(),
       admissionSeq: open !== void 0 ? open[1].admissionSeq : __privateWrapper(this, _nextAdmissionSeq)._++
     };
+    if (open === void 0 && __privateGet(this, _timeoutMs) !== null) {
+      pending.timeoutId = setTimeout(() => __privateMethod(this, _MFUReassembler_instances, onPendingTimeout_fn).call(this, address), __privateGet(this, _timeoutMs));
+    }
     __privateGet(this, _pendingContinuations).set(address, pending);
-    armAfterInsert = true;
   } else if (!alreadyCharged) {
     pending.admissionSeq = __privateWrapper(this, _nextAdmissionSeq)._++;
     pending.startedAt = Date.now();
     __privateMethod(this, _MFUReassembler_instances, clearPendingTimeout_fn).call(this, address);
-    armAfterInsert = true;
+    reAnchored = true;
   }
   if (pending.fragments.has(fragment.fragmentCounter)) {
     __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "fragment-counter-mismatch", "duplicate queued continuation counter would replace retained media");
   }
   pending.fragments.set(fragment.fragmentCounter, fragment);
-  if (armAfterInsert) __privateMethod(this, _MFUReassembler_instances, armHeadlessPendingTimeout_fn).call(this, address);
+  if (reAnchored) __privateMethod(this, _MFUReassembler_instances, armHeadlessPendingTimeout_fn).call(this, address);
 };
 drainPendingContinuations_fn = function(address, runKey) {
   while (true) {
@@ -1663,10 +1668,9 @@ clearPendingTimeout_fn = function(address) {
  * from its own first arrival, exactly as it would had the head never come.
  *
  * An empty queue is not armed: it holds no data unit that could fail to
- * complete, so there is nothing for a deadline to expire. Every arming site
- * reaches this function, which takes that test through `parkedRunHoldsASlot`
- * rather than filtering on the open run alone, which is how this engine
- * reaches Rust's answer: its
+ * complete, so there is nothing for a deadline to expire. Both arming sites
+ * take that test through `parkedRunHoldsASlot` rather than filtering on the
+ * open run alone, which is how this engine reaches Rust's answer — its
  * `next_timeout_at` derives candidate deadlines from the queue's live
  * entries, so an empty queue yields none (BLO-32420).
  */
@@ -7777,7 +7781,6 @@ var MmtpToCmaf = class {
     const samplesPerFrame = __privateGet(this, _audioTimescale) !== 1e6 ? __privateGet(this, _aacFrameSamples) : sampleDuration;
     const scaledTs = __privateGet(this, _audioTimescale) !== 1e6 ? __privateGet(this, _audioSampleCount) * samplesPerFrame : timestamp - __privateGet(this, _audioBaseTs);
     __privateWrapper(this, _audioSampleCount)._++;
-    const scaledCompositionTimeOffset = compositionTimeOffset === void 0 || __privateGet(this, _audioTimescale) === 1e6 ? compositionTimeOffset : Math.round(compositionTimeOffset * __privateGet(this, _audioTimescale) / 1e6);
     return encodeDataSegment(
       sampleData,
       scaledTs,
@@ -7785,7 +7788,7 @@ var MmtpToCmaf = class {
       true,
       __privateWrapper(this, _audioSeq)._++,
       1,
-      scaledCompositionTimeOffset
+      compositionTimeOffset
     );
   }
   /** Convert an ordered audio batch using the caller-owned timeline. */
@@ -14915,1333 +14918,6 @@ var ReedSolomonCodec = class {
   }
 };
 
-// node_modules/@blockcast/mmt-transport/dist/types.js
-var MoqFecAlgorithm;
-(function(MoqFecAlgorithm2) {
-  MoqFecAlgorithm2[MoqFecAlgorithm2["None"] = 0] = "None";
-  MoqFecAlgorithm2[MoqFecAlgorithm2["Xor"] = 1] = "Xor";
-  MoqFecAlgorithm2[MoqFecAlgorithm2["RaptorQ"] = 2] = "RaptorQ";
-})(MoqFecAlgorithm || (MoqFecAlgorithm = {}));
-
-// node_modules/@blockcast/mmt-transport/dist/driad-discovery.js
-var DRIADDiscovery = class {
-  constructor() {
-    __publicField(this, "cache", /* @__PURE__ */ new Map());
-    __publicField(this, "cacheExpiry", 3e5);
-  }
-  // 5 minutes
-  /**
-   * Discover AMT relays for a multicast source address (RFC 8777)
-   *
-   * @param source - The multicast source IP address (NOT the group!)
-   * @returns Array of discovered AMT relays that can tunnel traffic from this source
-   */
-  async discoverRelays(source) {
-    const cached = this.cache.get(source);
-    if (cached) {
-      return cached;
-    }
-    try {
-      const reversedSource = source.split(".").reverse().join(".");
-      const queryDomain = `${reversedSource}.amt.in-addr.arpa`;
-      console.log(`[DRIAD] Discovering relays for source ${source} via ${queryDomain}`);
-      const relays = await this.queryDRIADProxy(source);
-      if (relays.length > 0) {
-        this.cache.set(source, relays);
-        setTimeout(() => this.cache.delete(source), this.cacheExpiry);
-      }
-      return relays;
-    } catch (error) {
-      console.warn(`[DRIAD] Discovery failed for source ${source}:`, error);
-      return [];
-    }
-  }
-  /**
-   * Query DRIAD proxy service (browser-compatible)
-   */
-  async queryDRIADProxy(source) {
-    const proxyEndpoints = [
-      "https://driad.amt.net/api/v1/relays",
-      "https://multicast-gateway.cloudflare.com/driad"
-    ];
-    for (const endpoint of proxyEndpoints) {
-      try {
-        const response = await fetch(`${endpoint}?source=${encodeURIComponent(source)}`, {
-          method: "GET",
-          headers: { Accept: "application/json" },
-          signal: AbortSignal.timeout(5e3)
-        });
-        if (response.ok) {
-          const data = await response.json();
-          return data.relays || [];
-        }
-      } catch {
-      }
-    }
-    const dohRelay = await this.queryDNSOverHTTPS(source);
-    if (dohRelay) {
-      return [dohRelay];
-    }
-    return [];
-  }
-  /**
-   * Query DNS-over-HTTPS for DRIAD relay based on source address (RFC 8777)
-   */
-  async queryDNSOverHTTPS(source) {
-    try {
-      const reversedSource = source.split(".").reverse().join(".");
-      const queryName = `${reversedSource}.amt.in-addr.arpa`;
-      const dohUrl = `https://cloudflare-dns.com/dns-query?name=${queryName}&type=A`;
-      const response = await fetch(dohUrl, {
-        headers: { Accept: "application/dns-json" },
-        signal: AbortSignal.timeout(3e3)
-      });
-      if (!response.ok) {
-        return null;
-      }
-      const result = await response.json();
-      if (result.Answer && result.Answer.length > 0) {
-        return {
-          host: result.Answer[0].data,
-          port: 2268,
-          priority: 10,
-          weight: 100,
-          asn: 0
-        };
-      }
-      return null;
-    } catch (error) {
-      console.warn("[DRIAD] DNS-over-HTTPS query failed:", error);
-      return null;
-    }
-  }
-  /**
-   * Select best relay based on RTT measurements
-   */
-  async selectBestRelay(relays) {
-    if (relays.length === 0)
-      return null;
-    const measured = await Promise.all(relays.map(async (relay) => {
-      const rtt = await this.measureRTT(relay.host, relay.port);
-      return { ...relay, rtt };
-    }));
-    measured.sort((a, b) => {
-      if (a.priority !== b.priority)
-        return a.priority - b.priority;
-      return (a.rtt || Infinity) - (b.rtt || Infinity);
-    });
-    console.log(`[DRIAD] Selected relay: ${measured[0].host} (RTT: ${measured[0].rtt}ms)`);
-    return measured[0];
-  }
-  async measureRTT(host, _port) {
-    const start = performance.now();
-    try {
-      await fetch(`https://${host}/health`, {
-        method: "HEAD",
-        signal: AbortSignal.timeout(2e3),
-        mode: "no-cors"
-      });
-      return performance.now() - start;
-    } catch {
-      return Infinity;
-    }
-  }
-  /**
-   * Clear the relay cache
-   */
-  clearCache() {
-    this.cache.clear();
-  }
-  /**
-   * Get cached relays for a source address
-   */
-  getCached(source) {
-    return this.cache.get(source);
-  }
-};
-var driadDiscovery = new DRIADDiscovery();
-
-// node_modules/@blockcast/mmt-transport/dist/multicast-tier.js
-function endpointKey(endpoint) {
-  return `${endpoint.sourceAddress ?? ""}|${endpoint.groupAddress}|${endpoint.port}`;
-}
-function selectMulticastTier(endpoints, estimate) {
-  if (endpoints.length <= 1)
-    return endpoints[0];
-  const ranked = endpoints.filter((endpoint) => typeof endpoint.bandwidth === "number" && endpoint.bandwidth > 0).sort((a, b) => a.bandwidth - b.bandwidth);
-  if (ranked.length < 2)
-    return endpoints[0];
-  if (estimate === void 0)
-    return ranked[0];
-  const budget = estimate * 0.8;
-  let selected;
-  for (const endpoint of ranked) {
-    if (endpoint.bandwidth <= budget)
-      selected = endpoint;
-  }
-  return selected ?? ranked[0];
-}
-
-// node_modules/@blockcast/mmt-transport/dist/abr-controller.js
-var QUALITY_LEVELS = [
-  { name: "240p", bitrate: 3e5, width: 426, height: 240, fps: 15 },
-  { name: "360p", bitrate: 5e5, width: 640, height: 360, fps: 24 },
-  { name: "480p", bitrate: 1e6, width: 854, height: 480, fps: 30 },
-  { name: "720p", bitrate: 25e5, width: 1280, height: 720, fps: 30 },
-  { name: "1080p", bitrate: 5e6, width: 1920, height: 1080, fps: 30 },
-  { name: "1440p", bitrate: 8e6, width: 2560, height: 1440, fps: 30 },
-  { name: "4K", bitrate: 15e6, width: 3840, height: 2160, fps: 30 }
-];
-var AdaptiveBitrateController = class {
-  constructor(initialQuality) {
-    __publicField(this, "currentQualityIndex");
-    __publicField(this, "history", []);
-    __publicField(this, "historyWindow", 1e4);
-    // 10 second window
-    __publicField(this, "upgradeThreshold", 0.8);
-    // 80% of target bitrate sustained
-    __publicField(this, "downgradeThreshold", 0.5);
-    // 50% of target bitrate triggers downgrade
-    __publicField(this, "stabilityPeriod", 5e3);
-    // Wait 5s before upgrading
-    __publicField(this, "lastQualityChange", 0);
-    __publicField(this, "onQualityChange");
-    // FEC stats for effective loss rate calculation
-    __publicField(this, "fecStats", {
-      rawLossRate: 0,
-      effectiveLossRate: 0,
-      recoveryRate: 1,
-      fecEnabled: false
-    });
-    this.currentQualityIndex = initialQuality ? QUALITY_LEVELS.findIndex((q) => q.name === initialQuality.name) : 0;
-    if (this.currentQualityIndex < 0)
-      this.currentQualityIndex = 0;
-  }
-  setCallback(callback) {
-    this.onQualityChange = callback;
-  }
-  getCurrentQuality() {
-    return QUALITY_LEVELS[this.currentQualityIndex];
-  }
-  /** Selects the multicast (S,G) tier without replacing a player's unicast ABR manager. */
-  selectMulticastTier(endpoints, estimate = this.getMetrics().measuredBitrate || void 0) {
-    return selectMulticastTier(endpoints, estimate);
-  }
-  /**
-   * Record network sample for bitrate adaptation
-   *
-   * @param bytesReceived - Bytes received in this sample
-   * @param packetsLost - Packets lost (raw, before FEC recovery)
-   */
-  recordSample(bytesReceived, packetsLost) {
-    const now = Date.now();
-    this.history.push({ timestamp: now, bytesReceived, packetsLost });
-    this.history = this.history.filter((s) => now - s.timestamp < this.historyWindow);
-    const { measuredBitrate, lossRate: rawLossRate } = this.calculateMetrics();
-    const currentQuality = this.getCurrentQuality();
-    const effectiveLossRate = this.fecStats.fecEnabled ? this.fecStats.effectiveLossRate : rawLossRate;
-    if (now - this.lastQualityChange < this.stabilityPeriod) {
-      return;
-    }
-    if (effectiveLossRate > 0.05 || measuredBitrate < currentQuality.bitrate * this.downgradeThreshold) {
-      this.downgrade();
-      return;
-    }
-    if (measuredBitrate > currentQuality.bitrate * this.upgradeThreshold && effectiveLossRate < 0.01 && this.currentQualityIndex < QUALITY_LEVELS.length - 1) {
-      this.upgrade();
-    }
-  }
-  /**
-   * Update FEC statistics for ABR decisions
-   *
-   * Per draft-ramadan-moq-fec-00, ABR should use the effective loss rate
-   * (after FEC recovery) rather than raw transport loss rate.
-   *
-   * @param stats - FEC statistics from the FEC decoder
-   */
-  setFecStats(stats) {
-    this.fecStats = stats;
-  }
-  /**
-   * Get current FEC statistics
-   */
-  getFecStats() {
-    return { ...this.fecStats };
-  }
-  calculateMetrics() {
-    if (this.history.length < 2) {
-      return { measuredBitrate: 0, lossRate: 0 };
-    }
-    const totalBytes = this.history.reduce((sum, s) => sum + s.bytesReceived, 0);
-    const totalLost = this.history.reduce((sum, s) => sum + s.packetsLost, 0);
-    const duration = (this.history[this.history.length - 1].timestamp - this.history[0].timestamp) / 1e3;
-    const measuredBitrate = duration > 0 ? totalBytes * 8 / duration : 0;
-    const lossRate = totalLost / (this.history.length + totalLost);
-    return { measuredBitrate, lossRate };
-  }
-  upgrade() {
-    if (this.currentQualityIndex >= QUALITY_LEVELS.length - 1)
-      return;
-    this.currentQualityIndex++;
-    this.lastQualityChange = Date.now();
-    const newQuality = this.getCurrentQuality();
-    console.log(`[ABR] Upgrading to ${newQuality.name} (${newQuality.bitrate / 1e6}Mbps)`);
-    this.onQualityChange?.(newQuality);
-  }
-  downgrade() {
-    if (this.currentQualityIndex <= 0)
-      return;
-    this.currentQualityIndex--;
-    this.lastQualityChange = Date.now();
-    const newQuality = this.getCurrentQuality();
-    console.log(`[ABR] Downgrading to ${newQuality.name} (${newQuality.bitrate / 1e6}Mbps)`);
-    this.onQualityChange?.(newQuality);
-  }
-  /**
-   * Force quality level (for testing)
-   */
-  setQuality(name) {
-    const index = QUALITY_LEVELS.findIndex((q) => q.name === name);
-    if (index >= 0) {
-      this.currentQualityIndex = index;
-      this.lastQualityChange = Date.now();
-      this.onQualityChange?.(this.getCurrentQuality());
-    }
-  }
-  /**
-   * Get current metrics including both raw and effective loss rates
-   */
-  getMetrics() {
-    const { measuredBitrate, lossRate: rawLossRate } = this.calculateMetrics();
-    return {
-      measuredBitrate,
-      rawLossRate,
-      effectiveLossRate: this.fecStats.fecEnabled ? this.fecStats.effectiveLossRate : rawLossRate,
-      fecEnabled: this.fecStats.fecEnabled,
-      sampleCount: this.history.length
-    };
-  }
-  /**
-   * Reset history and start fresh
-   */
-  reset() {
-    this.history = [];
-    this.lastQualityChange = 0;
-  }
-};
-
-// node_modules/@blockcast/mmt-transport/dist/multicast-orchestrator.js
-var DEFAULT_DWELL_MS = 3e3;
-var DEFAULT_JOIN_DEADLINE_MS = 5e3;
-var _state2, _current, _target, _estimate, _favored, _joinStartedAt, _lastCommittedTimestamp, _dwellMs, _joinDeadlineMs, _MulticastOrchestrator_instances, now_fn;
-var MulticastOrchestrator = class {
-  constructor(options) {
-    __privateAdd(this, _MulticastOrchestrator_instances);
-    __publicField(this, "options");
-    __privateAdd(this, _state2, "stable");
-    __privateAdd(this, _current);
-    __privateAdd(this, _target);
-    __privateAdd(this, _estimate);
-    __privateAdd(this, _favored);
-    __privateAdd(this, _joinStartedAt, 0);
-    __privateAdd(this, _lastCommittedTimestamp, Number.NEGATIVE_INFINITY);
-    __privateAdd(this, _dwellMs);
-    __privateAdd(this, _joinDeadlineMs);
-    this.options = options;
-    __privateSet(this, _dwellMs, options.dwellMs ?? DEFAULT_DWELL_MS);
-    __privateSet(this, _joinDeadlineMs, options.joinDeadlineMs ?? DEFAULT_JOIN_DEADLINE_MS);
-    if (!Number.isFinite(__privateGet(this, _dwellMs)) || !Number.isFinite(__privateGet(this, _joinDeadlineMs)) || __privateGet(this, _dwellMs) <= 0 || __privateGet(this, _joinDeadlineMs) <= 0) {
-      throw new Error("Multicast dwell and join deadline must be positive");
-    }
-  }
-  get state() {
-    return __privateGet(this, _state2);
-  }
-  get current() {
-    return __privateGet(this, _current);
-  }
-  get target() {
-    return __privateGet(this, _target);
-  }
-  get estimate() {
-    return __privateGet(this, _estimate);
-  }
-  start() {
-    __privateGet(this, _current) ?? __privateSet(this, _current, this.options.initialEndpoint ?? selectMulticastTier(this.options.endpoints, void 0));
-    return __privateGet(this, _current);
-  }
-  onGoodput(sample) {
-    const bitrate = sample.bitrate;
-    if (!__privateGet(this, _current) || this.options.adaptive === false)
-      return void 0;
-    if (__privateGet(this, _state2) === "joining")
-      return this.poll();
-    if (bitrate === void 0 || !Number.isFinite(bitrate))
-      return void 0;
-    __privateSet(this, _estimate, bitrate);
-    const desired = selectMulticastTier(this.options.endpoints, bitrate);
-    if (!desired)
-      return void 0;
-    const desiredKey = endpointKey(desired);
-    if (desiredKey === endpointKey(__privateGet(this, _current))) {
-      if (__privateGet(this, _favored)?.source === "goodput")
-        __privateSet(this, _favored, void 0);
-      return void 0;
-    }
-    if (typeof desired.bandwidth !== "number" || typeof __privateGet(this, _current).bandwidth !== "number" || desired.bandwidth >= __privateGet(this, _current).bandwidth) {
-      if (__privateGet(this, _favored)?.source === "goodput")
-        __privateSet(this, _favored, void 0);
-      return void 0;
-    }
-    const now = __privateMethod(this, _MulticastOrchestrator_instances, now_fn).call(this);
-    if (!__privateGet(this, _favored) || __privateGet(this, _favored).key !== desiredKey || __privateGet(this, _favored).source !== "goodput") {
-      __privateSet(this, _favored, { key: desiredKey, since: now, source: "goodput" });
-      return void 0;
-    }
-    if (now - __privateGet(this, _favored).since < __privateGet(this, _dwellMs))
-      return void 0;
-    __privateSet(this, _state2, "joining");
-    __privateSet(this, _target, desired);
-    __privateSet(this, _joinStartedAt, now);
-    __privateSet(this, _favored, void 0);
-    return { kind: "join-target", current: __privateGet(this, _current), target: desired };
-  }
-  onHeadroom(sample) {
-    if (!__privateGet(this, _current) || this.options.adaptive === false || __privateGet(this, _state2) === "joining")
-      return void 0;
-    if (!sample.healthy) {
-      if (__privateGet(this, _favored)?.source === "headroom")
-        __privateSet(this, _favored, void 0);
-      return void 0;
-    }
-    if (__privateGet(this, _favored)?.source === "goodput")
-      return void 0;
-    const currentBandwidth = __privateGet(this, _current).bandwidth;
-    if (typeof currentBandwidth !== "number")
-      return void 0;
-    const desired = this.options.endpoints.filter((endpoint) => typeof endpoint.bandwidth === "number" && endpoint.bandwidth > currentBandwidth).sort((a, b) => a.bandwidth - b.bandwidth)[0];
-    if (!desired) {
-      __privateSet(this, _favored, void 0);
-      return void 0;
-    }
-    const desiredKey = endpointKey(desired);
-    if (desiredKey === endpointKey(__privateGet(this, _current))) {
-      __privateSet(this, _favored, void 0);
-      return void 0;
-    }
-    const now = __privateMethod(this, _MulticastOrchestrator_instances, now_fn).call(this);
-    if (!__privateGet(this, _favored) || __privateGet(this, _favored).key !== desiredKey) {
-      __privateSet(this, _favored, { key: desiredKey, since: now, source: "headroom" });
-      return void 0;
-    }
-    if (now - __privateGet(this, _favored).since < __privateGet(this, _dwellMs))
-      return void 0;
-    __privateSet(this, _state2, "joining");
-    __privateSet(this, _target, desired);
-    __privateSet(this, _joinStartedAt, now);
-    __privateSet(this, _favored, void 0);
-    return { kind: "join-target", current: __privateGet(this, _current), target: desired };
-  }
-  onTierPacket(packet) {
-    if (!__privateGet(this, _current))
-      return void 0;
-    if (packet.endpointKey === endpointKey(__privateGet(this, _current)) && Number.isFinite(packet.timestamp)) {
-      __privateSet(this, _lastCommittedTimestamp, Math.max(__privateGet(this, _lastCommittedTimestamp), packet.timestamp));
-    }
-    if (__privateGet(this, _state2) !== "joining" || !__privateGet(this, _target))
-      return void 0;
-    const expired = this.poll();
-    if (expired)
-      return expired;
-    if (packet.endpointKey !== endpointKey(__privateGet(this, _target)) || !packet.keyframe || !packet.hasValidCodecConfig || !Number.isFinite(packet.timestamp) || packet.timestamp < __privateGet(this, _lastCommittedTimestamp))
-      return void 0;
-    const command = {
-      kind: "commit-swap",
-      target: __privateGet(this, _target),
-      old: __privateGet(this, _current)
-    };
-    __privateSet(this, _lastCommittedTimestamp, packet.timestamp);
-    __privateSet(this, _current, __privateGet(this, _target));
-    __privateSet(this, _target, void 0);
-    __privateSet(this, _state2, "stable");
-    return command;
-  }
-  poll() {
-    if (__privateGet(this, _state2) !== "joining" || !__privateGet(this, _target) || !__privateGet(this, _current))
-      return void 0;
-    if (__privateMethod(this, _MulticastOrchestrator_instances, now_fn).call(this) - __privateGet(this, _joinStartedAt) < __privateGet(this, _joinDeadlineMs))
-      return void 0;
-    return this.cancel();
-  }
-  cancel() {
-    if (__privateGet(this, _state2) !== "joining" || !__privateGet(this, _target) || !__privateGet(this, _current))
-      return void 0;
-    const command = {
-      kind: "abandon-join",
-      current: __privateGet(this, _current),
-      target: __privateGet(this, _target)
-    };
-    __privateSet(this, _target, void 0);
-    __privateSet(this, _state2, "stable");
-    return command;
-  }
-};
-_state2 = new WeakMap();
-_current = new WeakMap();
-_target = new WeakMap();
-_estimate = new WeakMap();
-_favored = new WeakMap();
-_joinStartedAt = new WeakMap();
-_lastCommittedTimestamp = new WeakMap();
-_dwellMs = new WeakMap();
-_joinDeadlineMs = new WeakMap();
-_MulticastOrchestrator_instances = new WeakSet();
-now_fn = function() {
-  const now = this.options.now();
-  if (!Number.isFinite(now))
-    throw new Error("Multicast orchestrator clock must be finite");
-  return now;
-};
-
-// node_modules/@blockcast/mmt-transport/dist/endpoint-config.js
-function toWindowMulticastSubscribeConfig(input) {
-  if (input.mode !== void 0 && !["auto", "native", "tunnel"].includes(input.mode)) {
-    throw new TypeError(`Unsupported multicast mode: ${String(input.mode)}`);
-  }
-  const base = {
-    group: input.group,
-    port: input.port,
-    ...input.source?.trim() ? { source: input.source.trim() } : {},
-    consume: "bytes",
-    ...input.packetIds?.length ? { packetIds: [...input.packetIds] } : {}
-  };
-  const relay = input.amtRelay?.trim();
-  const wantsAmt = input.mode === "tunnel" || input.mode !== "native" && relay !== void 0 && relay !== "";
-  if (!wantsAmt) {
-    const native = {
-      ...base,
-      origin: "ip-multicast",
-      ...input.tracks?.length ? { tracks: input.tracks.map(({ name, packetId }) => ({ name, packetId })) } : {}
-    };
-    return native;
-  }
-  const relayPort = input.amtRelayPort;
-  if (!relay || relayPort === void 0 || !isPositivePort(relayPort)) {
-    throw new TypeError("AMT requires a resolved relay and a valid relay port");
-  }
-  return {
-    ...base,
-    origin: "amt",
-    relay,
-    relayPort
-  };
-}
-function isValidMulticastGroupAddress(address) {
-  const value = address?.trim().toLowerCase();
-  if (!value)
-    return false;
-  if (value.startsWith("ff"))
-    return isValidIpv6MulticastAddress(value);
-  const parts = value.split(".");
-  if (parts.length !== 4)
-    return false;
-  const octets = parts.map((part) => {
-    if (!/^\d+$/.test(part))
-      return Number.NaN;
-    const octet = Number(part);
-    return Number.isInteger(octet) && octet >= 0 && octet <= 255 ? octet : Number.NaN;
-  });
-  return octets.every(Number.isInteger) && octets[0] >= 224 && octets[0] <= 239;
-}
-function normalizeMulticastEndpoint(endpoint) {
-  const groupAddress = endpoint.groupAddress.trim().toLowerCase();
-  const sourceAddress = endpoint.sourceAddress?.trim().toLowerCase() || void 0;
-  const amtRelay = endpoint.amtRelay?.trim().toLowerCase() || void 0;
-  if (!isValidMulticastGroupAddress(groupAddress) || !isPositivePort(endpoint.port))
-    return void 0;
-  if (endpoint.mode && !["auto", "native", "tunnel"].includes(endpoint.mode))
-    return void 0;
-  if (endpoint.amtRelayPort !== void 0 && !isPositivePort(endpoint.amtRelayPort))
-    return void 0;
-  return {
-    groupAddress,
-    ...sourceAddress ? { sourceAddress } : {},
-    port: endpoint.port,
-    ...endpoint.mode ? { mode: endpoint.mode } : {},
-    ...amtRelay ? { amtRelay } : {},
-    ...endpoint.amtRelayPort ? { amtRelayPort: endpoint.amtRelayPort } : {}
-  };
-}
-function multicastEndpointKey(endpoint) {
-  const normalized = normalizeMulticastEndpoint(endpoint);
-  if (!normalized)
-    throw new Error("Invalid multicast endpoint");
-  return JSON.stringify([
-    normalized.sourceAddress ?? "",
-    normalized.groupAddress,
-    normalized.port,
-    normalized.mode ?? "auto",
-    normalized.amtRelay ?? "",
-    normalized.amtRelayPort ?? ""
-  ]);
-}
-function isValidIpv6MulticastAddress(value) {
-  if (!/^[0-9a-f:]+$/.test(value))
-    return false;
-  const compressed = value.includes("::");
-  if (value.indexOf("::") !== value.lastIndexOf("::"))
-    return false;
-  const groups = value.split(":").filter(Boolean);
-  if (groups.length === 0 || groups.length > 8)
-    return false;
-  if (!compressed && groups.length !== 8)
-    return false;
-  return groups.every((group) => /^[0-9a-f]{1,4}$/.test(group));
-}
-function isPositivePort(port) {
-  return Number.isInteger(port) && port > 0 && port <= 65535;
-}
-
-// node_modules/@blockcast/mmt-transport/dist/multicast-subscription-pool.js
-var _entries, _gatewayIds, _nextGatewayId, _MulticastSubscriptionPool_instances, createEntry_fn, gatewayId_fn, detach_fn, dispatch_fn;
-var MulticastSubscriptionPool = class {
-  constructor() {
-    __privateAdd(this, _MulticastSubscriptionPool_instances);
-    __privateAdd(this, _entries, /* @__PURE__ */ new Map());
-    __privateAdd(this, _gatewayIds, /* @__PURE__ */ new WeakMap());
-    __privateAdd(this, _nextGatewayId, 1);
-  }
-  async acquire(gateway, config, consumer) {
-    const endpoint = normalizeMulticastEndpoint({
-      groupAddress: config.group,
-      sourceAddress: config.source,
-      port: config.port,
-      mode: config.mode,
-      amtRelay: config.amtRelay,
-      amtRelayPort: config.amtRelayPort
-    });
-    if (!endpoint)
-      throw new Error("Invalid multicast endpoint");
-    if (typeof gateway.subscribe !== "function")
-      throw new Error("window.multicast.subscribe unavailable");
-    const key = multicastEndpointKey(endpoint);
-    const internalKey = `${__privateMethod(this, _MulticastSubscriptionPool_instances, gatewayId_fn).call(this, gateway)}|${key}`;
-    let record = __privateGet(this, _entries).get(internalKey);
-    if (!record) {
-      record = { claims: 0, entry: Promise.resolve(null) };
-      const createdRecord = record;
-      record.entry = __privateMethod(this, _MulticastSubscriptionPool_instances, createEntry_fn).call(this, gateway, endpoint, (entry2) => {
-        if (__privateGet(this, _entries).get(internalKey) === createdRecord)
-          __privateGet(this, _entries).delete(internalKey);
-        __privateMethod(this, _MulticastSubscriptionPool_instances, detach_fn).call(this, entry2);
-      }).catch((error) => {
-        if (__privateGet(this, _entries).get(internalKey) === createdRecord)
-          __privateGet(this, _entries).delete(internalKey);
-        throw error;
-      });
-      __privateGet(this, _entries).set(internalKey, record);
-    }
-    record.claims++;
-    let entry;
-    try {
-      entry = await record.entry;
-    } catch (error) {
-      record.claims--;
-      throw error;
-    }
-    if (entry.closed) {
-      record.claims--;
-      return this.acquire(gateway, config, consumer);
-    }
-    const token = Symbol(key);
-    entry.consumers.set(token, consumer);
-    let released = false;
-    return {
-      key,
-      release: async () => {
-        if (released)
-          return;
-        released = true;
-        entry.consumers.delete(token);
-        record.claims--;
-        if (record.claims > 0)
-          return;
-        if (__privateGet(this, _entries).get(internalKey) === record)
-          __privateGet(this, _entries).delete(internalKey);
-        __privateMethod(this, _MulticastSubscriptionPool_instances, detach_fn).call(this, entry);
-        if (!entry.closed)
-          await entry.subscription.unsubscribe();
-      }
-    };
-  }
-  get size() {
-    return __privateGet(this, _entries).size;
-  }
-};
-_entries = new WeakMap();
-_gatewayIds = new WeakMap();
-_nextGatewayId = new WeakMap();
-_MulticastSubscriptionPool_instances = new WeakSet();
-createEntry_fn = async function(gateway, endpoint, onClosed) {
-  const subscription = await gateway.subscribe(toWindowMulticastSubscribeConfig({
-    group: endpoint.groupAddress,
-    ...endpoint.sourceAddress ? { source: endpoint.sourceAddress } : {},
-    port: endpoint.port,
-    ...endpoint.mode ? { mode: endpoint.mode } : {},
-    ...endpoint.amtRelay ? { amtRelay: endpoint.amtRelay } : {},
-    ...endpoint.amtRelayPort ? { amtRelayPort: endpoint.amtRelayPort } : {}
-  }));
-  const consumers = /* @__PURE__ */ new Map();
-  let entry;
-  const bytesListener = (event) => {
-    __privateMethod(this, _MulticastSubscriptionPool_instances, dispatch_fn).call(this, consumers, (consumer) => consumer.onBytes(event.detail));
-  };
-  const stateListener = (event) => {
-    __privateMethod(this, _MulticastSubscriptionPool_instances, dispatch_fn).call(this, consumers, (consumer) => consumer.onState?.(event.detail));
-    if (event.detail === "closed" && !entry.closed) {
-      entry.closed = true;
-      onClosed(entry);
-    }
-  };
-  const errorListener = (event) => {
-    const error = event.detail instanceof Error ? event.detail : new Error(String(event.detail));
-    __privateMethod(this, _MulticastSubscriptionPool_instances, dispatch_fn).call(this, consumers, (consumer) => consumer.onError?.(error));
-  };
-  entry = { subscription, consumers, bytesListener, stateListener, errorListener, closed: false };
-  subscription.addEventListener("bytes", bytesListener);
-  subscription.addEventListener("state", stateListener);
-  subscription.addEventListener("error", errorListener);
-  return entry;
-};
-gatewayId_fn = function(gateway) {
-  const object = gateway;
-  let id = __privateGet(this, _gatewayIds).get(object);
-  if (!id) {
-    id = __privateWrapper(this, _nextGatewayId)._++;
-    __privateGet(this, _gatewayIds).set(object, id);
-  }
-  return id;
-};
-detach_fn = function(entry) {
-  entry.subscription.removeEventListener("bytes", entry.bytesListener);
-  entry.subscription.removeEventListener("state", entry.stateListener);
-  entry.subscription.removeEventListener("error", entry.errorListener);
-};
-dispatch_fn = function(consumers, callback) {
-  for (const consumer of consumers.values()) {
-    try {
-      callback(consumer);
-    } catch (error) {
-      console.error("[Transport] multicast consumer callback failed", error);
-    }
-  }
-};
-var multicastSubscriptionPool = new MulticastSubscriptionPool();
-
-// node_modules/@blockcast/mmt-transport/dist/transport-manager.js
-var TransportManager = class {
-  constructor() {
-    __publicField(this, "state", {
-      mode: "disconnected",
-      connected: false,
-      packetsReceived: 0,
-      bytesReceived: 0,
-      lastPacketTime: 0
-    });
-    __publicField(this, "capabilities", null);
-    __publicField(this, "subscription", null);
-    __publicField(this, "driad", new DRIADDiscovery());
-    __publicField(this, "abr");
-    __publicField(this, "multicastOrchestrator", null);
-    __publicField(this, "onOrchestratorCommand");
-    __publicField(this, "connectionGeneration", 0);
-    __publicField(this, "onPacket");
-    __publicField(this, "onError");
-    __publicField(this, "onStateChange");
-    this.abr = new AdaptiveBitrateController();
-  }
-  getWindow() {
-    return typeof window === "undefined" ? void 0 : window;
-  }
-  getWindowMulticastGateway() {
-    return this.getWindow()?.multicast;
-  }
-  async getGatewayCapabilities(gateway) {
-    if (!gateway?.capabilities)
-      return void 0;
-    try {
-      return typeof gateway.capabilities === "function" ? await gateway.capabilities() : gateway.capabilities;
-    } catch (error) {
-      console.warn("[Transport] window.multicast capabilities failed:", error);
-      return void 0;
-    }
-  }
-  async gatewaySupportsBytes(gateway) {
-    if (typeof gateway?.subscribe !== "function")
-      return false;
-    if (!gateway.capabilities)
-      return true;
-    const capabilities = await this.getGatewayCapabilities(gateway);
-    if (!capabilities)
-      return false;
-    const consumeModes = capabilities.consumeModes;
-    return !consumeModes || consumeModes.includes("bytes");
-  }
-  /**
-   * Detect available transport capabilities
-   */
-  async detectCapabilities() {
-    if (this.capabilities)
-      return this.capabilities;
-    const gateway = this.getWindowMulticastGateway();
-    const hasGatewayBytes = await this.gatewaySupportsBytes(gateway);
-    const win = this.getWindow();
-    this.capabilities = {
-      nativeSSM: hasGatewayBytes,
-      nativeIGMP: hasGatewayBytes,
-      directSockets: typeof win?.UDPSocket !== "undefined",
-      amt: false,
-      driad: true,
-      // DRIAD uses HTTP proxy, always available
-      fecDecode: false
-    };
-    console.log("[Transport] Capabilities:", this.capabilities);
-    return this.capabilities;
-  }
-  /**
-   * Connect using best available transport
-   *
-   * Promotion hierarchy:
-   * 1. window.multicast gateway bytes
-   * 2. AMT proxy (specified or discovered via DRIAD)
-   * 3. MOQ WebTransport (final fallback)
-   */
-  async connect(config) {
-    const generation = ++this.connectionGeneration;
-    this.subscription?.close();
-    this.subscription = null;
-    this.state = {
-      mode: "disconnected",
-      connected: false,
-      packetsReceived: 0,
-      bytesReceived: 0,
-      lastPacketTime: 0
-    };
-    this.onStateChange?.(this.state);
-    const endpoint = normalizeMulticastEndpoint({
-      groupAddress: config.group,
-      sourceAddress: config.source,
-      port: config.port,
-      mode: config.mode,
-      amtRelay: config.amtRelay,
-      amtRelayPort: config.amtRelayPort
-    });
-    if (!endpoint) {
-      const error = new Error("Invalid multicast endpoint configuration");
-      this.onError?.(error);
-      return false;
-    }
-    config = {
-      ...config,
-      group: endpoint.groupAddress,
-      source: endpoint.sourceAddress ?? "",
-      mode: endpoint.mode,
-      amtRelay: endpoint.amtRelay,
-      amtRelayPort: endpoint.amtRelayPort
-    };
-    const caps = await this.detectCapabilities();
-    if (generation !== this.connectionGeneration)
-      return false;
-    if (config.initialQuality) {
-      this.abr = new AdaptiveBitrateController(config.initialQuality);
-    }
-    this.abr.setCallback((quality) => {
-      this.state.quality = quality;
-      this.subscription?.onqualitychange?.(quality);
-      this.onStateChange?.(this.state);
-    });
-    let connected = false;
-    if (caps.nativeSSM || caps.nativeIGMP) {
-      console.log("[Transport] Attempting window.multicast...");
-      connected = await this.connectWindowMulticast(config, generation);
-      if (connected) {
-        if (generation !== this.connectionGeneration)
-          return false;
-        this.state.mode = "multicast";
-        return true;
-      }
-    }
-    if (!connected) {
-      console.log("[Transport] Attempting AMT tunnel...");
-      connected = await this.connectAmt(config, generation);
-      if (connected) {
-        if (generation !== this.connectionGeneration)
-          return false;
-        this.state.mode = "amt";
-        return true;
-      }
-    }
-    console.log("[Transport] All multicast transports failed, falling back to MOQ");
-    return false;
-  }
-  /**
-   * Connect via the lowercase window.multicast bytes gateway.
-   */
-  async connectWindowMulticast(config, generation) {
-    try {
-      const gateway = this.getWindowMulticastGateway();
-      if (typeof gateway?.subscribe !== "function")
-        return false;
-      const lease = await multicastSubscriptionPool.acquire(gateway, config, {
-        onBytes: (data) => {
-          if (generation === this.connectionGeneration)
-            this.handlePacket(data);
-        },
-        onState: (state) => {
-          if (generation !== this.connectionGeneration)
-            return;
-          this.state.connected = state !== "closed";
-          this.onStateChange?.(this.state);
-        },
-        onError: (error) => {
-          if (generation !== this.connectionGeneration)
-            return;
-          console.error("[Transport] window.multicast error:", error);
-          this.onError?.(error);
-        }
-      });
-      if (generation !== this.connectionGeneration) {
-        await lease.release();
-        return false;
-      }
-      this.subscription = {
-        id: lease.key,
-        config,
-        close: () => {
-          void lease.release();
-        }
-      };
-      this.state = {
-        mode: "multicast",
-        connected: true,
-        group: config.group,
-        source: config.source,
-        quality: this.abr.getCurrentQuality(),
-        packetsReceived: 0,
-        bytesReceived: 0,
-        lastPacketTime: 0
-      };
-      console.log(`[Transport] Connected via window.multicast: (${config.source}, ${config.group})`);
-      this.onStateChange?.(this.state);
-      return true;
-    } catch (error) {
-      console.warn("[Transport] window.multicast failed:", error);
-      return false;
-    }
-  }
-  /**
-   * Connect via AMT proxy (with optional DRIAD discovery)
-   */
-  async connectAmt(config, generation) {
-    try {
-      let amtRelay = config.amtRelay;
-      if (!amtRelay && config.driadEnabled !== false && config.source) {
-        console.log(`[Transport] Discovering AMT relay via DRIAD for source ${config.source}...`);
-        const relays = await this.driad.discoverRelays(config.source);
-        if (generation !== this.connectionGeneration)
-          return false;
-        const bestRelay = await this.driad.selectBestRelay(relays);
-        if (generation !== this.connectionGeneration)
-          return false;
-        if (bestRelay) {
-          amtRelay = bestRelay.host;
-          this.state.amtRelay = amtRelay;
-        }
-      }
-      if (!amtRelay) {
-        console.warn("[Transport] No AMT relay available (DRIAD requires source address for SSM)");
-        return false;
-      }
-      return await this.connectAmtProxy(config, amtRelay, generation);
-    } catch (error) {
-      console.warn("[Transport] AMT connection failed:", error);
-      return false;
-    }
-  }
-  /**
-   * Connect via WebSocket-based AMT proxy (browser fallback)
-   */
-  async connectAmtProxy(config, amtRelay, generation) {
-    try {
-      const relayHost = amtRelay.includes(":") && !amtRelay.startsWith("[") ? `[${amtRelay}]` : amtRelay;
-      const relayAuthority = config.amtRelayPort ? `${relayHost}:${config.amtRelayPort}` : relayHost;
-      const wsUrl = new URL(`wss://${relayAuthority}/amt-proxy`);
-      wsUrl.searchParams.set("group", config.group);
-      wsUrl.searchParams.set("source", config.source || "");
-      wsUrl.searchParams.set("port", String(config.port));
-      const ws = new WebSocket(wsUrl);
-      return new Promise((resolve, reject) => {
-        ws.binaryType = "arraybuffer";
-        const timeout = setTimeout(() => {
-          ws.close();
-          reject(new Error("AMT proxy connection timeout"));
-        }, 1e4);
-        ws.onopen = () => {
-          clearTimeout(timeout);
-          if (generation !== this.connectionGeneration) {
-            ws.close();
-            resolve(false);
-            return;
-          }
-          console.log(`[Transport] Connected to AMT proxy: ${amtRelay}`);
-          this.subscription = {
-            id: `amt-proxy-${Date.now()}`,
-            config,
-            close: () => ws.close()
-          };
-          this.state = {
-            mode: "amt",
-            connected: true,
-            group: config.group,
-            source: config.source,
-            amtRelay,
-            quality: this.abr.getCurrentQuality(),
-            packetsReceived: 0,
-            bytesReceived: 0,
-            lastPacketTime: 0
-          };
-          this.onStateChange?.(this.state);
-          resolve(true);
-        };
-        ws.onmessage = (event) => {
-          if (generation === this.connectionGeneration && event.data instanceof ArrayBuffer) {
-            this.handlePacket(event.data);
-          }
-        };
-        ws.onerror = (error) => {
-          clearTimeout(timeout);
-          if (generation !== this.connectionGeneration) {
-            resolve(false);
-            return;
-          }
-          console.error("[Transport] AMT proxy error:", error);
-          reject(error);
-        };
-        ws.onclose = () => {
-          clearTimeout(timeout);
-          if (generation !== this.connectionGeneration) {
-            resolve(false);
-            return;
-          }
-          this.state.connected = false;
-          this.onStateChange?.(this.state);
-          resolve(false);
-        };
-      });
-    } catch (error) {
-      console.warn("[Transport] AMT proxy failed:", error);
-      return false;
-    }
-  }
-  /**
-   * Handle received packet
-   */
-  handlePacket(data) {
-    this.state.packetsReceived++;
-    this.state.bytesReceived += data.byteLength;
-    this.state.lastPacketTime = Date.now();
-    this.abr.recordSample(data.byteLength, 0);
-    this.onPacket?.(data);
-  }
-  /**
-   * Get current transport state
-   */
-  getState() {
-    return { ...this.state };
-  }
-  /**
-   * Get current quality level
-   */
-  getQuality() {
-    return this.abr.getCurrentQuality();
-  }
-  /**
-   * Force quality level
-   */
-  setQuality(name) {
-    this.abr.setQuality(name);
-  }
-  /** Configures multicast-only ABR while leaving the caller's MoQ ABR untouched. */
-  configureMulticastTiers(options, onCommand) {
-    this.dispatchOrchestratorCommand(this.multicastOrchestrator?.cancel());
-    this.multicastOrchestrator = new MulticastOrchestrator(options);
-    this.onOrchestratorCommand = onCommand;
-    return this.multicastOrchestrator.start();
-  }
-  recordMulticastGoodput(bitrate) {
-    return this.dispatchOrchestratorCommand(this.multicastOrchestrator?.onGoodput({ bitrate }));
-  }
-  recordMulticastHeadroom(healthy) {
-    return this.dispatchOrchestratorCommand(this.multicastOrchestrator?.onHeadroom({ healthy }));
-  }
-  recordMulticastTierPacket(packet) {
-    return this.dispatchOrchestratorCommand(this.multicastOrchestrator?.onTierPacket(packet));
-  }
-  pollMulticastTierSwitch() {
-    return this.dispatchOrchestratorCommand(this.multicastOrchestrator?.poll());
-  }
-  /**
-   * Set packet callback
-   */
-  setPacketCallback(callback) {
-    this.onPacket = callback;
-  }
-  /**
-   * Set error callback
-   */
-  setErrorCallback(callback) {
-    this.onError = callback;
-  }
-  /**
-   * Set state change callback
-   */
-  setStateCallback(callback) {
-    this.onStateChange = callback;
-  }
-  /**
-   * Disconnect
-   */
-  disconnect() {
-    this.connectionGeneration++;
-    this.subscription?.close();
-    this.subscription = null;
-    this.dispatchOrchestratorCommand(this.multicastOrchestrator?.cancel());
-    this.multicastOrchestrator = null;
-    this.onOrchestratorCommand = void 0;
-    this.state = {
-      mode: "disconnected",
-      connected: false,
-      packetsReceived: 0,
-      bytesReceived: 0,
-      lastPacketTime: 0
-    };
-    this.onStateChange?.(this.state);
-  }
-  dispatchOrchestratorCommand(command) {
-    if (command)
-      this.onOrchestratorCommand?.(command);
-    return command;
-  }
-};
-var transportManager = new TransportManager();
-
-// node_modules/@blockcast/mmt-transport/dist/moqt-priority.js
-var MAX_MOQT_PRIORITY = 255;
-function moqtPriority(value, field) {
-  if (!Number.isInteger(value) || value < 0 || value > MAX_MOQT_PRIORITY) {
-    throw new RangeError(`${field} must be an integer in [0, ${MAX_MOQT_PRIORITY}], got ${value}`);
-  }
-  return value;
-}
-function moqtSubscriberPriority(value) {
-  return moqtPriority(value, "MOQT subscriber priority");
-}
-function moqtPublisherPriority(value) {
-  return moqtPriority(value, "MOQT publisher priority");
-}
-var MOQT_SUBSCRIBER_PRIORITY = Object.freeze({
-  catalog: moqtSubscriberPriority(0),
-  deadlineRepair: moqtSubscriberPriority(0),
-  audio: moqtSubscriberPriority(1),
-  video: moqtSubscriberPriority(2),
-  backgroundRepair: moqtSubscriberPriority(3)
-});
-var MOQT_PUBLISHER_PRIORITY = Object.freeze({
-  catalog: moqtPublisherPriority(32),
-  source: moqtPublisherPriority(128),
-  repair: moqtPublisherPriority(240)
-});
-
-// node_modules/@blockcast/mmt-transport/dist/amt-gateway.js
-var DEFAULT_AMT_PORT = 2268;
-var AMTGatewayManager = class {
-  constructor() {
-    __publicField(this, "subscriptions", /* @__PURE__ */ new Map());
-    __publicField(this, "messageHandler");
-    __publicField(this, "pendingPackets", /* @__PURE__ */ new Map());
-    __publicField(this, "driad", new DRIADDiscovery());
-    this.messageHandler = (event) => {
-      const data = event.data;
-      console.log(`[AMT] SW message received:`, data.type);
-      if (data.type === "UDP_PACKET") {
-        this.handlePacket(data);
-      } else if (data.type === "SOCKET_ERROR") {
-        this.handleSocketError(data);
-      } else if (data.type === "DEBUG_LOG") {
-        console.log(`[AMT SW Debug] ${data.message}`);
-      }
-    };
-    if (typeof navigator !== "undefined" && navigator.serviceWorker) {
-      navigator.serviceWorker.addEventListener("message", this.messageHandler);
-      console.log("[AMT] Registered service worker message handler");
-    } else {
-      console.warn("[AMT] Service worker not available");
-    }
-  }
-  /**
-   * Subscribe via AMT tunnel
-   */
-  async subscribe(config) {
-    const { key } = config;
-    const keyStr = this.getKeyString(key);
-    if (this.subscriptions.has(keyStr)) {
-      console.log(`[AMT] Reusing existing subscription to ${keyStr}`);
-      return keyStr;
-    }
-    try {
-      let relayAddress;
-      let discoveryMethod;
-      const relayPort = config.relayPort || DEFAULT_AMT_PORT;
-      if (config.relayAddress) {
-        relayAddress = config.relayAddress;
-        discoveryMethod = "manual";
-        console.log(`[AMT] Using configured relay ${relayAddress}:${relayPort}`);
-      } else if (key.source) {
-        console.log(`[AMT] No relay configured, discovering via DRIAD for source ${key.source}...`);
-        const relays = await this.driad.discoverRelays(key.source);
-        const bestRelay = await this.driad.selectBestRelay(relays);
-        if (!bestRelay) {
-          throw new Error(`AMT relay discovery failed for source ${key.source}. Please specify a relay address in the subscription configuration.`);
-        }
-        relayAddress = bestRelay.host;
-        discoveryMethod = "driad";
-        console.log(`[AMT] Discovered relay via DRIAD: ${relayAddress}:${relayPort}`);
-      } else {
-        throw new Error(`AMT relay discovery requires a source address for SSM (RFC 8777). Please specify either a relay address or source address.`);
-      }
-      const subscriptionId = keyStr;
-      this.pendingPackets.set(subscriptionId, []);
-      const subscription = {
-        key,
-        subscriptionId,
-        config,
-        handshakeComplete: false,
-        relay: {
-          address: relayAddress,
-          port: relayPort,
-          discoveryMethod,
-          discoveredAt: Date.now()
-        }
-      };
-      this.subscriptions.set(keyStr, subscription);
-      console.log(`[AMT] Subscription created for ${keyStr} via ${relayAddress}:${relayPort}`);
-      return keyStr;
-    } catch (error) {
-      const subscription = this.subscriptions.get(keyStr);
-      if (subscription) {
-        this.subscriptions.delete(keyStr);
-        this.pendingPackets.delete(subscription.subscriptionId);
-      }
-      throw new Error(`Failed to subscribe via AMT: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  /**
-   * Unsubscribe from AMT tunnel
-   */
-  async unsubscribe(handle) {
-    const subscription = this.subscriptions.get(handle);
-    if (!subscription) {
-      throw new Error(`Subscription ${handle} not found`);
-    }
-    try {
-      if (subscription.keepAliveTimer) {
-        clearInterval(subscription.keepAliveTimer);
-      }
-      console.log(`[AMT] Unsubscribed from ${handle}`);
-    } catch (error) {
-      console.error("[AMT] Error during unsubscribe:", error);
-    } finally {
-      this.subscriptions.delete(handle);
-      this.pendingPackets.delete(subscription.subscriptionId);
-    }
-  }
-  /**
-   * Get list of active subscriptions
-   */
-  getSubscriptions() {
-    return Array.from(this.subscriptions.keys());
-  }
-  /**
-   * Handle packet from service worker
-   */
-  handlePacket(message) {
-    const { subscriptionId, data } = message;
-    if (!subscriptionId)
-      return;
-    const subscription = this.subscriptions.get(subscriptionId);
-    if (!subscription) {
-      console.warn(`[AMT] Received packet for unknown subscription: ${subscriptionId}`);
-      return;
-    }
-    if (!subscription.handshakeComplete) {
-      const queue = this.pendingPackets.get(subscriptionId);
-      const packetData2 = data;
-      if (queue) {
-        queue.push({
-          data: packetData2.data,
-          remoteAddress: packetData2.remoteAddress,
-          remotePort: packetData2.remotePort
-        });
-      }
-      return;
-    }
-    const packetData = data;
-    const metadata = {
-      sourceAddress: subscription.relay?.address || "unknown",
-      sourcePort: subscription.relay?.port || 0,
-      transport: "tunnel",
-      timestamp: performance.now()
-    };
-    subscription.config.onPacket(packetData.data, metadata);
-  }
-  /**
-   * Handle socket error from service worker
-   */
-  handleSocketError(message) {
-    const { subscriptionId, error } = message;
-    if (!subscriptionId)
-      return;
-    const subscription = this.subscriptions.get(subscriptionId);
-    if (!subscription) {
-      console.warn(`[AMT] Received error for unknown subscription: ${subscriptionId}`);
-      return;
-    }
-    subscription.config.onError(new Error(error || "Unknown error"));
-  }
-  /**
-   * Cleanup on destroy
-   */
-  destroy() {
-    if (this.messageHandler && typeof navigator !== "undefined" && navigator.serviceWorker) {
-      navigator.serviceWorker.removeEventListener("message", this.messageHandler);
-    }
-    const handles = Array.from(this.subscriptions.keys());
-    for (const handle of handles) {
-      this.unsubscribe(handle).catch((err) => {
-        console.error(`[AMT] Error unsubscribing ${handle}:`, err);
-      });
-    }
-  }
-  /**
-   * Get key string for HashMap
-   */
-  getKeyString(key) {
-    const source = key.source ? `@${key.source}` : "";
-    return `${key.group}:${key.port}${source}`;
-  }
-};
-var amtGatewayManager = new AMTGatewayManager();
-
 // src/multicast-transport.ts
 var MAX_TRACKED_DROPPED_PIDS = 16;
 function getMulticastGlobals() {
@@ -16250,13 +14926,19 @@ function getMulticastGlobals() {
 function hasMulticastGateway() {
   return typeof getMulticastGlobals().multicast?.subscribe === "function";
 }
-var _onPacket, _subscription2, _bytesListener, _resolvedTransport, _videoConfirmed, _audioConfirmed, _watchdog, _failbackWindowMs, _onTakeover, _onFailback, _disposed4, _stats3, _droppedPidCounts, _packetIds, _joinGeneration, _MulticastTransport_instances, releaseSubscription_fn, acceptPacket_fn, recordUnregisteredPidDrop_fn, checkTakeover_fn, resetWatchdog_fn;
+function normalizeResolvedTransport(value) {
+  if (value === "native") return "native";
+  if (value === "amt") return "amt";
+  return void 0;
+}
+var _onPacket, _subscription2, _bytesListener, _transportListener, _resolvedTransport, _videoConfirmed, _audioConfirmed, _watchdog, _failbackWindowMs, _onTakeover, _onFailback, _disposed4, _stats3, _droppedPidCounts, _packetIds, _joinGeneration, _MulticastTransport_instances, releaseSubscription_fn, acceptPacket_fn, recordUnregisteredPidDrop_fn, checkTakeover_fn, resetWatchdog_fn;
 var _MulticastTransport = class _MulticastTransport {
   constructor(onPacket) {
     __privateAdd(this, _MulticastTransport_instances);
     __privateAdd(this, _onPacket);
     __privateAdd(this, _subscription2, null);
     __privateAdd(this, _bytesListener, null);
+    __privateAdd(this, _transportListener, null);
     __privateAdd(this, _resolvedTransport);
     __privateAdd(this, _videoConfirmed, false);
     __privateAdd(this, _audioConfirmed, false);
@@ -16292,17 +14974,17 @@ var _MulticastTransport = class _MulticastTransport {
       console.log(
         `[MulticastTransport] window.multicast.subscribe(${config.sourceAddress}, ${config.groupAddress}, ${config.port})`
       );
-      const subscribeConfig = toWindowMulticastSubscribeConfig({
+      const subscription = await getMulticastGlobals().multicast.subscribe({
         source: config.sourceAddress,
         group: config.groupAddress,
         port: config.port,
+        consume: "bytes",
         mode: config.mode,
         amtRelay: config.amtRelay,
         amtRelayPort: config.amtRelayPort,
         packetIds: config.packetIds,
-        tracks: config.tracks
+        tracks: config.tracks?.map(({ name, packetId }) => ({ name, packetId }))
       });
-      const subscription = await getMulticastGlobals().multicast.subscribe(subscribeConfig);
       console.log(`[MulticastTransport] window.multicast.subscribe returned:`, !!subscription);
       if (__privateGet(this, _disposed4) || generation !== __privateGet(this, _joinGeneration)) {
         void subscription.unsubscribe();
@@ -16324,11 +15006,18 @@ var _MulticastTransport = class _MulticastTransport {
         __privateGet(this, _onPacket).call(this, packet, context);
         __privateMethod(this, _MulticastTransport_instances, resetWatchdog_fn).call(this);
       };
+      const onTransportChange = (event) => {
+        if (__privateGet(this, _disposed4) || generation !== __privateGet(this, _joinGeneration)) return;
+        const transport = normalizeResolvedTransport(event.detail);
+        if (transport) __privateSet(this, _resolvedTransport, transport);
+      };
       __privateSet(this, _subscription2, subscription);
       __privateSet(this, _bytesListener, onBytes);
+      __privateSet(this, _transportListener, onTransportChange);
       __privateSet(this, _packetIds, packetIds);
-      __privateSet(this, _resolvedTransport, subscribeConfig.origin === "amt" ? "amt" : "native");
+      __privateSet(this, _resolvedTransport, normalizeResolvedTransport(subscription.transport));
       subscription.addEventListener("bytes", onBytes);
+      subscription.addEventListener("transportchange", onTransportChange);
       __privateMethod(this, _MulticastTransport_instances, resetWatchdog_fn).call(this);
       console.log(
         `[MulticastTransport] Joined ${config.groupAddress}:${config.port}`
@@ -16396,6 +15085,7 @@ var _MulticastTransport = class _MulticastTransport {
 _onPacket = new WeakMap();
 _subscription2 = new WeakMap();
 _bytesListener = new WeakMap();
+_transportListener = new WeakMap();
 _resolvedTransport = new WeakMap();
 _videoConfirmed = new WeakMap();
 _audioConfirmed = new WeakMap();
@@ -16416,10 +15106,14 @@ releaseSubscription_fn = function() {
     if (__privateGet(this, _bytesListener)) {
       __privateGet(this, _subscription2).removeEventListener("bytes", __privateGet(this, _bytesListener));
     }
+    if (__privateGet(this, _transportListener)) {
+      __privateGet(this, _subscription2).removeEventListener("transportchange", __privateGet(this, _transportListener));
+    }
     void __privateGet(this, _subscription2).unsubscribe();
   }
   __privateSet(this, _subscription2, null);
   __privateSet(this, _bytesListener, null);
+  __privateSet(this, _transportListener, null);
   __privateSet(this, _resolvedTransport, void 0);
   __privateSet(this, _packetIds, null);
 };