@blockcast/mmt-container 2.1.0-main.36792a9d6614 → 2.1.0

package/dist/mmtp-router.js

@@ -377,1412 +377,6 @@ var RUNTIME_FEC_RECEIVER = Object.freeze({
   overlays: true
 });
 
-// node_modules/@blockcast/mmt-transport/dist/multicast-tier.js
-function endpointKey(endpoint) {
-  return `${endpoint.sourceAddress ?? ""}|${endpoint.groupAddress}|${endpoint.port}`;
-}
-function carriesMedia(endpoint) {
-  return endpoint.carriesMedia !== false;
-}
-function selectMulticastTier(endpoints, estimate) {
-  const media = endpoints.filter(carriesMedia);
-  if (media.length <= 1)
-    return media[0];
-  const ranked = media.filter((endpoint) => typeof endpoint.bandwidth === "number" && endpoint.bandwidth > 0).sort((a, b) => a.bandwidth - b.bandwidth);
-  if (ranked.length < 2)
-    return media[0];
-  if (estimate === void 0)
-    return ranked[0];
-  const budget = estimate * 0.8;
-  let selected;
-  for (const endpoint of ranked) {
-    if (endpoint.bandwidth <= budget)
-      selected = endpoint;
-  }
-  return selected ?? ranked[0];
-}
-
-// node_modules/@blockcast/mmt-transport/dist/abr-controller.js
-var QUALITY_LEVELS = Object.freeze([
-  { name: "240p", bitrate: 3e5, width: 426, height: 240, fps: 15 },
-  { name: "360p", bitrate: 5e5, width: 640, height: 360, fps: 24 },
-  { name: "480p", bitrate: 1e6, width: 854, height: 480, fps: 30 },
-  { name: "720p", bitrate: 25e5, width: 1280, height: 720, fps: 30 },
-  { name: "1080p", bitrate: 5e6, width: 1920, height: 1080, fps: 30 },
-  { name: "1440p", bitrate: 8e6, width: 2560, height: 1440, fps: 30 },
-  { name: "4K", bitrate: 15e6, width: 3840, height: 2160, fps: 30 }
-].map((level) => Object.freeze(level)));
-function positiveFinite(value) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0;
-}
-function validateQualityLadder(ladder) {
-  if (!Array.isArray(ladder) || ladder.length === 0) {
-    throw new TypeError("[ABR] ladder must list at least one rendition (e.g. the catalog's video tracks)");
-  }
-  const names = /* @__PURE__ */ new Set();
-  for (const level of ladder) {
-    if (typeof level?.name !== "string" || level.name.length === 0) {
-      throw new TypeError("[ABR] every ladder rendition needs a name");
-    }
-    if (!positiveFinite(level.bitrate)) {
-      throw new RangeError(`[ABR] rendition ${level.name}: bitrate must be a positive finite number, got ${String(level.bitrate)}`);
-    }
-    for (const field of ["width", "height", "fps"]) {
-      if (level[field] !== void 0 && !positiveFinite(level[field])) {
-        throw new RangeError(`[ABR] rendition ${level.name}: ${field} must be a positive finite number when stated, got ${String(level[field])}`);
-      }
-    }
-    if (names.has(level.name))
-      throw new RangeError(`[ABR] rendition ${level.name} appears twice in the ladder`);
-    names.add(level.name);
-  }
-  return Object.freeze([...ladder].sort((a, b) => a.bitrate - b.bitrate).map((level) => Object.freeze({ ...level })));
-}
-var AdaptiveBitrateController = class {
-  /** The caller's renditions, ascending by bitrate (`validateQualityLadder`). */
-  ladder;
-  currentQualityIndex;
-  history = [];
-  historyWindow = 1e4;
-  // 10 second window
-  upgradeThreshold = 0.8;
-  // 80% of target bitrate sustained
-  downgradeThreshold = 0.5;
-  // 50% of target bitrate triggers downgrade
-  stabilityPeriod = 5e3;
-  // Wait 5s before upgrading
-  lastQualityChange = 0;
-  onQualityChange;
-  // FEC stats for effective loss rate calculation
-  fecStats = {
-    rawLossRate: 0,
-    effectiveLossRate: 0,
-    recoveryRate: 1,
-    fecEnabled: false
-  };
-  constructor(options) {
-    if (!options || typeof options !== "object") {
-      throw new TypeError("[ABR] AdaptiveBitrateController needs { ladder, initialQuality }");
-    }
-    this.ladder = validateQualityLadder(options.ladder);
-    this.currentQualityIndex = options.initialQuality === void 0 ? 0 : this.ladder.findIndex((q) => q.name === options.initialQuality);
-    if (this.currentQualityIndex < 0) {
-      throw new RangeError(`[ABR] initial rendition ${String(options.initialQuality)} is not in the ladder`);
-    }
-  }
-  setCallback(callback) {
-    this.onQualityChange = callback;
-  }
-  getCurrentQuality() {
-    return this.ladder[this.currentQualityIndex];
-  }
-  /** Selects the multicast (S,G) tier without replacing a player's unicast ABR manager. */
-  selectMulticastTier(endpoints, estimate = this.getMetrics().measuredBitrate || void 0) {
-    return selectMulticastTier(endpoints, estimate);
-  }
-  /**
-   * Record network sample for bitrate adaptation
-   *
-   * @param bytesReceived - Bytes received in this sample
-   * @param packetsLost - Packets lost (raw, before FEC recovery)
-   */
-  recordSample(bytesReceived, packetsLost) {
-    const now = Date.now();
-    this.history.push({ timestamp: now, bytesReceived, packetsLost });
-    this.history = this.history.filter((s) => now - s.timestamp < this.historyWindow);
-    const { measuredBitrate, lossRate: rawLossRate } = this.calculateMetrics();
-    const currentQuality = this.getCurrentQuality();
-    const effectiveLossRate = this.fecStats.fecEnabled ? this.fecStats.effectiveLossRate : rawLossRate;
-    if (now - this.lastQualityChange < this.stabilityPeriod) {
-      return;
-    }
-    if (effectiveLossRate > 0.05 || measuredBitrate < currentQuality.bitrate * this.downgradeThreshold) {
-      this.downgrade();
-      return;
-    }
-    if (measuredBitrate > currentQuality.bitrate * this.upgradeThreshold && effectiveLossRate < 0.01 && this.currentQualityIndex < this.ladder.length - 1) {
-      this.upgrade();
-    }
-  }
-  /**
-   * Update FEC statistics for ABR decisions
-   *
-   * ABR uses the effective loss rate (after FEC recovery) rather than the
-   * raw transport loss rate.
-   *
-   * @param stats - FEC statistics from the FEC decoder
-   */
-  setFecStats(stats) {
-    this.fecStats = stats;
-  }
-  /**
-   * Get current FEC statistics
-   */
-  getFecStats() {
-    return { ...this.fecStats };
-  }
-  calculateMetrics() {
-    if (this.history.length < 2) {
-      return { measuredBitrate: 0, lossRate: 0 };
-    }
-    const totalBytes = this.history.reduce((sum, s) => sum + s.bytesReceived, 0);
-    const totalLost = this.history.reduce((sum, s) => sum + s.packetsLost, 0);
-    const duration = (this.history[this.history.length - 1].timestamp - this.history[0].timestamp) / 1e3;
-    const measuredBitrate = duration > 0 ? totalBytes * 8 / duration : 0;
-    const lossRate = totalLost / (this.history.length + totalLost);
-    return { measuredBitrate, lossRate };
-  }
-  upgrade() {
-    if (this.currentQualityIndex >= this.ladder.length - 1)
-      return;
-    this.currentQualityIndex++;
-    this.lastQualityChange = Date.now();
-    const newQuality = this.getCurrentQuality();
-    console.log(`[ABR] Upgrading to ${newQuality.name} (${newQuality.bitrate / 1e6}Mbps)`);
-    this.onQualityChange?.(newQuality);
-  }
-  downgrade() {
-    if (this.currentQualityIndex <= 0)
-      return;
-    this.currentQualityIndex--;
-    this.lastQualityChange = Date.now();
-    const newQuality = this.getCurrentQuality();
-    console.log(`[ABR] Downgrading to ${newQuality.name} (${newQuality.bitrate / 1e6}Mbps)`);
-    this.onQualityChange?.(newQuality);
-  }
-  /**
-   * Select a ladder rendition: the caller switched to it (a manual override,
-   * or a switch the caller made). Throws for a name the ladder does not carry.
-   */
-  setQuality(name) {
-    const index = this.ladder.findIndex((q) => q.name === name);
-    if (index < 0)
-      throw new RangeError(`[ABR] rendition ${name} is not in the ladder`);
-    this.currentQualityIndex = index;
-    this.lastQualityChange = Date.now();
-    this.onQualityChange?.(this.getCurrentQuality());
-  }
-  /**
-   * Get current metrics including both raw and effective loss rates
-   */
-  getMetrics() {
-    const { measuredBitrate, lossRate: rawLossRate } = this.calculateMetrics();
-    return {
-      measuredBitrate,
-      rawLossRate,
-      effectiveLossRate: this.fecStats.fecEnabled ? this.fecStats.effectiveLossRate : rawLossRate,
-      fecEnabled: this.fecStats.fecEnabled,
-      sampleCount: this.history.length
-    };
-  }
-  /**
-   * Reset history and start fresh
-   */
-  reset() {
-    this.history = [];
-    this.lastQualityChange = 0;
-  }
-};
-
-// node_modules/@blockcast/mmt-base/dist/mmtp.js
-var MPU_HEADER_SIZE2 = 8;
-var MPU_LENGTH_FIELD_SIZE2 = 2;
-var MPU_HEADER_REMAINDER_SIZE2 = MPU_HEADER_SIZE2 - MPU_LENGTH_FIELD_SIZE2;
-var MMTP_SIGNALING_PACKET_ID2 = 0;
-var MMTP_PACKET_ID_MAX = 65535;
-
-// node_modules/@blockcast/mmt-base/dist/net-constants.js
-var DEFAULT_AMT_RELAY_PORT = 2268;
-
-// node_modules/@blockcast/mmt-base/dist/ntp-short.js
-var NTP_SHORT_BITS2 = 32;
-var NTP_SHORT_MODULUS2 = 2 ** NTP_SHORT_BITS2;
-var NTP_SHORT_HALF_RANGE2 = 2 ** (NTP_SHORT_BITS2 - 1);
-function isNtpShort(value) {
-  return Number.isInteger(value) && value >= 0 && value < NTP_SHORT_MODULUS2;
-}
-function compareNtpShort(a, b) {
-  if (!isNtpShort(a) || !isNtpShort(b)) {
-    throw new RangeError(`NTP-short values must be integers in [0, 2^${NTP_SHORT_BITS2}), got ${String(a)} and ${String(b)}`);
-  }
-  if (a === b)
-    return "equal";
-  const forward = (a - b + NTP_SHORT_MODULUS2) % NTP_SHORT_MODULUS2;
-  if (forward < NTP_SHORT_HALF_RANGE2)
-    return "after";
-  if (forward > NTP_SHORT_HALF_RANGE2)
-    return "before";
-  return "unordered";
-}
-
-// node_modules/@blockcast/mmt-base/dist/fec-block-profile.js
-var FEC_BLOCK_PROFILES2 = Object.freeze([
-  "iso-ssbg1-v1"
-]);
-
-// node_modules/@blockcast/mmt-base/dist/fec-bindings.js
-var RUNTIME_FEC_RECEIVER2 = Object.freeze({
-  schemes: Object.freeze(["raptorq", "reed-solomon"]),
-  blockProfiles: Object.freeze(["iso-ssbg1-v1"]),
-  overlays: true
-});
-
-// node_modules/@blockcast/mmt-transport/dist/multicast-orchestrator.js
-var DEFAULT_DWELL_MS = 3e3;
-var DEFAULT_JOIN_DEADLINE_MS = 5e3;
-var MulticastOrchestrator = class {
-  options;
-  #state = "stable";
-  #current;
-  #target;
-  #estimate;
-  #favored;
-  #joinStartedAt = 0;
-  /**
-   * Latest active-tier send time (NTP short), or undefined before the first.
-   * "Latest" is serial order, not the numerically largest value: after the
-   * field wraps, the largest value is the stale one.
-   */
-  #highWater;
-  #dwellMs;
-  #joinDeadlineMs;
-  constructor(options) {
-    this.options = options;
-    this.#dwellMs = options.dwellMs ?? DEFAULT_DWELL_MS;
-    this.#joinDeadlineMs = options.joinDeadlineMs ?? DEFAULT_JOIN_DEADLINE_MS;
-    if (!Number.isFinite(this.#dwellMs) || !Number.isFinite(this.#joinDeadlineMs) || this.#dwellMs <= 0 || this.#joinDeadlineMs <= 0) {
-      throw new Error("Multicast dwell and join deadline must be positive");
-    }
-  }
-  get state() {
-    return this.#state;
-  }
-  get current() {
-    return this.#current;
-  }
-  get target() {
-    return this.#target;
-  }
-  get estimate() {
-    return this.#estimate;
-  }
-  start() {
-    this.#current ??= this.options.initialEndpoint ?? selectMulticastTier(this.options.endpoints, void 0);
-    return this.#current;
-  }
-  onGoodput(sample) {
-    const bitrate = sample.bitrate;
-    if (!this.#current)
-      return void 0;
-    if (this.#state === "joining")
-      return this.poll();
-    if (this.options.adaptive === false)
-      return void 0;
-    if (bitrate === void 0 || !Number.isFinite(bitrate))
-      return void 0;
-    this.#estimate = bitrate;
-    const desired = selectMulticastTier(this.options.endpoints, bitrate);
-    if (!desired)
-      return void 0;
-    const desiredKey = endpointKey(desired);
-    if (desiredKey === endpointKey(this.#current)) {
-      if (this.#favored?.source === "goodput")
-        this.#favored = void 0;
-      return void 0;
-    }
-    if (typeof desired.bandwidth !== "number" || typeof this.#current.bandwidth !== "number" || desired.bandwidth >= this.#current.bandwidth) {
-      if (this.#favored?.source === "goodput")
-        this.#favored = void 0;
-      return void 0;
-    }
-    const now = this.#now();
-    if (!this.#favored || this.#favored.key !== desiredKey || this.#favored.source !== "goodput") {
-      this.#favored = { key: desiredKey, since: now, source: "goodput" };
-      return void 0;
-    }
-    if (now - this.#favored.since < this.#dwellMs)
-      return void 0;
-    this.#state = "joining";
-    this.#target = desired;
-    this.#joinStartedAt = now;
-    this.#favored = void 0;
-    return { kind: "join-target", current: this.#current, target: desired };
-  }
-  onHeadroom(sample) {
-    if (!this.#current || this.options.adaptive === false || this.#state === "joining")
-      return void 0;
-    if (!sample.healthy) {
-      if (this.#favored?.source === "headroom")
-        this.#favored = void 0;
-      return void 0;
-    }
-    if (this.#favored?.source === "goodput")
-      return void 0;
-    const currentBandwidth = this.#current.bandwidth;
-    if (typeof currentBandwidth !== "number")
-      return void 0;
-    const desired = this.options.endpoints.filter((endpoint) => carriesMedia(endpoint) && typeof endpoint.bandwidth === "number" && endpoint.bandwidth > currentBandwidth).sort((a, b) => a.bandwidth - b.bandwidth)[0];
-    if (!desired) {
-      this.#favored = void 0;
-      return void 0;
-    }
-    const desiredKey = endpointKey(desired);
-    if (desiredKey === endpointKey(this.#current)) {
-      this.#favored = void 0;
-      return void 0;
-    }
-    const now = this.#now();
-    if (!this.#favored || this.#favored.key !== desiredKey) {
-      this.#favored = { key: desiredKey, since: now, source: "headroom" };
-      return void 0;
-    }
-    if (now - this.#favored.since < this.#dwellMs)
-      return void 0;
-    this.#state = "joining";
-    this.#target = desired;
-    this.#joinStartedAt = now;
-    this.#favored = void 0;
-    return { kind: "join-target", current: this.#current, target: desired };
-  }
-  /**
-   * Join `target` because the viewer selected it, not because goodput or
-   * headroom ranked it. It runs whether or not the orchestrator adapts, and
-   * takes the path an adaptive join takes: commit on the target's RAP at or
-   * beyond the high-water mark, abandon at the join deadline. While it is
-   * pending nothing re-ranks the ladder; goodput only advances the deadline.
-   *
-   * Returns undefined, changing nothing, while another join is pending (cancel
-   * it first), when `target` is the current tier, or when it carries no media.
-   */
-  select(target) {
-    if (!this.#current || this.#state === "joining" || !carriesMedia(target))
-      return void 0;
-    if (endpointKey(target) === endpointKey(this.#current))
-      return void 0;
-    this.#state = "joining";
-    this.#target = target;
-    this.#joinStartedAt = this.#now();
-    this.#favored = void 0;
-    return { kind: "join-target", current: this.#current, target };
-  }
-  /**
-   * Feed a packet from the active tier (to advance the high-water mark) or
-   * from the in-flight target (to find a committable RAP).
-   *
-   * Serial order is only the true order while the compared instants are less
-   * than `NTP_SHORT_HALF_RANGE` (2^15 s, ~9.1 h) apart. Feeding every
-   * active-tier packet keeps the mark that close to the live stream. A mark
-   * refreshed only by commits can fall further behind than that, and a
-   * target RAP may then compare as older, so the join is abandoned.
-   */
-  onTierPacket(packet) {
-    if (!this.#current)
-      return void 0;
-    const sentAt = tierPacketSendTime(packet);
-    if (packet.endpointKey === endpointKey(this.#current) && sentAt !== void 0 && (this.#highWater === void 0 || compareNtpShort(sentAt, this.#highWater) === "after")) {
-      this.#highWater = sentAt;
-    }
-    if (this.#state !== "joining" || !this.#target)
-      return void 0;
-    const expired = this.poll();
-    if (expired)
-      return expired;
-    if (packet.endpointKey !== endpointKey(this.#target) || !packet.keyframe || !packet.hasValidCodecConfig || sentAt === void 0 || !this.#reachesHighWater(sentAt))
-      return void 0;
-    const command = {
-      kind: "commit-swap",
-      target: this.#target,
-      old: this.#current
-    };
-    this.#highWater = sentAt;
-    this.#current = this.#target;
-    this.#target = void 0;
-    this.#state = "stable";
-    return command;
-  }
-  poll() {
-    if (this.#state !== "joining" || !this.#target || !this.#current)
-      return void 0;
-    if (this.#now() - this.#joinStartedAt < this.#joinDeadlineMs)
-      return void 0;
-    return this.cancel();
-  }
-  cancel() {
-    if (this.#state !== "joining" || !this.#target || !this.#current)
-      return void 0;
-    const command = {
-      kind: "abandon-join",
-      current: this.#current,
-      target: this.#target
-    };
-    this.#target = void 0;
-    this.#state = "stable";
-    return command;
-  }
-  /**
-   * Whether a target RAP sent at `sentAt` is at or beyond the active tier's
-   * high-water mark. A pair exactly half the NTP-short space apart has no
-   * serial order, so it cannot show that and does not commit.
-   */
-  #reachesHighWater(sentAt) {
-    if (this.#highWater === void 0)
-      return true;
-    const order = compareNtpShort(sentAt, this.#highWater);
-    return order === "after" || order === "equal";
-  }
-  #now() {
-    const now = this.options.now();
-    if (!Number.isFinite(now))
-      throw new Error("Multicast orchestrator clock must be finite");
-    return now;
-  }
-};
-function tierPacketSendTime(packet) {
-  if (!Number.isFinite(packet.timestamp))
-    return void 0;
-  if (!isNtpShort(packet.timestamp)) {
-    throw new RangeError(`Multicast tier packet timestamp must be an MMTP NTP-short send time, got ${packet.timestamp}`);
-  }
-  return packet.timestamp;
-}
-
-// node_modules/@blockcast/mmt-transport/dist/endpoint-config.js
-function toWindowMulticastSubscribeConfig(input) {
-  if (input.mode !== void 0 && !["auto", "native", "tunnel"].includes(input.mode)) {
-    throw new TypeError(`Unsupported multicast mode: ${String(input.mode)}`);
-  }
-  if (input.packetIds !== void 0 && !Array.isArray(input.packetIds)) {
-    throw new TypeError(`multicast packetIds must be an array, got ${input.packetIds === null ? "null" : typeof input.packetIds}`);
-  }
-  if (input.packetIds?.some((id) => !isMulticastTrackPacketId(id)) || input.tracks?.some((track) => !isMulticastTrackPacketId(track.packetId))) {
-    throw new RangeError(`multicast packetId must be an integer from 1 to ${MMTP_PACKET_ID_MAX}; packetId 0 is the MMTP signaling flow and is never a track's`);
-  }
-  const source = input.source?.trim() || void 0;
-  const senderAddress = input.senderAddress?.trim() || void 0;
-  if (source && senderAddress) {
-    throw new TypeError("multicast senderAddress is an ASM filter and never appears beside source");
-  }
-  const base = {
-    group: input.group,
-    port: input.port,
-    ...source ? { source } : {},
-    consume: "bytes",
-    ...input.packetIds?.length ? { packetIds: [...input.packetIds] } : {}
-  };
-  const filter = senderAddress ? { senderAddress } : {};
-  if (input.atsc3) {
-    if (senderAddress)
-      throw new TypeError("an ATSC3 tuner request carries no senderAddress");
-    const { frequency, plpId, serviceId } = input.atsc3;
-    if (!Number.isInteger(frequency) || frequency < 1) {
-      throw new TypeError(`ATSC3 tuning requires a positive integer frequency in kHz, got ${String(frequency)}`);
-    }
-    return {
-      ...base,
-      origin: "tuner",
-      standard: "atsc3",
-      frequency,
-      ...plpId !== void 0 ? { plpId } : {},
-      ...serviceId !== void 0 ? { serviceId } : {}
-    };
-  }
-  const relay = input.amtRelay?.trim();
-  const driad = !relay && input.amtDiscovery === "driad";
-  const wantsAmt = input.mode === "tunnel" || input.mode !== "native" && (relay !== void 0 && relay !== "" || driad);
-  if (!wantsAmt) {
-    const native = {
-      ...base,
-      ...filter,
-      origin: "ip-multicast",
-      ...input.tracks?.length ? { tracks: input.tracks.map(({ name, packetId }) => ({ name, packetId })) } : {}
-    };
-    return native;
-  }
-  const relayPort = input.amtRelayPort;
-  if (driad) {
-    if (!base.source)
-      throw new TypeError("AMT DRIAD discovery requires a source address");
-    if (relayPort !== void 0 && !isPositivePort(relayPort)) {
-      throw new TypeError("AMT DRIAD discovery requires a valid relay port when one is given");
-    }
-    return {
-      ...base,
-      source: base.source,
-      origin: "amt",
-      discovery: "driad",
-      ...relayPort !== void 0 ? { relayPort } : {}
-    };
-  }
-  if (!relay || relayPort === void 0 || !isPositivePort(relayPort)) {
-    throw new TypeError("AMT requires a resolved relay and a valid relay port");
-  }
-  return {
-    ...base,
-    ...filter,
-    origin: "amt",
-    relay,
-    relayPort
-  };
-}
-function isValidMulticastGroupAddress(address) {
-  const value = address?.trim().toLowerCase();
-  if (!value)
-    return false;
-  if (value.startsWith("ff"))
-    return isValidIpv6MulticastAddress(value);
-  const parts = value.split(".");
-  if (parts.length !== 4)
-    return false;
-  const octets = parts.map((part) => {
-    if (!/^\d+$/.test(part))
-      return Number.NaN;
-    const octet = Number(part);
-    return Number.isInteger(octet) && octet >= 0 && octet <= 255 ? octet : Number.NaN;
-  });
-  return octets.every(Number.isInteger) && octets[0] >= 224 && octets[0] <= 239;
-}
-function normalizeMulticastEndpoint(endpoint) {
-  const groupAddress = endpoint.groupAddress.trim().toLowerCase();
-  const sourceAddress = endpoint.sourceAddress?.trim().toLowerCase() || void 0;
-  const senderAddress = endpoint.senderAddress?.trim().toLowerCase() || void 0;
-  if (sourceAddress && senderAddress)
-    return void 0;
-  const amtRelay = endpoint.amtRelay?.trim().toLowerCase() || void 0;
-  if (!isValidMulticastGroupAddress(groupAddress) || !isPositivePort(endpoint.port))
-    return void 0;
-  if (endpoint.mode && !["auto", "native", "tunnel"].includes(endpoint.mode))
-    return void 0;
-  if (endpoint.amtRelayPort !== void 0 && !isPositivePort(endpoint.amtRelayPort))
-    return void 0;
-  return {
-    groupAddress,
-    ...sourceAddress ? { sourceAddress } : {},
-    ...senderAddress ? { senderAddress } : {},
-    port: endpoint.port,
-    ...endpoint.mode ? { mode: endpoint.mode } : {},
-    ...amtRelay ? { amtRelay } : {},
-    ...endpoint.amtRelayPort ? { amtRelayPort: endpoint.amtRelayPort } : {},
-    ...endpoint.amtDiscovery === "driad" ? { amtDiscovery: "driad" } : {}
-  };
-}
-function multicastEndpointKey(endpoint) {
-  const normalized = normalizeMulticastEndpoint(endpoint);
-  if (!normalized)
-    throw new Error("Invalid multicast endpoint");
-  return JSON.stringify([
-    normalized.sourceAddress ?? "",
-    normalized.groupAddress,
-    normalized.port,
-    normalized.mode ?? "auto",
-    normalized.amtRelay ?? "",
-    normalized.amtRelayPort ?? "",
-    // A DRIAD join is a different gateway subscription from a native one.
-    ...normalized.amtDiscovery ? [normalized.amtDiscovery] : [],
-    // An ASM sender filter is a different subscription from the unfiltered join.
-    ...normalized.senderAddress ? [{ senderAddress: normalized.senderAddress }] : []
-  ]);
-}
-function isMulticastTrackPacketId(value) {
-  return Number.isInteger(value) && value > MMTP_SIGNALING_PACKET_ID2 && value <= MMTP_PACKET_ID_MAX;
-}
-function isValidIpv6MulticastAddress(value) {
-  if (!/^[0-9a-f:]+$/.test(value))
-    return false;
-  const compressed = value.includes("::");
-  if (value.indexOf("::") !== value.lastIndexOf("::"))
-    return false;
-  const groups = value.split(":").filter(Boolean);
-  if (groups.length === 0 || groups.length > 8)
-    return false;
-  if (!compressed && groups.length !== 8)
-    return false;
-  return groups.every((group) => /^[0-9a-f]{1,4}$/.test(group));
-}
-function isPositivePort(port) {
-  return Number.isInteger(port) && port > 0 && port <= 65535;
-}
-
-// node_modules/@blockcast/mmt-transport/dist/packet-batch.js
-function subscriptionDeliversPacketBatches(subscription) {
-  return subscription.eventTypes?.includes("packets") === true;
-}
-
-// node_modules/@blockcast/mmt-transport/dist/multicast-subscription-pool.js
-var MulticastSubscriptionPool = class {
-  #entries = /* @__PURE__ */ new Map();
-  #gatewayIds = /* @__PURE__ */ new WeakMap();
-  #nextGatewayId = 1;
-  async acquire(gateway, config, consumer) {
-    const endpoint = normalizeMulticastEndpoint({
-      groupAddress: config.group,
-      sourceAddress: config.source,
-      port: config.port,
-      mode: config.mode,
-      amtRelay: config.amtRelay,
-      amtRelayPort: config.amtRelayPort,
-      amtDiscovery: config.amtDiscovery
-    });
-    if (!endpoint)
-      throw new Error("Invalid multicast endpoint");
-    if (typeof gateway.subscribe !== "function")
-      throw new Error("window.multicast.subscribe unavailable");
-    const key = multicastEndpointKey(endpoint);
-    const internalKey = `${this.#gatewayId(gateway)}|${key}`;
-    let record = this.#entries.get(internalKey);
-    if (!record) {
-      record = { claims: 0, entry: Promise.resolve(null) };
-      const createdRecord = record;
-      record.entry = this.#createEntry(gateway, endpoint, (entry2) => {
-        if (this.#entries.get(internalKey) === createdRecord)
-          this.#entries.delete(internalKey);
-        this.#detach(entry2);
-      }).catch((error) => {
-        if (this.#entries.get(internalKey) === createdRecord)
-          this.#entries.delete(internalKey);
-        throw error;
-      });
-      this.#entries.set(internalKey, record);
-    }
-    record.claims++;
-    let entry;
-    try {
-      entry = await record.entry;
-    } catch (error) {
-      record.claims--;
-      throw error;
-    }
-    if (entry.closed) {
-      record.claims--;
-      return this.acquire(gateway, config, consumer);
-    }
-    const token = Symbol(key);
-    entry.consumers.set(token, consumer);
-    let released = false;
-    return {
-      key,
-      release: async () => {
-        if (released)
-          return;
-        released = true;
-        entry.consumers.delete(token);
-        record.claims--;
-        if (record.claims > 0)
-          return;
-        if (this.#entries.get(internalKey) === record)
-          this.#entries.delete(internalKey);
-        this.#detach(entry);
-        if (!entry.closed)
-          await entry.subscription.unsubscribe();
-      }
-    };
-  }
-  get size() {
-    return this.#entries.size;
-  }
-  async #createEntry(gateway, endpoint, onClosed) {
-    const subscription = await gateway.subscribe(toWindowMulticastSubscribeConfig({
-      group: endpoint.groupAddress,
-      ...endpoint.sourceAddress ? { source: endpoint.sourceAddress } : {},
-      port: endpoint.port,
-      ...endpoint.mode ? { mode: endpoint.mode } : {},
-      ...endpoint.amtRelay ? { amtRelay: endpoint.amtRelay } : {},
-      ...endpoint.amtRelayPort ? { amtRelayPort: endpoint.amtRelayPort } : {},
-      ...endpoint.amtDiscovery ? { amtDiscovery: endpoint.amtDiscovery } : {}
-    }));
-    const consumers = /* @__PURE__ */ new Map();
-    let entry;
-    const packetListener = subscriptionDeliversPacketBatches(subscription) ? {
-      type: "packets",
-      listener: (event) => {
-        for (const data of event.detail) {
-          this.#dispatch(consumers, (consumer) => consumer.onBytes(data));
-        }
-      }
-    } : {
-      type: "bytes",
-      listener: (event) => {
-        this.#dispatch(consumers, (consumer) => consumer.onBytes(event.detail));
-      }
-    };
-    const stateListener = (event) => {
-      this.#dispatch(consumers, (consumer) => consumer.onState?.(event.detail));
-      if (event.detail === "closed" && !entry.closed) {
-        entry.closed = true;
-        onClosed(entry);
-      }
-    };
-    const errorListener = (event) => {
-      const error = event.detail instanceof Error ? event.detail : new Error(String(event.detail));
-      this.#dispatch(consumers, (consumer) => consumer.onError?.(error));
-    };
-    entry = { subscription, consumers, packetListener, stateListener, errorListener, closed: false };
-    if (packetListener.type === "packets") {
-      subscription.addEventListener("packets", packetListener.listener);
-    } else {
-      subscription.addEventListener("bytes", packetListener.listener);
-    }
-    subscription.addEventListener("state", stateListener);
-    subscription.addEventListener("error", errorListener);
-    return entry;
-  }
-  #gatewayId(gateway) {
-    const object = gateway;
-    let id = this.#gatewayIds.get(object);
-    if (!id) {
-      id = this.#nextGatewayId++;
-      this.#gatewayIds.set(object, id);
-    }
-    return id;
-  }
-  #detach(entry) {
-    const { packetListener } = entry;
-    if (packetListener.type === "packets") {
-      entry.subscription.removeEventListener("packets", packetListener.listener);
-    } else {
-      entry.subscription.removeEventListener("bytes", packetListener.listener);
-    }
-    entry.subscription.removeEventListener("state", entry.stateListener);
-    entry.subscription.removeEventListener("error", entry.errorListener);
-  }
-  #dispatch(consumers, callback) {
-    for (const consumer of consumers.values()) {
-      try {
-        callback(consumer);
-      } catch (error) {
-        console.error("[Transport] multicast consumer callback failed", error);
-      }
-    }
-  }
-};
-var multicastSubscriptionPool = new MulticastSubscriptionPool();
-
-// node_modules/@blockcast/mmt-transport/dist/transport-manager.js
-var TransportManager = class {
-  state = {
-    mode: "disconnected",
-    connected: false,
-    packetsReceived: 0,
-    bytesReceived: 0,
-    lastPacketTime: 0
-  };
-  capabilities = null;
-  subscription = null;
-  /** Built by `connect()` from the caller's ladder; there is no built-in one. */
-  abr = null;
-  multicastOrchestrator = null;
-  onOrchestratorCommand;
-  connectionGeneration = 0;
-  onPacket;
-  onError;
-  onStateChange;
-  getWindow() {
-    return typeof window === "undefined" ? void 0 : window;
-  }
-  getWindowMulticastGateway() {
-    return this.getWindow()?.multicast;
-  }
-  async getGatewayCapabilities(gateway) {
-    if (!gateway?.capabilities)
-      return void 0;
-    try {
-      return typeof gateway.capabilities === "function" ? await gateway.capabilities() : gateway.capabilities;
-    } catch (error) {
-      console.warn("[Transport] window.multicast capabilities failed:", error);
-      return void 0;
-    }
-  }
-  async gatewaySupportsBytes(gateway) {
-    if (typeof gateway?.subscribe !== "function")
-      return false;
-    if (!gateway.capabilities)
-      return true;
-    const capabilities = await this.getGatewayCapabilities(gateway);
-    if (!capabilities)
-      return false;
-    const consumeModes = capabilities.consumeModes;
-    return !consumeModes || consumeModes.includes("bytes");
-  }
-  /**
-   * Detect available transport capabilities
-   */
-  async detectCapabilities() {
-    if (this.capabilities)
-      return this.capabilities;
-    const gateway = this.getWindowMulticastGateway();
-    const hasGatewayBytes = await this.gatewaySupportsBytes(gateway);
-    const win = this.getWindow();
-    this.capabilities = {
-      nativeSSM: hasGatewayBytes,
-      nativeIGMP: hasGatewayBytes,
-      directSockets: typeof win?.UDPSocket !== "undefined",
-      amt: false,
-      driad: hasGatewayBytes,
-      // the gateway runs RFC 8777 discovery
-      fecDecode: false
-    };
-    console.log("[Transport] Capabilities:", this.capabilities);
-    return this.capabilities;
-  }
-  /**
-   * Connect using best available transport
-   *
-   * Promotion hierarchy:
-   * 1. window.multicast gateway bytes
-   * 2. AMT: a configured relay via the AMT proxy, else gateway DRIAD discovery
-   * 3. MOQ WebTransport (final fallback)
-   *
-   * The ABR ladder (`abrLadder`) and initial rendition (`initialQuality`)
-   * are checked first, before anything is torn down. A config that fails is
-   * refused with the same shape as an invalid endpoint, the error to the
-   * error callback and `false` resolved; unlike one, it is caught before the
-   * live subscription closes, so a refused reconnect leaves that subscription,
-   * its state and any connect already in flight untouched.
-   */
-  async connect(config) {
-    let abr;
-    try {
-      abr = new AdaptiveBitrateController({
-        ladder: config.abrLadder,
-        initialQuality: config.initialQuality?.name
-      });
-    } catch (error) {
-      const refused = error instanceof Error ? error : new Error(String(error));
-      if (this.onError)
-        this.onError(refused);
-      else
-        console.error("[Transport] ABR config refused, not connecting:", refused);
-      return false;
-    }
-    const generation = ++this.connectionGeneration;
-    this.subscription?.close();
-    this.subscription = null;
-    this.abr = null;
-    this.state = {
-      mode: "disconnected",
-      connected: false,
-      packetsReceived: 0,
-      bytesReceived: 0,
-      lastPacketTime: 0
-    };
-    this.onStateChange?.(this.state);
-    const endpoint = normalizeMulticastEndpoint({
-      groupAddress: config.group,
-      sourceAddress: config.source,
-      port: config.port,
-      mode: config.mode,
-      amtRelay: config.amtRelay,
-      amtRelayPort: config.amtRelayPort
-    });
-    if (!endpoint) {
-      const error = new Error("Invalid multicast endpoint configuration");
-      this.onError?.(error);
-      return false;
-    }
-    config = {
-      ...config,
-      group: endpoint.groupAddress,
-      source: endpoint.sourceAddress ?? "",
-      mode: endpoint.mode,
-      amtRelay: endpoint.amtRelay,
-      amtRelayPort: endpoint.amtRelayPort
-    };
-    const caps = await this.detectCapabilities();
-    if (generation !== this.connectionGeneration)
-      return false;
-    this.abr = abr;
-    abr.setCallback((quality) => {
-      this.state.quality = quality;
-      this.subscription?.onqualitychange?.(quality);
-      this.onStateChange?.(this.state);
-    });
-    let connected = false;
-    if (caps.nativeSSM || caps.nativeIGMP) {
-      console.log("[Transport] Attempting window.multicast...");
-      connected = await this.connectWindowMulticast(config, generation);
-      if (connected) {
-        if (generation !== this.connectionGeneration)
-          return false;
-        this.state.mode = "multicast";
-        return true;
-      }
-    }
-    if (!connected) {
-      console.log("[Transport] Attempting AMT tunnel...");
-      connected = await this.connectAmt(config, generation);
-      if (connected) {
-        if (generation !== this.connectionGeneration)
-          return false;
-        this.state.mode = "amt";
-        return true;
-      }
-    }
-    console.log("[Transport] All multicast transports failed, falling back to MOQ");
-    return false;
-  }
-  /**
-   * Connect via the lowercase window.multicast bytes gateway.
-   */
-  async connectWindowMulticast(config, generation, mode = "multicast") {
-    try {
-      const gateway = this.getWindowMulticastGateway();
-      if (typeof gateway?.subscribe !== "function")
-        return false;
-      const lease = await multicastSubscriptionPool.acquire(gateway, config, {
-        onBytes: (data) => {
-          if (generation === this.connectionGeneration)
-            this.handlePacket(data);
-        },
-        onState: (state) => {
-          if (generation !== this.connectionGeneration)
-            return;
-          this.state.connected = state !== "closed";
-          this.onStateChange?.(this.state);
-        },
-        onError: (error) => {
-          if (generation !== this.connectionGeneration)
-            return;
-          console.error("[Transport] window.multicast error:", error);
-          this.onError?.(error);
-        }
-      });
-      if (generation !== this.connectionGeneration) {
-        await lease.release();
-        return false;
-      }
-      this.subscription = {
-        id: lease.key,
-        config,
-        close: () => {
-          void lease.release();
-        }
-      };
-      this.state = {
-        mode,
-        connected: true,
-        group: config.group,
-        source: config.source,
-        quality: this.requireAbr().getCurrentQuality(),
-        packetsReceived: 0,
-        bytesReceived: 0,
-        lastPacketTime: 0
-      };
-      console.log(`[Transport] Connected via window.multicast: (${config.source}, ${config.group})`);
-      this.onStateChange?.(this.state);
-      return true;
-    } catch (error) {
-      console.warn("[Transport] window.multicast failed:", error);
-      return false;
-    }
-  }
-  /**
-   * Connect via AMT: a configured relay goes through the AMT proxy; with no
-   * relay, the window.multicast gateway discovers one per RFC 8777 (DRIAD).
-   */
-  async connectAmt(config, generation) {
-    try {
-      if (config.amtRelay)
-        return await this.connectAmtProxy(config, config.amtRelay, generation);
-      if (config.driadEnabled === false || !config.source || config.mode === "native") {
-        console.warn("[Transport] No AMT relay available (DRIAD requires source address for SSM)");
-        return false;
-      }
-      console.log(`[Transport] Asking the gateway for a DRIAD relay for source ${config.source}...`);
-      return await this.connectWindowMulticast({ ...config, amtDiscovery: "driad" }, generation, "amt");
-    } catch (error) {
-      console.warn("[Transport] AMT connection failed:", error);
-      return false;
-    }
-  }
-  /**
-   * Connect via WebSocket-based AMT proxy (browser fallback)
-   */
-  async connectAmtProxy(config, amtRelay, generation) {
-    try {
-      const relayHost = amtRelay.includes(":") && !amtRelay.startsWith("[") ? `[${amtRelay}]` : amtRelay;
-      const wsUrl = new URL(`wss://${relayHost}/amt-proxy`);
-      wsUrl.searchParams.set("group", config.group);
-      wsUrl.searchParams.set("source", config.source || "");
-      wsUrl.searchParams.set("port", String(config.port));
-      const ws = new WebSocket(wsUrl);
-      return new Promise((resolve, reject) => {
-        ws.binaryType = "arraybuffer";
-        const timeout = setTimeout(() => {
-          ws.close();
-          reject(new Error("AMT proxy connection timeout"));
-        }, 1e4);
-        ws.onopen = () => {
-          clearTimeout(timeout);
-          if (generation !== this.connectionGeneration) {
-            ws.close();
-            resolve(false);
-            return;
-          }
-          console.log(`[Transport] Connected to AMT proxy: ${amtRelay}`);
-          this.subscription = {
-            id: `amt-proxy-${Date.now()}`,
-            config,
-            close: () => ws.close()
-          };
-          this.state = {
-            mode: "amt",
-            connected: true,
-            group: config.group,
-            source: config.source,
-            amtRelay,
-            quality: this.requireAbr().getCurrentQuality(),
-            packetsReceived: 0,
-            bytesReceived: 0,
-            lastPacketTime: 0
-          };
-          this.onStateChange?.(this.state);
-          resolve(true);
-        };
-        ws.onmessage = (event) => {
-          if (generation === this.connectionGeneration && event.data instanceof ArrayBuffer) {
-            this.handlePacket(event.data);
-          }
-        };
-        ws.onerror = (error) => {
-          clearTimeout(timeout);
-          if (generation !== this.connectionGeneration) {
-            resolve(false);
-            return;
-          }
-          console.error("[Transport] AMT proxy error:", error);
-          reject(error);
-        };
-        ws.onclose = () => {
-          clearTimeout(timeout);
-          if (generation !== this.connectionGeneration) {
-            resolve(false);
-            return;
-          }
-          this.state.connected = false;
-          this.onStateChange?.(this.state);
-          resolve(false);
-        };
-      });
-    } catch (error) {
-      console.warn("[Transport] AMT proxy failed:", error);
-      return false;
-    }
-  }
-  /**
-   * Handle received packet
-   */
-  handlePacket(data) {
-    this.state.packetsReceived++;
-    this.state.bytesReceived += data.byteLength;
-    this.state.lastPacketTime = Date.now();
-    this.abr?.recordSample(data.byteLength, 0);
-    this.onPacket?.(data);
-  }
-  /**
-   * Get current transport state
-   */
-  getState() {
-    return { ...this.state };
-  }
-  /**
-   * The rung of the live connection's `abrLadder` ABR is on; `null` when
-   * there is no ladder (before `connect(config)` succeeds, after
-   * `disconnect()`, or after a reconnect that was torn down and bailed).
-   */
-  getQuality() {
-    return this.abr?.getCurrentQuality() ?? null;
-  }
-  /**
-   * Force the rung named `name` of the live connection's `abrLadder`.
-   * Throws `Error` when there is no ladder (see `getQuality()`), and
-   * `RangeError` when the ladder has no rung of that name; it never falls
-   * back to another rung.
-   */
-  setQuality(name) {
-    this.requireAbr().setQuality(name);
-  }
-  /** The controller `connect()` built; before it there is no ladder to adapt over. */
-  requireAbr() {
-    if (!this.abr)
-      throw new Error("[Transport] ABR has no ladder before connect(config)");
-    return this.abr;
-  }
-  /** Configures multicast-only ABR while leaving the caller's MoQ ABR untouched. */
-  configureMulticastTiers(options, onCommand) {
-    this.dispatchOrchestratorCommand(this.multicastOrchestrator?.cancel());
-    this.multicastOrchestrator = new MulticastOrchestrator(options);
-    this.onOrchestratorCommand = onCommand;
-    return this.multicastOrchestrator.start();
-  }
-  recordMulticastGoodput(bitrate) {
-    return this.dispatchOrchestratorCommand(this.multicastOrchestrator?.onGoodput({ bitrate }));
-  }
-  recordMulticastHeadroom(healthy) {
-    return this.dispatchOrchestratorCommand(this.multicastOrchestrator?.onHeadroom({ healthy }));
-  }
-  recordMulticastTierPacket(packet) {
-    return this.dispatchOrchestratorCommand(this.multicastOrchestrator?.onTierPacket(packet));
-  }
-  pollMulticastTierSwitch() {
-    return this.dispatchOrchestratorCommand(this.multicastOrchestrator?.poll());
-  }
-  /** Abandon the in-flight tier join, e.g. because the host could not join the target. */
-  cancelMulticastTierJoin() {
-    return this.dispatchOrchestratorCommand(this.multicastOrchestrator?.cancel());
-  }
-  /**
-   * Set packet callback
-   */
-  setPacketCallback(callback) {
-    this.onPacket = callback;
-  }
-  /**
-   * Set error callback
-   */
-  setErrorCallback(callback) {
-    this.onError = callback;
-  }
-  /**
-   * Set state change callback
-   */
-  setStateCallback(callback) {
-    this.onStateChange = callback;
-  }
-  /**
-   * Disconnect
-   */
-  disconnect() {
-    this.connectionGeneration++;
-    this.subscription?.close();
-    this.subscription = null;
-    this.abr = null;
-    this.dispatchOrchestratorCommand(this.multicastOrchestrator?.cancel());
-    this.multicastOrchestrator = null;
-    this.onOrchestratorCommand = void 0;
-    this.state = {
-      mode: "disconnected",
-      connected: false,
-      packetsReceived: 0,
-      bytesReceived: 0,
-      lastPacketTime: 0
-    };
-    this.onStateChange?.(this.state);
-  }
-  dispatchOrchestratorCommand(command) {
-    if (command)
-      this.onOrchestratorCommand?.(command);
-    return command;
-  }
-};
-var transportManager = new TransportManager();
-
-// node_modules/@blockcast/mmt-transport/dist/multicast-receiver-gateway.js
-var USER_AGENT_VERIFIED = /* @__PURE__ */ Symbol.for("@blockcast/mmt-transport/user-agent-verified/v1");
-
-// node_modules/@blockcast/mmt-transport/dist/moqt-priority.js
-var MAX_MOQT_PRIORITY = 255;
-function moqtPriority(value, field) {
-  if (!Number.isInteger(value) || value < 0 || value > MAX_MOQT_PRIORITY) {
-    throw new RangeError(`${field} must be an integer in [0, ${MAX_MOQT_PRIORITY}], got ${value}`);
-  }
-  return value;
-}
-function moqtSubscriberPriority(value) {
-  return moqtPriority(value, "MOQT subscriber priority");
-}
-function moqtPublisherPriority(value) {
-  return moqtPriority(value, "MOQT publisher priority");
-}
-var MOQT_SUBSCRIBER_PRIORITY = Object.freeze({
-  catalog: moqtSubscriberPriority(0),
-  /**
-   * @deprecated A repair FETCH's SUBSCRIBER_PRIORITY is derived per request
-   * from the catalog source and repair priorities (draft-ramadan-moq-fec
-   * §11.4.5), not a player constant. Use the `subscriberPriority` that
-   * `@blockcast/mmt-container`'s `wireRepairFetch` puts on each
-   * `RepairFetchRequest` (`repairFetchSubscriberPriority`).
-   */
-  deadlineRepair: moqtSubscriberPriority(0),
-  audio: moqtSubscriberPriority(1),
-  video: moqtSubscriberPriority(2),
-  /**
-   * @deprecated See `deadlineRepair`: use the request's catalog-derived
-   * `RepairFetchRequest.subscriberPriority` (draft-ramadan-moq-fec §11.4.5).
-   */
-  backgroundRepair: moqtSubscriberPriority(3)
-});
-var MOQT_PUBLISHER_PRIORITY = Object.freeze({
-  catalog: moqtPublisherPriority(32),
-  source: moqtPublisherPriority(128),
-  repair: moqtPublisherPriority(240)
-});
-
-// node_modules/@blockcast/mmt-transport/dist/amt-gateway.js
-var AMTGatewayManager = class {
-  subscriptions = /* @__PURE__ */ new Map();
-  messageHandler;
-  pendingPackets = /* @__PURE__ */ new Map();
-  constructor() {
-    this.messageHandler = (event) => {
-      const data = event.data;
-      console.log(`[AMT] SW message received:`, data.type);
-      if (data.type === "UDP_PACKET") {
-        this.handlePacket(data);
-      } else if (data.type === "SOCKET_ERROR") {
-        this.handleSocketError(data);
-      } else if (data.type === "DEBUG_LOG") {
-        console.log(`[AMT SW Debug] ${data.message}`);
-      }
-    };
-    if (typeof navigator !== "undefined" && navigator.serviceWorker) {
-      navigator.serviceWorker.addEventListener("message", this.messageHandler);
-      console.log("[AMT] Registered service worker message handler");
-    } else {
-      console.warn("[AMT] Service worker not available");
-    }
-  }
-  /**
-   * Subscribe via AMT tunnel
-   */
-  async subscribe(config) {
-    const { key } = config;
-    if (config.protected) {
-      throw new Error("AMTGatewayManager refuses a protected join: it reports no per-datagram sender (multicast-02 7.2.7)");
-    }
-    const keyStr = this.getKeyString(key);
-    if (this.subscriptions.has(keyStr)) {
-      console.log(`[AMT] Reusing existing subscription to ${keyStr}`);
-      return keyStr;
-    }
-    try {
-      const relayAddress = config.relayAddress;
-      const relayPort = config.relayPort || DEFAULT_AMT_RELAY_PORT;
-      if (!relayAddress) {
-        throw new Error(`AMT relay address required: this manager does no relay discovery. For RFC 8777 DRIAD discovery, join through window.multicast with amtDiscovery: "driad".`);
-      }
-      console.log(`[AMT] Using configured relay ${relayAddress}:${relayPort}`);
-      const subscriptionId = keyStr;
-      this.pendingPackets.set(subscriptionId, []);
-      const subscription = {
-        key,
-        subscriptionId,
-        config,
-        handshakeComplete: false,
-        relay: {
-          address: relayAddress,
-          port: relayPort,
-          discoveryMethod: "manual",
-          discoveredAt: Date.now()
-        }
-      };
-      this.subscriptions.set(keyStr, subscription);
-      console.log(`[AMT] Subscription created for ${keyStr} via ${relayAddress}:${relayPort}`);
-      return keyStr;
-    } catch (error) {
-      const subscription = this.subscriptions.get(keyStr);
-      if (subscription) {
-        this.subscriptions.delete(keyStr);
-        this.pendingPackets.delete(subscription.subscriptionId);
-      }
-      throw new Error(`Failed to subscribe via AMT: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  /**
-   * Unsubscribe from AMT tunnel
-   */
-  async unsubscribe(handle) {
-    const subscription = this.subscriptions.get(handle);
-    if (!subscription) {
-      throw new Error(`Subscription ${handle} not found`);
-    }
-    try {
-      if (subscription.keepAliveTimer) {
-        clearInterval(subscription.keepAliveTimer);
-      }
-      console.log(`[AMT] Unsubscribed from ${handle}`);
-    } catch (error) {
-      console.error("[AMT] Error during unsubscribe:", error);
-    } finally {
-      this.subscriptions.delete(handle);
-      this.pendingPackets.delete(subscription.subscriptionId);
-    }
-  }
-  /**
-   * Get list of active subscriptions
-   */
-  getSubscriptions() {
-    return Array.from(this.subscriptions.keys());
-  }
-  /**
-   * Handle packet from service worker
-   */
-  handlePacket(message) {
-    const { subscriptionId, data } = message;
-    if (!subscriptionId)
-      return;
-    const subscription = this.subscriptions.get(subscriptionId);
-    if (!subscription) {
-      console.warn(`[AMT] Received packet for unknown subscription: ${subscriptionId}`);
-      return;
-    }
-    if (!subscription.handshakeComplete) {
-      const queue = this.pendingPackets.get(subscriptionId);
-      const packetData2 = data;
-      if (queue) {
-        queue.push({
-          data: packetData2.data,
-          remoteAddress: packetData2.remoteAddress,
-          remotePort: packetData2.remotePort
-        });
-      }
-      return;
-    }
-    const packetData = data;
-    const metadata = {
-      sourceAddress: subscription.relay?.address || "unknown",
-      sourcePort: subscription.relay?.port || 0,
-      transport: "tunnel",
-      timestamp: performance.now()
-    };
-    subscription.config.onPacket(packetData.data, metadata);
-  }
-  /**
-   * Handle socket error from service worker
-   */
-  handleSocketError(message) {
-    const { subscriptionId, error } = message;
-    if (!subscriptionId)
-      return;
-    const subscription = this.subscriptions.get(subscriptionId);
-    if (!subscription) {
-      console.warn(`[AMT] Received error for unknown subscription: ${subscriptionId}`);
-      return;
-    }
-    subscription.config.onError(new Error(error || "Unknown error"));
-  }
-  /**
-   * Cleanup on destroy
-   */
-  destroy() {
-    if (this.messageHandler && typeof navigator !== "undefined" && navigator.serviceWorker) {
-      navigator.serviceWorker.removeEventListener("message", this.messageHandler);
-    }
-    const handles = Array.from(this.subscriptions.keys());
-    for (const handle of handles) {
-      this.unsubscribe(handle).catch((err) => {
-        console.error(`[AMT] Error unsubscribing ${handle}:`, err);
-      });
-    }
-  }
-  /**
-   * Get key string for HashMap
-   */
-  getKeyString(key) {
-    const source = key.source ? `@${key.source}` : "";
-    return `${key.group}:${key.port}${source}`;
-  }
-};
-var amtGatewayManager = new AMTGatewayManager();
-
 // src/mfu-reassembler.ts
 function fragmentProvenance(fragment) {
   if (fragment.deliveryProvenance !== void 0) return fragment.deliveryProvenance;
@@ -9589,7 +8183,7 @@ function decideGap(input) {
 
 // src/duplicate-ledger.ts
 var COUNT_BOUNDED_GENERATION = 2e3;
-function serial32Precedes3(a, b) {
+function serial32Precedes2(a, b) {
   const distance = b - a >>> 0;
   return distance !== 0 && distance < 2147483648;
 }
@@ -9765,12 +8359,12 @@ var StreamDuplicateLedgers = class {
   predatesHorizon(packetSequenceNumber, ssId) {
     if (this.#retentionMs === null) return false;
     const seqFloor = this.sourceSeqs.horizonFloor;
-    if (seqFloor !== void 0 && serial32Precedes3(packetSequenceNumber, seqFloor) && !this.sourceSeqs.has(packetSequenceNumber)) {
+    if (seqFloor !== void 0 && serial32Precedes2(packetSequenceNumber, seqFloor) && !this.sourceSeqs.has(packetSequenceNumber)) {
       return true;
     }
     if (ssId === void 0) return false;
     const ssIdFloor = this.parsedSymbols.horizonFloor;
-    return ssIdFloor !== void 0 && serial32Precedes3(ssId, ssIdFloor) && !this.parsedSymbols.has(ssId);
+    return ssIdFloor !== void 0 && serial32Precedes2(ssId, ssIdFloor) && !this.parsedSymbols.has(ssId);
   }
   /** Whether the stream keeps ledgers, for its FEC horizon or by count. */
   get retaining() {
@@ -10977,11 +9571,10 @@ var MmtpRouter = class {
     if (!entry) return;
     entry.receiver.release();
     entry.protected = false;
-    entry.userAgent = false;
     this.#assistBlocks.clear();
     this.#assistFailures.clear();
   }
-  /** Packets of a track a protected flow lists, dropped unread: a MoQ copy (duplicate, overflow, or listed by more than one flow) or a multicast source datagram that names no flow, of a track a user-agent-admitted flow lists. */
+  /** MoQ packets of a track a protected flow lists, dropped on its unicast path: duplicate, overflow, or listed by more than one flow. */
   get unadmittedListedDropCount() {
     return this.#unadmittedListedDrops;
   }
@@ -11022,13 +9615,6 @@ var MmtpRouter = class {
     }
     return false;
   }
-  /** Whether a protected flow the user agent admitted lists `packetId`. */
-  #userAgentGoverns(packetId) {
-    for (const entry of this.#provenance.values()) {
-      if (entry.protected && entry.userAgent && ingressHasPacketId(entry.ingress, packetId)) return true;
-    }
-    return false;
-  }
   /**
    * A MoQ repair symbol no protected flow lists, owned by a source track one
    * does: its FEC instance is governed (7.2.7 step 2) and takes only admitted
@@ -11119,7 +9705,7 @@ var MmtpRouter = class {
       fec.cancelBlockTimeout(blockStart, ownerPacketId, catalogTrackName);
       fec.countRecovery(ownerPacketId, blockStart, catalogTrackName);
       fec.markBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
-    }, true)) {
+    })) {
       this.#unlistedAssistedRecoveries++;
       this.#assistBlocks.delete(key);
       return;
@@ -12275,12 +10861,6 @@ var MmtpRouter = class {
         debugRouter(`[MmtpRouter] Dropping multicast packet pid=${info.packetId}: flow ${ingress.flow} has no receiver`);
         return;
       }
-      if (ingress.admittedBy === USER_AGENT_VERIFIED) {
-        this.#noteFlowAdmitted(ingress.flow);
-        protectedFlow.userAgent = true;
-        this.#processMMTP(packet, source, true, ingress, overlapCopy);
-        return;
-      }
       const { verdict } = protectedFlow.receiver.onDatagram(packet, "multicast");
       if (verdict === "admitted") {
         this.#noteFlowAdmitted(ingress.flow);
@@ -12298,11 +10878,6 @@ var MmtpRouter = class {
         return;
       }
     }
-    const flowless = source === "multicast" && !manifestAdmitted && ingress?.flow === void 0;
-    if (flowless && !info.isRepair && this.#userAgentGoverns(info.packetId)) {
-      this.#unadmittedListedDrops++;
-      return;
-    }
     if (info.isRepair) {
       const overlay = this.#overlayRepairTarget(info.packetId, catalogTrackNameForPacket(ingress, info.packetId));
       if (overlay !== void 0) {
@@ -12320,7 +10895,7 @@ var MmtpRouter = class {
       );
       if (!repair) return;
       if (ownerPacketId != null && this.#fecManager) {
-        if ((flowless && this.#userAgentGoverns(ownerPacketId) || source === "moq" && !manifestAdmitted) && this.#setAsideUnlistedRepair(ownerPacketId, catalogTrackNameForPacket(ingress, ownerPacketId), repair)) return;
+        if (source === "moq" && !manifestAdmitted && this.#setAsideUnlistedRepair(ownerPacketId, catalogTrackNameForPacket(ingress, ownerPacketId), repair)) return;
         this.#repairPidCounts[info.packetId] = (this.#repairPidCounts[info.packetId] || 0) + 1;
         const count = this.#repairPidCounts[info.packetId];
         if (count <= 2 || count % 500 === 0) {
@@ -12899,7 +11474,7 @@ var MmtpRouter = class {
   }
   // ── Private: FEC recovery routing ───────────────────────────────
   /** Route WASM-recovered block through appropriate path based on container kind. */
-  #routeRecoveredBlock(blockId, recovered, ownerPacketId, catalogTrackName, complete, assisted = false) {
+  #routeRecoveredBlock(blockId, recovered, ownerPacketId, catalogTrackName, complete) {
     const packetSymbolSize = this.#symbolSizeForPacket(ownerPacketId);
     if (ownerPacketId === void 0) {
       throw new Error("[MmtpRouter] a recovered FEC block needs its owner packetId to read its fec.blockProfile");
@@ -12916,7 +11491,7 @@ var MmtpRouter = class {
       ownerPacketId,
       blockProfile
     });
-    return this.#routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, complete, assisted);
+    return this.#routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, complete);
   }
   /**
    * A recovered source packet of a protected flow is admitted on its own
@@ -12928,24 +11503,9 @@ var MmtpRouter = class {
    * recovered packets is refused is unrecovered (7.2.7): its caller leaves it
    * open, so it reaches its FEC deadline and fails by class. Always true
    * outside a protected flow.
-   *
-   * On a flow the user agent admitted, the live decoder's recoveries are kept
-   * without a record: while the flow is protected that decoder takes only
-   * symbols the user agent or a record verified (a flow-less multicast
-   * datagram of a listed track is dropped or set aside in #processMMTP), so
-   * what it recovers is as verified as they are. An `assisted` (scratch-decoder) recovery mixes in
-   * unlisted MoQ repair and still needs a record.
-   * ponytail: per-flow flag; per-block provenance only if a protected flow
-   * ever mixes verified and unverified live inputs.
-   * ponytail: a worker frame computed before the protection reset can still
-   * arrive after it (frames carry no epoch); its inputs are MoQ copies read
-   * and played before protection, so it admits nothing new. Drop pre-reset
-   * frames by epoch only if pre-protection input ever matters.
    */
-  #routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, complete, assisted = false) {
-    const entry = ownerPacketId == null ? void 0 : this.#provenanceFor(ownerPacketId, catalogTrackName);
-    const receiver = entry === void 0 || entry === "ambiguous" ? entry : entry.receiver;
-    const userAgent = !assisted && entry !== void 0 && entry !== "ambiguous" && entry.protected === true && entry.userAgent === true;
+  #routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, complete) {
+    const receiver = ownerPacketId == null ? void 0 : this.#provenanceFor(ownerPacketId, catalogTrackName);
     let recovered = true;
     if (receiver) {
       const parsed = this.#stream(ownerPacketId, catalogTrackName).duplicates.parsedSymbols;
@@ -12957,8 +11517,6 @@ var MmtpRouter = class {
           let admitted = false;
           if (receiver === "ambiguous") {
             this.#ambiguousRecoveredDrops++;
-          } else if (userAgent) {
-            admitted = true;
           } else {
             const wire = new Uint8Array(sym.rawSymbol.byteLength + 4);
             wire.set(sym.rawSymbol);
@@ -12986,12 +11544,12 @@ var MmtpRouter = class {
       catalogTrackName === void 0 || !byName ? byName?.values() : byName.has(catalogTrackName) ? [byName.get(catalogTrackName)] : []
     );
     if (flows.size > 1) return "ambiguous";
-    for (const bound of flows) return this.#provenance.get(bound) ?? "ambiguous";
+    for (const bound of flows) return this.#provenance.get(bound)?.receiver ?? "ambiguous";
     let match;
-    for (const entry of this.#provenance.values()) {
-      if (entry.ingress.tracks.some((t) => t.packetId === packetId && (catalogTrackName === void 0 || t.name === catalogTrackName))) {
+    for (const { receiver, ingress } of this.#provenance.values()) {
+      if (ingress.tracks.some((t) => t.packetId === packetId && (catalogTrackName === void 0 || t.name === catalogTrackName))) {
         if (match) return "ambiguous";
-        match = entry;
+        match = receiver;
       }
     }
     return match;