@blockcast/mmt-transport 0.2.2 → 0.3.0

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

@@ -4,10 +4,14 @@
   function endpointKey(endpoint) {
     return `${endpoint.sourceAddress ?? ""}|${endpoint.groupAddress}|${endpoint.port}`;
   }
+  function carriesMedia(endpoint) {
+    return endpoint.carriesMedia !== false;
+  }
   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];
+    const media = endpoints.filter(carriesMedia);
+    if (media.length <= 1) return media[0];
+    const ranked = media.filter((endpoint) => typeof endpoint.bandwidth === "number" && endpoint.bandwidth > 0).sort((a, b) => a.bandwidth - b.bandwidth);
+    if (ranked.length < 2) return media[0];
     if (estimate === void 0) return ranked[0];
     const budget = estimate * 0.8;
     let selected;
@@ -18,7 +22,7 @@
   }
 
   // src/abr-controller.ts
-  var QUALITY_LEVELS = [
+  var QUALITY_LEVELS = Object.freeze([
     { name: "240p", bitrate: 3e5, width: 426, height: 240, fps: 15 },
     { name: "360p", bitrate: 5e5, width: 640, height: 360, fps: 24 },
     { name: "480p", bitrate: 1e6, width: 854, height: 480, fps: 30 },
@@ -26,8 +30,37 @@
     { name: "1080p", bitrate: 5e6, width: 1920, height: 1080, fps: 30 },
     { name: "1440p", bitrate: 8e6, width: 2560, height: 1440, fps: 30 },
     { name: "4K", bitrate: 15e6, width: 3840, height: 2160, fps: 30 }
-  ];
+  ].map((level) => Object.freeze(level)));
+  function positiveFinite(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+  }
+  function validateQualityLadder(ladder) {
+    if (!Array.isArray(ladder) || ladder.length === 0) {
+      throw new TypeError("[ABR] ladder must list at least one rendition (e.g. the catalog's video tracks)");
+    }
+    const names = /* @__PURE__ */ new Set();
+    for (const level of ladder) {
+      if (typeof level?.name !== "string" || level.name.length === 0) {
+        throw new TypeError("[ABR] every ladder rendition needs a name");
+      }
+      if (!positiveFinite(level.bitrate)) {
+        throw new RangeError(`[ABR] rendition ${level.name}: bitrate must be a positive finite number, got ${String(level.bitrate)}`);
+      }
+      for (const field of ["width", "height", "fps"]) {
+        if (level[field] !== void 0 && !positiveFinite(level[field])) {
+          throw new RangeError(`[ABR] rendition ${level.name}: ${field} must be a positive finite number when stated, got ${String(level[field])}`);
+        }
+      }
+      if (names.has(level.name)) throw new RangeError(`[ABR] rendition ${level.name} appears twice in the ladder`);
+      names.add(level.name);
+    }
+    return Object.freeze(
+      [...ladder].sort((a, b) => a.bitrate - b.bitrate).map((level) => Object.freeze({ ...level }))
+    );
+  }
   var AdaptiveBitrateController = class {
+    /** The caller's renditions, ascending by bitrate (`validateQualityLadder`). */
+    ladder;
     currentQualityIndex;
     history = [];
     historyWindow = 1e4;
@@ -47,15 +80,21 @@
       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;
+    constructor(options) {
+      if (!options || typeof options !== "object") {
+        throw new TypeError("[ABR] AdaptiveBitrateController needs { ladder, initialQuality }");
+      }
+      this.ladder = validateQualityLadder(options.ladder);
+      this.currentQualityIndex = options.initialQuality === void 0 ? 0 : this.ladder.findIndex((q) => q.name === options.initialQuality);
+      if (this.currentQualityIndex < 0) {
+        throw new RangeError(`[ABR] initial rendition ${String(options.initialQuality)} is not in the ladder`);
+      }
     }
     setCallback(callback) {
       this.onQualityChange = callback;
     }
     getCurrentQuality() {
-      return QUALITY_LEVELS[this.currentQualityIndex];
+      return this.ladder[this.currentQualityIndex];
     }
     /** Selects the multicast (S,G) tier without replacing a player's unicast ABR manager. */
     selectMulticastTier(endpoints, estimate = this.getMetrics().measuredBitrate || void 0) {
@@ -81,7 +120,7 @@
         this.downgrade();
         return;
       }
-      if (measuredBitrate > currentQuality.bitrate * this.upgradeThreshold && effectiveLossRate < 0.01 && this.currentQualityIndex < QUALITY_LEVELS.length - 1) {
+      if (measuredBitrate > currentQuality.bitrate * this.upgradeThreshold && effectiveLossRate < 0.01 && this.currentQualityIndex < this.ladder.length - 1) {
         this.upgrade();
       }
     }
@@ -114,7 +153,7 @@
       return { measuredBitrate, lossRate };
     }
     upgrade() {
-      if (this.currentQualityIndex >= QUALITY_LEVELS.length - 1) return;
+      if (this.currentQualityIndex >= this.ladder.length - 1) return;
       this.currentQualityIndex++;
       this.lastQualityChange = Date.now();
       const newQuality = this.getCurrentQuality();
@@ -130,15 +169,15 @@
       this.onQualityChange?.(newQuality);
     }
     /**
-     * Force quality level (for testing)
+     * Select a ladder rendition: the caller switched to it (a manual override,
+     * or a switch the caller made). Throws for a name the ladder does not carry.
      */
     setQuality(name) {
-      const index = QUALITY_LEVELS.findIndex((q) => q.name === name);
-      if (index >= 0) {
-        this.currentQualityIndex = index;
-        this.lastQualityChange = Date.now();
-        this.onQualityChange?.(this.getCurrentQuality());
-      }
+      const index = this.ladder.findIndex((q) => q.name === name);
+      if (index < 0) throw new RangeError(`[ABR] rendition ${name} is not in the ladder`);
+      this.currentQualityIndex = index;
+      this.lastQualityChange = Date.now();
+      this.onQualityChange?.(this.getCurrentQuality());
     }
     /**
      * Get current metrics including both raw and effective loss rates
@@ -162,7 +201,91 @@
     }
   };
 
+  // node_modules/@blockcast/mmt-alta-parse/dist/index.js
+  var MPU_HEADER_SIZE = 8;
+  var MPU_LENGTH_FIELD_SIZE = 2;
+  var MPU_HEADER_REMAINDER_SIZE = MPU_HEADER_SIZE - MPU_LENGTH_FIELD_SIZE;
+
+  // node_modules/@blockcast/mmt-base/dist/mmtp.js
+  var MPU_HEADER_SIZE2 = 8;
+  var MPU_LENGTH_FIELD_SIZE2 = 2;
+  var MPU_HEADER_REMAINDER_SIZE2 = MPU_HEADER_SIZE2 - MPU_LENGTH_FIELD_SIZE2;
+  var MMTP_SIGNALING_PACKET_ID = 0;
+  var MMTP_PACKET_ID_MAX = 65535;
+
+  // node_modules/@blockcast/mmt-base/dist/net-constants.js
+  var DEFAULT_AMT_RELAY_PORT = 2268;
+
+  // node_modules/@blockcast/mmt-base/dist/ntp-short.js
+  var NTP_SHORT_BITS = 32;
+  var NTP_SHORT_MODULUS = 2 ** NTP_SHORT_BITS;
+  var NTP_SHORT_HALF_RANGE = 2 ** (NTP_SHORT_BITS - 1);
+  function isNtpShort(value) {
+    return Number.isInteger(value) && value >= 0 && value < NTP_SHORT_MODULUS;
+  }
+  function compareNtpShort(a, b) {
+    if (!isNtpShort(a) || !isNtpShort(b)) {
+      throw new RangeError(`NTP-short values must be integers in [0, 2^${NTP_SHORT_BITS}), got ${String(a)} and ${String(b)}`);
+    }
+    if (a === b)
+      return "equal";
+    const forward = (a - b + NTP_SHORT_MODULUS) % NTP_SHORT_MODULUS;
+    if (forward < NTP_SHORT_HALF_RANGE)
+      return "after";
+    if (forward > NTP_SHORT_HALF_RANGE)
+      return "before";
+    return "unordered";
+  }
+
+  // node_modules/@blockcast/mmt-base/dist/fec-block-profile.js
+  var FEC_BLOCK_PROFILES = Object.freeze([
+    "k-padded-v1",
+    "iso-ssbg1-v1"
+  ]);
+
   // src/endpoint-config.ts
+  function toWindowMulticastSubscribeConfig(input) {
+    if (input.mode !== void 0 && !["auto", "native", "tunnel"].includes(input.mode)) {
+      throw new TypeError(`Unsupported multicast mode: ${String(input.mode)}`);
+    }
+    if (input.packetIds !== void 0 && !Array.isArray(input.packetIds)) {
+      throw new TypeError(
+        `multicast packetIds must be an array, got ${input.packetIds === null ? "null" : typeof input.packetIds}`
+      );
+    }
+    if (input.packetIds?.some((id) => !isMulticastTrackPacketId(id)) || input.tracks?.some((track) => !isMulticastTrackPacketId(track.packetId))) {
+      throw new RangeError(
+        `multicast packetId must be an integer from 1 to ${MMTP_PACKET_ID_MAX}; packetId 0 is the MMTP signaling flow and is never a track's`
+      );
+    }
+    const base = {
+      group: input.group,
+      port: input.port,
+      ...input.source?.trim() ? { source: input.source.trim() } : {},
+      consume: "bytes",
+      ...input.packetIds?.length ? { packetIds: [...input.packetIds] } : {}
+    };
+    const relay = input.amtRelay?.trim();
+    const wantsAmt = input.mode === "tunnel" || input.mode !== "native" && relay !== void 0 && relay !== "";
+    if (!wantsAmt) {
+      const native = {
+        ...base,
+        origin: "ip-multicast",
+        ...input.tracks?.length ? { tracks: input.tracks.map(({ name, packetId }) => ({ name, packetId })) } : {}
+      };
+      return native;
+    }
+    const relayPort = input.amtRelayPort;
+    if (!relay || relayPort === void 0 || !isPositivePort(relayPort)) {
+      throw new TypeError("AMT requires a resolved relay and a valid relay port");
+    }
+    return {
+      ...base,
+      origin: "amt",
+      relay,
+      relayPort
+    };
+  }
   function isValidMulticastGroupAddress(address) {
     const value = address?.trim().toLowerCase();
     if (!value) return false;
@@ -204,20 +327,36 @@
       normalized.amtRelayPort ?? ""
     ]);
   }
+  function isMulticastTrackPacketId(value) {
+    return Number.isInteger(value) && value > MMTP_SIGNALING_PACKET_ID && value <= MMTP_PACKET_ID_MAX;
+  }
   function isUsableMulticastEndpoint(endpoint) {
     const port = Number(endpoint?.port);
     return isValidMulticastGroupAddress(endpoint?.groupAddress) && isPositivePort(port);
   }
+  var RETIRED_MULTICAST_URL_PARAMS = [
+    ["amt_relay", "mc_amt_relay"],
+    ["amt_relay_port", "mc_amt_relay_port"]
+  ];
+  function assertNoRetiredMulticastUrlParams(params) {
+    for (const [retired, replacement] of RETIRED_MULTICAST_URL_PARAMS) {
+      if (params.has(retired)) {
+        throw new Error(
+          `multicast URL override: query parameter "${retired}" is retired; use "${replacement}"`
+        );
+      }
+    }
+  }
   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 amtRelay = params.get("mc_amt_relay") || void 0;
+    const amtRelayPort = positivePort(params.get("mc_amt_relay_port"));
     const requestedMode = params.get("mc_mode");
     const mode = amtRelay ? "tunnel" : multicastMode(requestedMode);
-    return normalizeMulticastEndpoint({
+    const endpoint = normalizeMulticastEndpoint({
       groupAddress,
       sourceAddress: params.get("mc_source") || void 0,
       port,
@@ -225,6 +364,8 @@
       ...amtRelay ? { amtRelay } : {},
       ...amtRelayPort ? { amtRelayPort } : {}
     });
+    if (endpoint) assertNoRetiredMulticastUrlParams(params);
+    return endpoint;
   }
   function isMulticastExplicitlyDisabled(search = typeof location === "undefined" ? "" : location.search) {
     const params = typeof search === "string" ? new URLSearchParams(search) : search;
@@ -270,7 +411,12 @@
     #estimate;
     #favored;
     #joinStartedAt = 0;
-    #lastCommittedTimestamp = Number.NEGATIVE_INFINITY;
+    /**
+     * Latest active-tier send time (NTP short), or undefined before the first.
+     * "Latest" is serial order, not the numerically largest value: after the
+     * field wraps, the largest value is the stale one.
+     */
+    #highWater;
     #dwellMs;
     #joinDeadlineMs;
     get state() {
@@ -291,19 +437,57 @@
     }
     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();
