@blockcast/mmt-transport 0.2.0 → 0.2.2

package/dist/mmt-transport.no-modules.js

@@ -0,0 +1,1154 @@
+"use strict";
+(() => {
+  // src/multicast-tier.ts
+  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];
+  }
+
+  // src/abr-controller.ts
+  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 {
+    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(initialQuality) {
+      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;
+    }
+  };
+
+  // src/endpoint-config.ts
+  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 isUsableMulticastEndpoint(endpoint) {
+    const port = Number(endpoint?.port);
+    return isValidMulticastGroupAddress(endpoint?.groupAddress) && isPositivePort(port);
+  }
+  function readUrlMulticastConfig(search = typeof location === "undefined" ? "" : location.search) {
+    const params = typeof search === "string" ? new URLSearchParams(search) : search;
+    const groupAddress = params.get("mc_group") || "";
+    const port = positivePort(params.get("mc_port"));
+    if (!groupAddress || !port) return void 0;
+    const amtRelay = params.get("mc_amt_relay") || params.get("amt_relay") || void 0;
+    const amtRelayPort = positivePort(params.get("mc_amt_relay_port") || params.get("amt_relay_port"));
+    const requestedMode = params.get("mc_mode");
+    const mode = amtRelay ? "tunnel" : multicastMode(requestedMode);
+    return normalizeMulticastEndpoint({
+      groupAddress,
+      sourceAddress: params.get("mc_source") || void 0,
+      port,
+      ...mode ? { mode } : {},
+      ...amtRelay ? { amtRelay } : {},
+      ...amtRelayPort ? { amtRelayPort } : {}
+    });
+  }
+  function isMulticastExplicitlyDisabled(search = typeof location === "undefined" ? "" : location.search) {
+    const params = typeof search === "string" ? new URLSearchParams(search) : search;
+    const multicast = params.get("multicast")?.trim().toLowerCase();
+    const transport = params.get("transport")?.trim().toLowerCase();
+    return transport === "moq-only" || ["0", "false", "no", "off"].includes(multicast || "");
+  }
+  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 multicastMode(value) {
+    return value === "native" || value === "tunnel" || value === "auto" ? value : void 0;
+  }
+  function positivePort(value) {
+    const port = Number(value);
+    return isPositivePort(port) ? port : void 0;
+  }
+  function isPositivePort(port) {
+    return Number.isInteger(port) && port > 0 && port <= 65535;
+  }
+
+  // src/multicast-orchestrator.ts
+  var DEFAULT_DWELL_MS = 3e3;
+  var DEFAULT_JOIN_DEADLINE_MS = 5e3;
+  var MulticastOrchestrator = class {
+    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");
+      }
+    }
+    #state = "stable";
+    #current;
+    #target;
+    #estimate;
+    #favored;
+    #joinStartedAt = 0;
+    #lastCommittedTimestamp = Number.NEGATIVE_INFINITY;
+    #dwellMs;
+    #joinDeadlineMs;
+    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;
+      this.#estimate = bitrate;
+      if (!this.#current || this.options.adaptive === false) return void 0;
+      if (this.#state === "joining") return this.poll();
+      const desired = selectMulticastTier(this.options.endpoints, bitrate);
+      if (!desired) 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 };
+        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 };
+    }
+    onTierPacket(packet) {
+      if (!this.#current) return void 0;
+      if (packet.endpointKey === endpointKey(this.#current) && Number.isFinite(packet.timestamp)) {
+        this.#lastCommittedTimestamp = Math.max(this.#lastCommittedTimestamp, packet.timestamp);
+      }
+      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 || !Number.isFinite(packet.timestamp) || packet.timestamp < this.#lastCommittedTimestamp) return void 0;
+      const command = {
+        kind: "commit-swap",
+        target: this.#target,
+        old: this.#current
+      };
+      this.#lastCommittedTimestamp = packet.timestamp;
+      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;
+    }
+    #now() {
+      const now = this.options.now();
+      if (!Number.isFinite(now)) throw new Error("Multicast orchestrator clock must be finite");
+      return now;
+    }
+  };
+
+  // src/multicast-subscription-pool.ts
+  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({
+        group: endpoint.groupAddress,
+        ...endpoint.sourceAddress ? { source: endpoint.sourceAddress } : {},
+        port: endpoint.port,
+        consume: "bytes",
+        ...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) => {
+        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, bytesListener, stateListener, errorListener, closed: false };
+      subscription.addEventListener("bytes", bytesListener);
+      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) {
+      entry.subscription.removeEventListener("bytes", entry.bytesListener);
+      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();
+
+  // src/stall-detector.ts
+  var TransportStallDetector = class {
+    constructor(config) {
+      this.config = config;
+      if (config.windowMs <= 0) throw new Error("Stall window must be positive and catalog-derived");
+      this.#now = config.now ?? Date.now;
+    }
+    #last = null;
+    #lastSampleAt = 0;
+    #starvedSince = null;
+    #latched = false;
+    #now;
+    get isStarved() {
+      return this.#latched;
+    }
+    update(snapshot) {
+      const previous = this.#last;
+      const previousAt = this.#lastSampleAt;
+      const now = this.#now();
+      this.#last = { ...snapshot };
+      this.#lastSampleAt = now;
+      if (!previous) return;
+      const blockDelta = snapshot.blocksComplete - previous.blocksComplete + snapshot.blocksRecovered - previous.blocksRecovered;
+      const mediaDelta = (snapshot.mediaFrames ?? 0) - (previous.mediaFrames ?? 0);
+      if (blockDelta <= 0 && mediaDelta <= 0) {
+        this.#starvedSince ??= previousAt;
+        if (!this.#latched && now - this.#starvedSince >= this.config.windowMs) {
+          this.#latched = true;
+          this.config.onStarvation();
+        }
+        return;
+      }
+      this.#starvedSince = null;
+      if (this.#latched) {
+        this.#latched = false;
+        this.config.onRecovery();
+      }
+    }
+    reset() {
+      this.#last = null;
+      this.#starvedSince = null;
+      this.#latched = false;
+    }
+  };
+
+  // src/takeover.ts
+  function makeSourceSwitchHandler(options) {
+    const log = options.log ?? console.log;
+    const warn = options.warn ?? console.warn;
+    return async (source) => {
+      if (source !== "multicast") return;
+      if (!options.multicastBridgeAvailable) {
+        warn("[MoqWatch] MediaRouter requested multicast without bridge; keeping MoQ active");
+        return;
+      }
+      const sessions = await options.sessionsReady;
+      if (!sessions) {
+        warn("[MoqWatch] SessionManager unavailable; aborting multicast takeover, staying on MoQ");
+        options.onAbortTakeover?.();
+        return;
+      }
+      log("[MoqWatch] MediaRouter -> multicast; activating via SessionManager");
+      sessions.activateMulticast();
+      options.onMulticastConfirmed?.();
+    };
+  }
+  function wireStallDetector(args) {
+    if (!args.session || args.windowMs <= 0) return null;
+    return args.makeDetector({
+      windowMs: args.windowMs,
+      onStarvation: () => args.session.lossDetected(),
+      onRecovery: () => args.session.lossRecovered()
+    });
+  }
+  async function wireStarvationDetector(args) {
+    if (!args.session || args.fecInterleaveMs <= 0 || args.fecK <= 0) return null;
+    const detector = wireStallDetector({
+      session: args.session,
+      windowMs: Math.ceil(args.fecInterleaveMs * 3),
+      makeDetector: args.makeDetector
+    });
+    if (!detector) args.warn?.(`Unable to create starvation detector for ${args.trackName}`);
+    return detector;
+  }
+
+  // src/driad-discovery.ts
+  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 [
+        { host: "amt-relay.m2icast.net", port: 2268, priority: 10, weight: 100, asn: 0 },
+        { host: "amt.akamaistream.net", port: 2268, priority: 20, weight: 50, asn: 0 }
+      ];
+    }
+    /**
+     * 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();
+
+  // src/transport-manager.ts
+  var TransportManager = class {
+    state = {
+      mode: "disconnected",
+      connected: false,
+      packetsReceived: 0,
+      bytesReceived: 0,
+      lastPacketTime: 0
+    };
+    capabilities = null;
+    subscription = null;
+    driad = new DRIADDiscovery();
+    abr;
+    multicastOrchestrator = null;
+    onOrchestratorCommand;
+    connectionGeneration = 0;
+    onPacket;
+    onError;
+    onStateChange;
+    constructor() {
+      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 }));
+    }
+    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();
+
+  // src/unicast-fallback.ts
+  function runUnicastFallback(input) {
+    input.sessions.enterUnicastFallback();
+    const tracks = Array.from(new Map(input.tracks.map((track) => [track.name, track])).values());
+    let resolveAbort;
+    const aborted = new Promise((resolve) => {
+      resolveAbort = resolve;
+      if (input.signal.aborted) resolve(void 0);
+    });
+    const onAbort = () => resolveAbort(void 0);
+    if (!input.signal.aborted) input.signal.addEventListener("abort", onAbort, { once: true });
+    const drainers = tracks.map(async (track) => {
+      const subscription = input.broadcast.subscribe(track.name, input.priority);
+      try {
+        while (!input.signal.aborted) {
+          const nextGroup = subscription.nextGroup();
+          const group = await Promise.race([nextGroup, aborted]);
+          if (!group && input.signal.aborted) void nextGroup.then((lateGroup) => lateGroup?.close());
+          if (!group) break;
+          try {
+            while (!input.signal.aborted) {
+              const frame = await Promise.race([group.readFrame(), aborted]);
+              if (!frame) break;
+              input.onPacket(frame);
+            }
+          } finally {
+            group.close();
+          }
+        }
+      } catch (error) {
+        if (!input.signal.aborted) {
+          if (input.onError) input.onError(track.name, error);
+          else console.warn(`[unicast-fallback] drainer error on ${track.name}:`, error);
+        }
+      } finally {
+        subscription.close();
+      }
+    });
+    const done = Promise.all(drainers).then(() => void 0).finally(() => {
+      input.signal.removeEventListener("abort", onAbort);
+    });
+    return { done };
+  }
+
+  // src/no-modules.ts
+  var api = {
+    AdaptiveBitrateController,
+    MulticastOrchestrator,
+    MulticastSubscriptionPool,
+    TransportManager,
+    TransportStallDetector,
+    endpointKey,
+    isMulticastExplicitlyDisabled,
+    isUsableMulticastEndpoint,
+    isValidMulticastGroupAddress,
+    makeSourceSwitchHandler,
+    multicastEndpointKey,
+    normalizeMulticastEndpoint,
+    readUrlMulticastConfig,
+    runUnicastFallback,
+    selectMulticastTier,
+    wireStarvationDetector
+  };
+  Object.defineProperty(globalThis, "__MmtTransport", {
+    configurable: true,
+    enumerable: false,
+    writable: false,
+    value: Object.freeze(api)
+  });
+  var no_modules_default = api;
+})();
+//# sourceMappingURL=mmt-transport.no-modules.js.map