+      if (bitrate === void 0 || !Number.isFinite(bitrate)) return void 0;
+      this.#estimate = bitrate;
       const desired = selectMulticastTier(this.options.endpoints, bitrate);
       if (!desired) return void 0;
       const desiredKey = endpointKey(desired);
+      if (desiredKey === endpointKey(this.#current)) {
+        if (this.#favored?.source === "goodput") this.#favored = void 0;
+        return void 0;
+      }
+      if (typeof desired.bandwidth !== "number" || typeof this.#current.bandwidth !== "number" || desired.bandwidth >= this.#current.bandwidth) {
+        if (this.#favored?.source === "goodput") this.#favored = void 0;
+        return void 0;
+      }
+      const now = this.#now();
+      if (!this.#favored || this.#favored.key !== desiredKey || this.#favored.source !== "goodput") {
+        this.#favored = { key: desiredKey, since: now, source: "goodput" };
+        return void 0;
+      }
+      if (now - this.#favored.since < this.#dwellMs) return void 0;
+      this.#state = "joining";
+      this.#target = desired;
+      this.#joinStartedAt = now;
+      this.#favored = void 0;
+      return { kind: "join-target", current: this.#current, target: desired };
+    }
+    onHeadroom(sample) {
+      if (!this.#current || this.options.adaptive === false || this.#state === "joining") return void 0;
+      if (!sample.healthy) {
+        if (this.#favored?.source === "headroom") this.#favored = void 0;
+        return void 0;
+      }
+      if (this.#favored?.source === "goodput") return void 0;
+      const currentBandwidth = this.#current.bandwidth;
+      if (typeof currentBandwidth !== "number") return void 0;
+      const desired = this.options.endpoints.filter(
+        (endpoint) => carriesMedia(endpoint) && typeof endpoint.bandwidth === "number" && endpoint.bandwidth > currentBandwidth
+      ).sort((a, b) => a.bandwidth - b.bandwidth)[0];
+      if (!desired) {
+        this.#favored = void 0;
+        return void 0;
+      }
+      const desiredKey = endpointKey(desired);
       if (desiredKey === endpointKey(this.#current)) {
         this.#favored = void 0;
         return void 0;
       }
       const now = this.#now();
       if (!this.#favored || this.#favored.key !== desiredKey) {
-        this.#favored = { key: desiredKey, since: now };
+        this.#favored = { key: desiredKey, since: now, source: "headroom" };
         return void 0;
       }
       if (now - this.#favored.since < this.#dwellMs) return void 0;
@@ -313,21 +497,32 @@
       this.#favored = void 0;
       return { kind: "join-target", current: this.#current, target: desired };
     }
+    /**
+     * Feed a packet from the active tier (to advance the high-water mark) or
+     * from the in-flight target (to find a committable RAP).
+     *
+     * Serial order is only the true order while the compared instants are less
+     * than `NTP_SHORT_HALF_RANGE` (2^15 s, ~9.1 h) apart. Feeding every
+     * active-tier packet keeps the mark that close to the live stream. A mark
+     * refreshed only by commits can fall further behind than that, and a
+     * target RAP may then compare as older, so the join is abandoned.
+     */
     onTierPacket(packet) {
       if (!this.#current) return void 0;
-      if (packet.endpointKey === endpointKey(this.#current) && Number.isFinite(packet.timestamp)) {
-        this.#lastCommittedTimestamp = Math.max(this.#lastCommittedTimestamp, packet.timestamp);
+      const sentAt = tierPacketSendTime(packet);
+      if (packet.endpointKey === endpointKey(this.#current) && sentAt !== void 0 && (this.#highWater === void 0 || compareNtpShort(sentAt, this.#highWater) === "after")) {
+        this.#highWater = sentAt;
       }
       if (this.#state !== "joining" || !this.#target) return void 0;
       const expired = this.poll();
       if (expired) return expired;
-      if (packet.endpointKey !== endpointKey(this.#target) || !packet.keyframe || !packet.hasValidCodecConfig || !Number.isFinite(packet.timestamp) || packet.timestamp < this.#lastCommittedTimestamp) return void 0;
+      if (packet.endpointKey !== endpointKey(this.#target) || !packet.keyframe || !packet.hasValidCodecConfig || sentAt === void 0 || !this.#reachesHighWater(sentAt)) return void 0;
       const command = {
         kind: "commit-swap",
         target: this.#target,
         old: this.#current
       };
-      this.#lastCommittedTimestamp = packet.timestamp;
+      this.#highWater = sentAt;
       this.#current = this.#target;
       this.#target = void 0;
       this.#state = "stable";
@@ -349,12 +544,481 @@
       this.#state = "stable";
       return command;
     }
+    /**
+     * Whether a target RAP sent at `sentAt` is at or beyond the active tier's
+     * high-water mark. A pair exactly half the NTP-short space apart has no
+     * serial order, so it cannot show that and does not commit.
+     */
+    #reachesHighWater(sentAt) {
+      if (this.#highWater === void 0) return true;
+      const order = compareNtpShort(sentAt, this.#highWater);
+      return order === "after" || order === "equal";
+    }
     #now() {
       const now = this.options.now();
       if (!Number.isFinite(now)) throw new Error("Multicast orchestrator clock must be finite");
       return now;
     }
   };
+  function tierPacketSendTime(packet) {
+    if (!Number.isFinite(packet.timestamp)) return void 0;
+    if (!isNtpShort(packet.timestamp)) {
+      throw new RangeError(
+        `Multicast tier packet timestamp must be an MMTP NTP-short send time, got ${packet.timestamp}`
+      );
+    }
+    return packet.timestamp;
+  }
+
+  // src/multicast-signaling-reconciler.ts
+  function createMulticastSignalingReconciler(catalog, options = {}) {
+    const initial = normalizeCatalogEndpoints(catalog);
+    const endpoints = new Map(initial.map((endpoint) => [endpoint.endpointId, copyEndpoint(endpoint)]));
+    const versions = new Map(initial.map((endpoint) => [endpoint.endpointId, endpoint.endpointVersion]));
+    const seen = /* @__PURE__ */ new Set();
+    const dormant = /* @__PURE__ */ new Set();
+    let catalogVersion = Number(catalog?.multicast?.version ?? catalog?.version ?? 0) || 0;
+    const snapshot = (now = Date.now()) => ({
+      catalogVersion,
+      endpoints: [...endpoints.values()].filter((endpoint) => !dormant.has(endpoint.endpointId) && !isExpired(endpoint, now)).map(copyEndpoint),
+      dormantEndpointIds: [...dormant].sort()
+    });
+    return {
+      apply(signal, now = Date.now()) {
+        if (!isObject(signal) || typeof signal.type !== "string" || typeof signal.msgId !== "string") return { applied: false, reason: "invalid-message" };
+        if (seen.has(signal.msgId)) return { applied: false, reason: "duplicate-message" };
+        if (signal.expiresAt != null && Number(signal.expiresAt) < now) return { applied: false, reason: "expired" };
+        const signalCatalogVersion = Number(signal.catalogVersion ?? 0);
+        if (!Number.isFinite(signalCatalogVersion)) return { applied: false, reason: "invalid-message" };
+        if (signalCatalogVersion < catalogVersion) return { applied: false, reason: "stale-catalog" };
+        const result = applyFresh(signal, now);
+        if (result.applied) {
+          seen.add(signal.msgId);
+          if (signal.type !== "heartbeat") {
+            catalogVersion = Math.max(catalogVersion, signalCatalogVersion);
+          }
+        }
+        return result;
+      },
+      snapshot,
+      toCatalog(now = Date.now()) {
+        const current = snapshot(now);
+        return { ...catalog, multicast: { ...catalog.multicast, version: current.catalogVersion, endpoints: current.endpoints } };
+      }
+    };
+    function applyFresh(signal, now) {
+      switch (signal.type) {
+        case "snapshot": {
+          const next = signal.payload?.endpoints;
+          if (!Array.isArray(next)) return { applied: false, reason: "invalid-message" };
+          const normalized = next.map((endpoint, index) => normalizeEndpoint(endpoint, index));
+          if (normalized.some((endpoint) => !endpoint || !isValidEndpoint(endpoint, options.catalog))) return { applied: false, reason: "invalid-endpoint" };
+          const ids = new Set(normalized.map((endpoint) => endpoint.endpointId));
+          if (ids.size !== normalized.length) return { applied: false, reason: "duplicate-endpoint" };
+          endpoints.clear();
+          versions.clear();
+          dormant.clear();
+          for (const endpoint of normalized) {
+            versions.set(endpoint.endpointId, endpoint.endpointVersion);
+            if (!isExpired(endpoint, now)) endpoints.set(endpoint.endpointId, copyEndpoint(endpoint));
+          }
+          return { applied: true, action: "snapshot" };
+        }
+        case "add":
+          return upsert(signal.payload?.endpoint, now);
+        case "update": {
+          const id = signal.payload?.endpointId;
+          const fields = signal.payload?.fields;
+          if (!endpoints.has(id)) return { applied: false, reason: "unknown-endpoint" };
+          if (isStale(id, signal.payload?.endpointVersion)) return { applied: false, reason: "stale-endpoint" };
+          if (!isObject(fields) || ["protocol", "sourceAddress", "groupAddress", "port"].some((key) => Object.hasOwn(fields, key))) return { applied: false, reason: "invalid-update" };
+          return upsert({ ...endpoints.get(id), ...fields, endpointVersion: signal.payload.endpointVersion }, now);
+        }
+        case "remove": {
+          const id = signal.payload?.endpointId;
+          if (!endpoints.has(id)) return { applied: false, reason: "unknown-endpoint" };
+          const endpointVersion = Number(signal.payload?.endpointVersion);
+          if (!Number.isFinite(endpointVersion)) return { applied: false, reason: "invalid-message" };
+          if (isStale(id, endpointVersion)) return { applied: false, reason: "stale-endpoint" };
+          endpoints.delete(id);
+          dormant.delete(id);
+          versions.set(id, endpointVersion);
+          return { applied: true, action: "drop" };
+        }
+        case "invalidate": {
+          const id = signal.payload?.endpointId;
+          if (!endpoints.has(id)) return { applied: false, reason: "unknown-endpoint" };
+          dormant.add(id);
+          return { applied: true, action: "drop" };
+        }
+        case "heartbeat":
+          return { applied: true, action: "heartbeat" };
+        default:
+          return { applied: false, reason: "unknown-message-type" };
+      }
+    }
+    function upsert(value, now) {
+      const endpoint = normalizeEndpoint(value, endpoints.size);
+      if (!endpoint || !isValidEndpoint(endpoint, options.catalog)) return { applied: false, reason: "invalid-endpoint" };
+      if (isStale(endpoint.endpointId, endpoint.endpointVersion)) return { applied: false, reason: "stale-endpoint" };
+      versions.set(endpoint.endpointId, endpoint.endpointVersion);
+      dormant.delete(endpoint.endpointId);
+      if (isExpired(endpoint, now)) endpoints.delete(endpoint.endpointId);
+      else endpoints.set(endpoint.endpointId, copyEndpoint(endpoint));
+      return { applied: true, action: isExpired(endpoint, now) ? "drop" : "candidate" };
+    }
+    function isStale(id, version) {
+      const current = versions.get(id);
+      return current !== void 0 && Number(version) <= current;
+    }
+  }
+  function normalizeCatalogEndpoints(catalog) {
+    const endpoints = catalog?.multicast?.endpoints;
+    if (!Array.isArray(endpoints)) return [];
+    return endpoints.map(normalizeEndpoint).filter((endpoint) => !!endpoint && isValidEndpoint(endpoint, catalog));
+  }
+  function normalizeEndpoint(value, index) {
+    if (!isObject(value)) return void 0;
+    const endpoint = value;
+    const tracks = Array.isArray(endpoint.tracks) ? endpoint.tracks.map((track) => typeof track === "string" ? { name: track } : { ...track }).filter((track) => track.name) : [];
+    return { ...endpoint, endpointId: endpoint.endpointId || `${endpoint.sourceAddress || ""}|${endpoint.groupAddress || ""}|${endpoint.port || ""}|${index}`, endpointVersion: Number(endpoint.endpointVersion ?? 0), tracks };
+  }
+  function isValidEndpoint(endpoint, catalog) {
+    if (!endpoint.endpointId || !Number.isFinite(endpoint.endpointVersion)) return false;
+    if (!["ssm", "asm", "amt"].includes(endpoint.protocol)) return false;
+    if (endpoint.protocol === "ssm" && (typeof endpoint.sourceAddress !== "string" || endpoint.sourceAddress.trim().length === 0)) return false;
+    if (!isValidMulticastGroupAddress(endpoint.groupAddress) || !Number.isInteger(Number(endpoint.port)) || endpoint.port <= 0 || endpoint.port > 65535 || !endpoint.tracks.length) return false;
+    const catalogTracks = /* @__PURE__ */ new Set([...Object.keys(catalog?.video?.renditions ?? {}), ...Object.keys(catalog?.audio?.renditions ?? {})]);
+    return endpoint.tracks.every((track) => !!track.name && isMulticastTrackPacketId(track.packetId) && (catalogTracks.size === 0 || catalogTracks.has(track.name) || catalogTracks.has(track.name.replace(/\/repair$/, ""))));
+  }
+  function copyEndpoint(endpoint) {
+    return { ...endpoint, tracks: endpoint.tracks.map((track) => ({ ...track })) };
+  }
+  function isExpired(endpoint, now) {
+    return endpoint.validUntil != null && Number(endpoint.validUntil) < now;
+  }
+  function isObject(value) {
+    return value !== null && typeof value === "object";
+  }
+
+  // src/multicast-catalog-policy.ts
+  function hasMulticastCatalogBaseline(catalog) {
+    const multicast = catalog?.multicast;
+    return normalizeCatalogEndpoints(catalog).length > 0 || Boolean(multicast?.groupAddress && multicast?.port);
+  }
+  function hasUnicastMediaRenditions(catalog) {
+    return Object.keys(catalog?.video?.renditions ?? {}).length > 0 || Object.keys(catalog?.audio?.renditions ?? {}).length > 0;
+  }
+  function isMulticastOnlyCatalog(catalog) {
+    return hasMulticastCatalogBaseline(catalog) && !hasUnicastMediaRenditions(catalog);
+  }
+  function requiresMulticastCapability(catalog, capabilities = {}) {
+    return isMulticastOnlyCatalog(catalog) && !capabilities.multicast;
+  }
+  function isRecoverableMulticastSignalReadError(error) {
+    const candidate = error;
+    const name = String(candidate?.name ?? "");
+    const message = String(candidate?.message ?? error ?? "");
+    return name === "SyntaxError" || /not valid JSON|unexpected token|JSON\.parse|encoded data was not valid|malformed/i.test(message);
+  }
+  function withMulticastEndpoints(catalog, endpoints, version) {
+    if (!catalog?.multicast) return catalog;
+    return {
+      ...catalog,
+      multicast: {
+        ...catalog.multicast,
+        version,
+        endpoints: endpoints.map(copyEndpoint2)
+      }
+    };
+  }
+  function selectMulticastCandidate(catalog, endpoints = normalizeCatalogEndpoints(catalog), search = currentSearchParams()) {
+    const params = search instanceof URLSearchParams ? search : new URLSearchParams(search);
+    return selectMulticastCandidateForTracks(catalog, endpoints, {
+      containerKind: params.get("packaging") || params.get("container") || "mmtp",
+      rendition: params.get("rendition") || void 0
+    });
+  }
+  function selectMulticastCandidateForTracks(catalog, endpoints = normalizeCatalogEndpoints(catalog), selection = {}) {
+    const packaging = selection.containerKind || "mmtp";
+    const renditionTrack = selection.rendition || "";
+    const preferredTrack = packaging === "mmtp" ? "video" : `video.${packaging}`;
+    const usableEndpoints = endpoints.filter(isUsableMulticastEndpoint);
+    const defaultRenditionTrack = renditionTrack ? "" : lowestServedVideoRendition(catalog, usableEndpoints);
+    return renditionTrack && usableEndpoints.find((endpoint) => endpoint.tracks?.some((track) => matchesPreferredTrack(track.name, renditionTrack))) || defaultRenditionTrack && usableEndpoints.find((endpoint) => endpoint.tracks?.some((track) => matchesPreferredTrack(track.name, defaultRenditionTrack))) || usableEndpoints.find((endpoint) => endpoint.tracks?.some((track) => matchesPreferredTrack(track.name, preferredTrack))) || usableEndpoints[0] || null;
+  }
+  function endpointToMulticastConfig(endpoint, catalog, selection) {
+    if (!endpoint || !isUsableMulticastEndpoint(endpoint) || advertisesInvalidPacketId(endpoint)) return null;
+    const config = {
+      group: endpoint.groupAddress,
+      source: endpoint.sourceAddress || "",
+      port: Number(endpoint.port)
+    };
+    const networkSource = endpoint.networkSource ?? catalog?.multicast?.networkSource;
+    const amt = findAmtRelay(networkSource);
+    if (amt) {
+      config.mode = "tunnel";
+      config.amtRelay = amt.relay;
+      config.amtRelayPort = amt.port;
+    } else if (endpoint.protocol === "amt") {
+      const amtEntries = amtNetworkSourceEntries(networkSource);
+      if (amtEntries.length > 0) config.amtNetworkSource = amtEntries;
+    }
+    const packetIds = selection === void 0 ? selectEndpointPacketIds(endpoint, catalog) : selectEndpointPacketIdsForTracks(endpoint, catalog, selection);
+    if (packetIds === null) return null;
+    if (packetIds.length > 0) config.packetIds = packetIds;
+    return config;
+  }
+  function selectEndpointPacketIds(endpoint, catalog, search = currentSearchParams()) {
+    const params = search instanceof URLSearchParams ? search : new URLSearchParams(search);
+    return selectEndpointPacketIdsForTracks(endpoint, catalog, {
+      containerKind: params.get("packaging") || params.get("container") || "mmtp",
+      rendition: params.get("rendition") || void 0
+    });
+  }
+  function selectEndpointPacketIdsForTracks(endpoint, catalog, selection = {}) {
+    if (!endpoint || !Array.isArray(endpoint.tracks)) return [];
+    if (advertisesInvalidPacketId(endpoint)) return null;
+    const tracks = endpoint.tracks.map((track) => ({
+      name: typeof track?.name === "string" ? track.name : "",
+      packetId: validPacketId(track?.packetId)
+    })).filter((track) => track.name.length > 0 && track.packetId !== void 0);
+    if (tracks.length === 0) return [];
+    const packaging = selection.containerKind || "mmtp";
+    const renditionTrack = selection.rendition || "";
+    const videoRenditions = catalogRenditions(catalog, "video");
+    const audioRenditions = catalogRenditions(catalog, "audio");
+    const videoTracks = tracks.filter((track) => Object.hasOwn(videoRenditions, track.name));
+    const audioTracks = tracks.filter((track) => Object.hasOwn(audioRenditions, track.name));
+    const preferredVideo = packaging === "mmtp" ? "video" : `video.${packaging}`;
+    const preferredAudio = packaging === "mmtp" ? "audio" : `audio.${packaging}`;
+    const video = (renditionTrack ? videoTracks.find((track) => track.name === renditionTrack) : void 0) ?? videoTracks.find((track) => track.name === preferredVideo) ?? [...videoTracks].sort((a, b) => videoRenditionRank(videoRenditions, a.name) - videoRenditionRank(videoRenditions, b.name))[0];
+    const audio = audioTracks.find((track) => track.name === preferredAudio) ?? audioTracks[0];
+    const selected = [video, audio].filter(
+      (track) => track !== void 0
+    );
+    if (selected.length === 0) return normalizePacketIds(tracks.map((track) => track.packetId));
+    const selectedRepairNames = new Set(selected.flatMap((track) => catalogRepairTracks(catalog, track.name)));
+    const selectedRepairTracks = tracks.filter((track) => selectedRepairNames.has(track.name));
+    return normalizePacketIds([...selected, ...selectedRepairTracks].map((track) => track.packetId));
+  }
+  function readPlayerMulticastConfig(search = currentSearchParams()) {
+    const params = search instanceof URLSearchParams ? search : new URLSearchParams(search || "");
+    const group = params.get("mc_group") || "";
+    if (!isValidMulticastGroupAddress(group)) return null;
+    const port = positivePort2(params.get("mc_port"));
+    if (!port) return null;
+    assertNoRetiredMulticastUrlParams(params);
+    const mode = params.get("mc_mode") || "";
+    const amtRelay = params.get("mc_amt_relay") || "";
+    const amtRelayPort = positivePort2(params.get("mc_amt_relay_port"));
+    const config = {
+      group,
+      source: params.get("mc_source") || "",
+      port
+    };
+    if (mode) config.mode = mode;
+    if (amtRelay) {
+      config.amtRelay = amtRelay;
+      if (amtRelay.trim()) config.mode = "tunnel";
+    }
+    if (amtRelayPort) config.amtRelayPort = amtRelayPort;
+    return config;
+  }
+  function normalizeMulticastConfig(config) {
+    if (!config?.group) return null;
+    if (Array.isArray(config.packetIds) && !config.packetIds.every(isMulticastTrackPacketId)) return null;
+    const amt = findAmtRelay(config.amtNetworkSource);
+    const amtRelay = config.amtRelay || amt?.relay || "";
+    const dialableRelay = amtRelay.trim();
+    const amtRelayPort = positivePort2(String(config.amtRelayPort ?? "")) ?? (dialableRelay ? amt?.port ?? DEFAULT_AMT_RELAY_PORT : void 0);
+    const packetIds = normalizePacketIds(config.packetIds);
+    const pendingAmt = dialableRelay ? [] : amtNetworkSourceEntries(config.amtNetworkSource);
+    return {
+      group: config.group,
+      source: config.source || "",
+      port: Number(config.port),
+      mode: dialableRelay ? "tunnel" : config.mode || "auto",
+      amtRelay,
+      ...amtRelayPort ? { amtRelayPort } : {},
+      // Relay-pending DRIAD survives normalization while it is still pending:
+      // dropping it here would erase, one hop before the join, the only thing
+      // telling the call site "AMT was asked for and is unresolved" apart from
+      // "this endpoint was always native" (BLO-38184). Once a relay resolves
+      // the entries have done their job and are not carried. `amtNetworkSource`
+      // is deliberately not part of `sameMulticastConfig`: it is provenance for
+      // the relay, not endpoint identity, so it must not report a change.
+      //
+      // That holds only while no caller acts on the field — today a pending
+      // DRIAD entry and a native endpoint both join `ip-multicast`, so
+      // comparing equal reports the truth. Once a caller resolves DRIAD and
+      // tunnels, a catalog swapping native for DRIAD-AMT becomes a real
+      // join-behaviour change that would compare equal and never re-join:
+      // whoever wires that resolution adds `amtNetworkSource` to
+      // `sameMulticastConfig` in the same change.
+      ...pendingAmt.length > 0 ? { amtNetworkSource: pendingAmt } : {},
+      ...packetIds.length > 0 ? { packetIds } : {}
+    };
+  }
+  function sameMulticastConfig(a, b) {
+    const left = normalizeMulticastConfig(a);
+    const right = normalizeMulticastConfig(b);
+    return Boolean(left && right && left.group === right.group && left.source === right.source && left.port === right.port && left.mode === right.mode && left.amtRelay === right.amtRelay && (left.amtRelayPort ?? 0) === (right.amtRelayPort ?? 0) && JSON.stringify(left.packetIds ?? []) === JSON.stringify(right.packetIds ?? []));
+  }
+  function urlOverrideBlocksMulticastCandidate(candidateConfig, urlConfig = readPlayerMulticastConfig()) {
+    if (!urlConfig) return false;
+    const candidate = normalizeMulticastConfig(candidateConfig);
+    const explicit = normalizeMulticastConfig(urlConfig);
+    return !candidate || !explicit || candidate.group !== explicit.group || candidate.source !== explicit.source || candidate.port !== explicit.port;
+  }
+  function mergeUrlMulticastPolicy(candidateConfig, urlConfig = readPlayerMulticastConfig()) {
+    const candidate = normalizeMulticastConfig(candidateConfig);
+    if (!candidate || !urlConfig || urlOverrideBlocksMulticastCandidate(candidate, urlConfig)) return candidate;
+    const merged = { ...candidate };
+    if (urlConfig.mode !== void 0) {
+      merged.mode = urlConfig.mode;
+      if (urlConfig.mode !== "tunnel" && urlConfig.amtRelay === void 0) {
+        merged.amtRelay = "";
+        delete merged.amtRelayPort;
+        delete merged.amtNetworkSource;
+      }
+    }
+    if (urlConfig.amtRelay !== void 0) {
+      merged.amtRelay = urlConfig.amtRelay;
+      delete merged.amtRelayPort;
+      if (urlConfig.amtRelay.trim()) {
+        merged.mode = "tunnel";
+        delete merged.amtNetworkSource;
+      } else if (urlConfig.mode === void 0 && candidate.amtRelay?.trim()) {
+        merged.mode = "auto";
+      }
+    }
+    if (urlConfig.amtRelayPort !== void 0) merged.amtRelayPort = urlConfig.amtRelayPort;
+    return normalizeMulticastConfig(merged);
+  }
+  function currentSearchParams() {
+    return typeof location === "undefined" ? new URLSearchParams() : new URLSearchParams(location.search);
+  }
+  function positivePort2(value) {
+    const port = Number(value);
+    return Number.isInteger(port) && port > 0 && port <= 65535 ? port : null;
+  }
+  function copyEndpoint2(endpoint) {
+    return { ...endpoint, tracks: endpoint.tracks.map((track) => ({ ...track })) };
+  }
+  function amtNetworkSourceEntries(networkSource) {
+    const sources = Array.isArray(networkSource) ? networkSource : networkSource ? [networkSource] : [];
+    return sources.filter((entry) => entry?.type === "amt").map((entry) => ({ ...entry }));
+  }
+  function findAmtRelay(networkSource) {
+    const source = amtNetworkSourceEntries(networkSource).find((candidate) => candidate?.discovery !== "driad" && typeof candidate?.relay === "string" && candidate.relay.trim());
+    if (!source) return void 0;
+    const port = positivePort2(String(source.port ?? ""));
+    return { relay: source.relay.trim(), port: port ?? DEFAULT_AMT_RELAY_PORT };
+  }
+  function validPacketId(value) {
+    return isMulticastTrackPacketId(value) ? value : void 0;
+  }
+  function advertisesInvalidPacketId(endpoint) {
+    return Array.isArray(endpoint.tracks) && endpoint.tracks.some((track) => track?.packetId !== void 0 && !isMulticastTrackPacketId(track.packetId));
+  }
+  function normalizePacketIds(packetIds) {
+    if (!Array.isArray(packetIds)) return [];
+    return [...new Set(packetIds.map(validPacketId).filter((id) => id !== void 0))].sort(
+      (a, b) => a - b
+    );
+  }
+  function matchesPreferredTrack(trackName, preferredTrack) {
+    return trackName === preferredTrack || trackName.startsWith(`${preferredTrack}/`);
+  }
+  function catalogRenditions(catalog, role) {
+    const renditions = { ...catalog?.[role]?.renditions ?? {} };
+    for (const track of Array.isArray(catalog?.tracks) ? catalog.tracks : []) {
+      if (track?.role === role && typeof track.name === "string" && track.name.length > 0) {
+        renditions[track.name] = track;
+      }
+    }
+    return renditions;
+  }
+  function assertNoRetiredTrackFields(catalog) {
+    if (catalog && typeof catalog === "object" && "commonTrackFields" in catalog) {
+      throw new Error("multicast catalog policy: $.commonTrackFields is retired; every track must declare its own packaging");
+    }
+    const tracks = Array.isArray(catalog?.tracks) ? catalog.tracks : [];
+    tracks.forEach((track, index) => {
+      if (track && typeof track === "object" && "selectionParams" in track) {
+        throw new Error(`multicast catalog policy: $.tracks[${index}].selectionParams is retired; selection fields are flat on the track`);
+      }
+    });
+  }
+  function catalogRepairTracks(catalog, name) {
+    assertNoRetiredTrackFields(catalog);
+    const tracks = Array.isArray(catalog?.tracks) ? catalog.tracks : [];
+    const track = tracks.find((candidate) => candidate?.name === name);
+    const rendition = catalog?.video?.renditions?.[name] ?? catalog?.audio?.renditions?.[name];
+    const fec = track?.fec ?? rendition?.fec;
+    if (!fec || fec.algorithm === "none") return [];
+    const names = /* @__PURE__ */ new Set();
+    if (typeof fec.repairTrack === "string" && fec.repairTrack.length > 0) names.add(fec.repairTrack);
+    const dependsOn = (entry) => Array.isArray(entry?.depends) && entry.depends.length === 1 && entry.depends[0] === name;
+    for (const candidate of tracks) {
+      const packaging = candidate?.packaging;
+      if (packaging === "fec-repair" && typeof candidate?.name === "string" && candidate.name.length > 0 && dependsOn(candidate)) {
+        names.add(candidate.name);
+      }
+    }
+    const repairRenditions = catalog?.repair?.renditions;
+    if (repairRenditions && typeof repairRenditions === "object") {
+      for (const [repairName, entry] of Object.entries(repairRenditions)) {
+        if (repairName.length > 0 && dependsOn(entry)) names.add(repairName);
+      }
+    }
+    return [...names];
+  }
+  function catalogQualityLadder(catalog, role = "video") {
+    return Object.entries(catalogRenditions(catalog, role)).map(([name, config]) => {
+      const { bitrate, codedWidth, codedHeight, framerate } = config ?? {};
+      if (!isPositiveFinite(bitrate)) {
+        throw new RangeError(`[ABR] catalog ${role} rendition ${name} states no positive bitrate to cost it by`);
+      }
+      const rung = { name, bitrate };
+      if (isPositiveFinite(codedWidth)) rung.width = codedWidth;
+      if (isPositiveFinite(codedHeight)) rung.height = codedHeight;
+      if (isPositiveFinite(framerate)) rung.fps = framerate;
+      return rung;
+    });
+  }
+  function isPositiveFinite(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+  }
+  function videoRenditionRank(config, name) {
+    if (typeof config?.bitrate === "number" && config.bitrate > 0) return config.bitrate;
+    const width = typeof config?.codedWidth === "number" ? config.codedWidth : 0;
+    const height = typeof config?.codedHeight === "number" ? config.codedHeight : 0;
+    if (width > 0 && height > 0) return width * height;
+    const match = /(?:^|[/_.-])(\d{3,4})p(?:$|[/_.-])/i.exec(name);
+    return match ? Number(match[1]) : Number.POSITIVE_INFINITY;
+  }
+  function lowestServedVideoRendition(catalog, endpoints) {
+    const renditions = catalog?.video?.renditions ?? {};
+    const servedTracks = new Set(endpoints.flatMap((endpoint) => endpoint.tracks?.map((track) => track.name) ?? []));
+    let selected = "";
+    let selectedRank = Number.POSITIVE_INFINITY;
+    for (const [name, config] of Object.entries(renditions)) {
+      if (!name || !servedTracks.has(name)) continue;
+      const rank = videoRenditionRank(config, name);
+      if (!selected || rank < selectedRank) {
+        selected = name;
+        selectedRank = rank;
+      }
+    }
+    return selected;
+  }
+
+  // src/packet-batch.ts
+  function subscriptionDeliversPacketBatches(subscription) {
+    return subscription.eventTypes?.includes("packets") === true;
+  }
 
   // src/multicast-subscription-pool.ts
   var MulticastSubscriptionPool = class {
@@ -420,19 +1084,28 @@
       return this.#entries.size;
     }
     async #createEntry(gateway, endpoint, onClosed) {
-      const subscription = await gateway.subscribe({
+      const subscription = await gateway.subscribe(toWindowMulticastSubscribeConfig({
         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 packetListener = subscriptionDeliversPacketBatches(subscription) ? {
+        type: "packets",
+        listener: (event) => {
+          for (const data of event.detail) {
+            this.#dispatch(consumers, (consumer) => consumer.onBytes(data));
+          }
+        }
+      } : {
+        type: "bytes",
+        listener: (event) => {
+          this.#dispatch(consumers, (consumer) => consumer.onBytes(event.detail));
+        }
       };
       const stateListener = (event) => {
         this.#dispatch(consumers, (consumer) => consumer.onState?.(event.detail));
@@ -445,8 +1118,12 @@
         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);
+      entry = { subscription, consumers, packetListener, stateListener, errorListener, closed: false };
+      if (packetListener.type === "packets") {
+        subscription.addEventListener("packets", packetListener.listener);
+      } else {
+        subscription.addEventListener("bytes", packetListener.listener);
+      }
       subscription.addEventListener("state", stateListener);
       subscription.addEventListener("error", errorListener);
       return entry;
@@ -461,7 +1138,12 @@
       return id;
     }
     #detach(entry) {
-      entry.subscription.removeEventListener("bytes", entry.bytesListener);
+      const { packetListener } = entry;
+      if (packetListener.type === "packets") {
+        entry.subscription.removeEventListener("packets", packetListener.listener);
+      } else {
+        entry.subscription.removeEventListener("bytes", packetListener.listener);
+      }
       entry.subscription.removeEventListener("state", entry.stateListener);
       entry.subscription.removeEventListener("error", entry.errorListener);
     }
@@ -477,7 +1159,70 @@
   };
   var multicastSubscriptionPool = new MulticastSubscriptionPool();
 
+  // src/moqt-priority.ts
+  var MAX_MOQT_PRIORITY = 255;
+  function moqtPriority(value, field) {
+    if (!Number.isInteger(value) || value < 0 || value > MAX_MOQT_PRIORITY) {
+      throw new RangeError(`${field} must be an integer in [0, ${MAX_MOQT_PRIORITY}], got ${value}`);
+    }
+    return value;
+  }
+  function moqtSubscriberPriority(value) {
+    return moqtPriority(value, "MOQT subscriber priority");
+  }
+  function moqtPublisherPriority(value) {
+    return moqtPriority(value, "MOQT publisher priority");
+  }
+  var MOQT_SUBSCRIBER_PRIORITY = Object.freeze({
+    catalog: moqtSubscriberPriority(0),
+    /**
+     * @deprecated A repair FETCH's SUBSCRIBER_PRIORITY is derived per request
+     * from the catalog source and repair priorities (draft-ramadan-moq-fec
+     * §11.4.5), not a player constant. Use the `subscriberPriority` that
+     * `@blockcast/mmt-container`'s `wireRepairFetch` puts on each
+     * `RepairFetchRequest` (`repairFetchSubscriberPriority`).
+     */
+    deadlineRepair: moqtSubscriberPriority(0),
+    audio: moqtSubscriberPriority(1),
+    video: moqtSubscriberPriority(2),
+    /**
+     * @deprecated See `deadlineRepair`: use the request's catalog-derived
+     * `RepairFetchRequest.subscriberPriority` (draft-ramadan-moq-fec §11.4.5).
+     */
+    backgroundRepair: moqtSubscriberPriority(3)
+  });
+  var MOQT_PUBLISHER_PRIORITY = Object.freeze({
+    catalog: moqtPublisherPriority(32),
+    source: moqtPublisherPriority(128),
+    repair: moqtPublisherPriority(240)
+  });
+
   // src/stall-detector.ts
+  function classifyStall({
+    liveQ = null,
+    decodeCallsDelta = null,
+    fps = null
+  } = {}) {
+    if (liveQ != null && liveQ >= 20) {
+      return {
+        verdict: "DECODE-BOUND",
+        reason: `decode queue backlogged now (liveQ=${liveQ})`
+      };
+    }
+    if (liveQ != null && liveQ <= 2 && decodeCallsDelta != null && decodeCallsDelta <= 1) {
+      return {
+        verdict: "PIPELINE-STARVED",
+        reason: `queue empty (liveQ=${liveQ}) and decode flatlined (\u0394calls=${decodeCallsDelta}) \u2014 nothing reaching the decoder; suspect delivery/FEC/failback, not decode perf`
+      };
+    }
+    if (fps != null && fps < 45) {
+      return {
+        verdict: "STARVED-OR-SLOW",
+        reason: `low decode rate (fps=${fps}) without a queue/flatline signal to disambiguate`
+      };
+    }
+    return { verdict: "INDETERMINATE", reason: "no signal supports a verdict" };
+  }
   var TransportStallDetector = class {
     constructor(config) {
       this.config = config;
@@ -553,13 +1298,39 @@
   }
   async function wireStarvationDetector(args) {
     if (!args.session || args.fecInterleaveMs <= 0 || args.fecK <= 0) return null;
+    const windowMs = args.deliveryWindowMs ?? Math.ceil(args.fecInterleaveMs * 3);
+    if (!Number.isFinite(windowMs) || windowMs <= 0) {
+      args.warn?.(`Unable to create starvation detector for ${args.trackName}: invalid delivery window ${windowMs}`);
+      return null;
+    }
     const detector = wireStallDetector({
       session: args.session,
-      windowMs: Math.ceil(args.fecInterleaveMs * 3),
+      windowMs,
       makeDetector: args.makeDetector
     });
     if (!detector) args.warn?.(`Unable to create starvation detector for ${args.trackName}`);
-    return detector;
+    if (!detector || typeof args.session.state !== "string") return detector;
+    let active = false;
+    return {
+      update(snapshot) {
+        const state = args.session.state;
+        const shouldObserve = state === "multicast" || state === "amt" || state === "failing";
+        if (!shouldObserve) {
+          if (active) detector.reset();
+          active = false;
+          return;
+        }
+        if (!active) {
+          detector.reset();
+          active = true;
+        }
+        detector.update(snapshot);
+      },
+      reset() {
+        active = false;
+        detector.reset();
+      }
+    };
   }
 
   // src/driad-discovery.ts
@@ -619,10 +1390,7 @@
       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 }
-      ];
+      return [];
     }
     /**
      * Query DNS-over-HTTPS for DRIAD relay based on source address (RFC 8777)
@@ -643,7 +1411,7 @@
         if (result.Answer && result.Answer.length > 0) {
           return {
             host: result.Answer[0].data,
-            port: 2268,
+            port: DEFAULT_AMT_RELAY_PORT,
             priority: 10,
             weight: 100,
             asn: 0
@@ -713,16 +1481,14 @@
     capabilities = null;
     subscription = null;
     driad = new DRIADDiscovery();
-    abr;
+    /** Built by `connect()` from the caller's ladder; there is no built-in one. */
+    abr = null;
     multicastOrchestrator = null;
     onOrchestratorCommand;
     connectionGeneration = 0;
     onPacket;
     onError;
     onStateChange;
-    constructor() {
-      this.abr = new AdaptiveBitrateController();
-    }
     getWindow() {
       return typeof window === "undefined" ? void 0 : window;
     }
@@ -773,11 +1539,31 @@
      * 1. window.multicast gateway bytes
      * 2. AMT proxy (specified or discovered via DRIAD)
      * 3. MOQ WebTransport (final fallback)
+     *
+     * The ABR ladder (`abrLadder`) and initial rendition (`initialQuality`)
+     * are checked first, before anything is torn down. A config that fails is
+     * refused with the same shape as an invalid endpoint, the error to the
+     * error callback and `false` resolved; unlike one, it is caught before the
+     * live subscription closes, so a refused reconnect leaves that subscription,
+     * its state and any connect already in flight untouched.
      */
     async connect(config) {
+      let abr;
+      try {
+        abr = new AdaptiveBitrateController({
+          ladder: config.abrLadder,
+          initialQuality: config.initialQuality?.name
+        });
+      } catch (error) {
+        const refused = error instanceof Error ? error : new Error(String(error));
+        if (this.onError) this.onError(refused);
+        else console.error("[Transport] ABR config refused, not connecting:", refused);
+        return false;
+      }
       const generation = ++this.connectionGeneration;
       this.subscription?.close();
       this.subscription = null;
+      this.abr = null;
       this.state = {
         mode: "disconnected",
         connected: false,
@@ -809,10 +1595,8 @@
       };
       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.abr = abr;
+      abr.setCallback((quality) => {
         this.state.quality = quality;
         this.subscription?.onqualitychange?.(quality);
         this.onStateChange?.(this.state);
@@ -877,7 +1661,7 @@
           connected: true,
           group: config.group,
           source: config.source,
-          quality: this.abr.getCurrentQuality(),
+          quality: this.requireAbr().getCurrentQuality(),
           packetsReceived: 0,
           bytesReceived: 0,
           lastPacketTime: 0
@@ -923,8 +1707,7 @@
     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`);
+        const wsUrl = new URL(`wss://${relayHost}/amt-proxy`);
         wsUrl.searchParams.set("group", config.group);
         wsUrl.searchParams.set("source", config.source || "");
         wsUrl.searchParams.set("port", String(config.port));
@@ -954,7 +1737,7 @@
               group: config.group,
               source: config.source,
               amtRelay,
-              quality: this.abr.getCurrentQuality(),
+              quality: this.requireAbr().getCurrentQuality(),
               packetsReceived: 0,
               bytesReceived: 0,
               lastPacketTime: 0
@@ -999,7 +1782,7 @@
       this.state.packetsReceived++;
       this.state.bytesReceived += data.byteLength;
       this.state.lastPacketTime = Date.now();
-      this.abr.recordSample(data.byteLength, 0);
+      this.abr?.recordSample(data.byteLength, 0);
       this.onPacket?.(data);
     }
     /**
@@ -1009,16 +1792,26 @@
       return { ...this.state };
     }
     /**
-     * Get current quality level
+     * The rung of the live connection's `abrLadder` ABR is on; `null` when
+     * there is no ladder (before `connect(config)` succeeds, after
+     * `disconnect()`, or after a reconnect that was torn down and bailed).
      */
     getQuality() {
-      return this.abr.getCurrentQuality();
+      return this.abr?.getCurrentQuality() ?? null;
     }
     /**
-     * Force quality level
+     * Force the rung named `name` of the live connection's `abrLadder`.
+     * Throws `Error` when there is no ladder (see `getQuality()`), and
+     * `RangeError` when the ladder has no rung of that name; it never falls
+     * back to another rung.
      */
     setQuality(name) {
-      this.abr.setQuality(name);
+      this.requireAbr().setQuality(name);
+    }
+    /** The controller `connect()` built; before it there is no ladder to adapt over. */
+    requireAbr() {
+      if (!this.abr) throw new Error("[Transport] ABR has no ladder before connect(config)");
+      return this.abr;
     }
     /** Configures multicast-only ABR while leaving the caller's MoQ ABR untouched. */
     configureMulticastTiers(options, onCommand) {
@@ -1030,6 +1823,9 @@
     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));
     }
@@ -1061,6 +1857,7 @@
       this.connectionGeneration++;
       this.subscription?.close();
       this.subscription = null;
+      this.abr = null;
       this.dispatchOrchestratorCommand(this.multicastOrchestrator?.cancel());
       this.multicastOrchestrator = null;
       this.onOrchestratorCommand = void 0;
@@ -1127,8 +1924,21 @@
   // src/no-modules.ts
   var api = {
     AdaptiveBitrateController,
+    validateQualityLadder,
+    catalogQualityLadder,
+    classifyStall,
+    createMulticastSignalingReconciler,
+    endpointToMulticastConfig,
+    hasMulticastCatalogBaseline,
+    hasUnicastMediaRenditions,
+    isRecoverableMulticastSignalReadError,
+    isMulticastOnlyCatalog,
     MulticastOrchestrator,
     MulticastSubscriptionPool,
+    MOQT_PUBLISHER_PRIORITY,
+    MOQT_SUBSCRIBER_PRIORITY,
+    moqtPublisherPriority,
+    moqtSubscriberPriority,
     TransportManager,
     TransportStallDetector,
     endpointKey,
@@ -1136,11 +1946,22 @@
     isUsableMulticastEndpoint,
     isValidMulticastGroupAddress,
     makeSourceSwitchHandler,
+    mergeUrlMulticastPolicy,
     multicastEndpointKey,
+    normalizeCatalogEndpoints,
+    normalizeMulticastConfig,
     normalizeMulticastEndpoint,
+    readPlayerMulticastConfig,
     readUrlMulticastConfig,
+    toWindowMulticastSubscribeConfig,
+    requiresMulticastCapability,
     runUnicastFallback,
+    sameMulticastConfig,
+    selectEndpointPacketIds,
+    selectMulticastCandidate,
     selectMulticastTier,
+    urlOverrideBlocksMulticastCandidate,
+    withMulticastEndpoints,
     wireStarvationDetector
   };
   Object.defineProperty(globalThis, "__MmtTransport", {