@blockcast/mmt-container 0.1.0-main.149f78a4adae

package/dist/media-router.js

@@ -0,0 +1,802 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+
+// src/align.ts
+function groupIdForTicks(ticks, groupDurationTicks) {
+  if (!Number.isInteger(ticks)) {
+    throw new Error(
+      `[align] groupIdForTicks: ticks must be an integer, got ${ticks}`
+    );
+  }
+  if (!Number.isInteger(groupDurationTicks) || groupDurationTicks <= 0) {
+    throw new Error(
+      `[align] groupIdForTicks: groupDurationTicks must be a positive integer, got ${groupDurationTicks}`
+    );
+  }
+  if (ticks < 0) return 0;
+  return Math.floor(ticks / groupDurationTicks);
+}
+function driftCheck(expected, actual) {
+  if (!Number.isInteger(expected) || !Number.isInteger(actual)) {
+    throw new Error(
+      `[align] driftCheck: both arguments must be integer groupIds, got expected=${expected} actual=${actual}`
+    );
+  }
+  const deltaGroups = actual - expected;
+  if (deltaGroups === 0) return { kind: "aligned", deltaGroups: 0 };
+  return { kind: "drifted", deltaGroups };
+}
+
+// src/track-session.ts
+import { deriveFecInterleaveDepth } from "@blockcast/mmt-fec";
+function computeFecDeliveryWindowMs(config) {
+  const fecInterleaveMs = config.interleaveDepthMs;
+  const fecK = config.sourceSymbols;
+  if (fecInterleaveMs <= 0) {
+    throw new Error(
+      `[TrackSession] fecInterleaveMs=${fecInterleaveMs}. Derive a positive FEC interleave window from the stream catalog.`
+    );
+  }
+  if (fecK <= 0) {
+    throw new Error(
+      `[TrackSession] fecK=${fecK}. Derive a positive FEC source-symbol count from the stream catalog.`
+    );
+  }
+  const spansMs = [fecInterleaveMs];
+  if (config.mediaUnitsPerSecond && config.mediaUnitsPerSecond > 0) {
+    const mediaUnitMs = 1e3 / config.mediaUnitsPerSecond;
+    const interleaveUnits = deriveFecInterleaveDepth(fecInterleaveMs, mediaUnitMs);
+    const deliverySymbols = fecK + Math.max(0, config.repairSymbols ?? 0);
+    spansMs.push(deliverySymbols * interleaveUnits * mediaUnitMs);
+  }
+  if (config.symbolSize && config.symbolSize > 0 && config.bandwidthBps && config.bandwidthBps > 0) {
+    const repairSymbols = Math.max(0, config.repairSymbols ?? 0);
+    spansMs.push(
+      (fecK + repairSymbols) * config.symbolSize * 8 * 1e3 / config.bandwidthBps
+    );
+  }
+  const coreMs = Math.max(...spansMs);
+  const marginMs = config.jitterBufferMs !== void 0 && config.jitterBufferMs >= 0 ? config.jitterBufferMs : fecInterleaveMs;
+  return Math.ceil(coreMs) + Math.ceil(marginMs);
+}
+
+// src/media-router.ts
+var GROUP_ALIGN_WARN_BUDGET = {
+  "invalid-tick-inputs": 1,
+  "ticks-formula-threw": 1,
+  "invalid-seconds-inputs": 1,
+  "sub-nanosecond-duration": 1,
+  "media-time-overflow": 1,
+  "seconds-formula-threw": 1,
+  "callback-threw": 3
+};
+var TrackSourceConflictError = class extends Error {
+  constructor(trackName) {
+    super(`Track source already assigned for '${trackName}'; call clearTrackSource first`);
+    this.trackName = trackName;
+    this.name = "TrackSourceConflictError";
+  }
+};
+var DEFAULT_CROSSFADE_FRAMES = 10;
+var DEFAULT_MAX_OVERLAY_BUFFER = 128;
+var _active, _multicastVideoKeyed, _multicastAudioReceived, _moqVideoKeyframeEmitted, _requireAudio, _suppressed, _audioFallbackTimer, _audioFallbackMs, _crossfadeFrames, _maxOverlayBuffer, _allowDeltaMulticastTakeoverAfterMoqKeyframe, _repairInFlight, _maxRepairInFlight, _onRepairRequest, _onVideoFrame, _onAudioFrame, _onOverlayFrame, _onSourceSwitch, _sourceSwitchReady, _sourceSwitchToken, _pendingMulticastToken, _pendingMulticastVideo, _pendingMulticastAudio, _trackSources, _trackTypes, _crossfadeCounters, _overlayBoundaryReached, _overlayBuffer, _deltaConfigured, _deltaActive, _deltaWindow, _deltaWindowSize, _deltaFailThresholdRatio, _deltaRecoverThresholdRatio, _deltaProbeIntervalMs, _lastProbeAt, _onDeltaFallbackCb, _onDeltaRecoverCb, _onGroupDrift, _groupAlignWarnCounts, _MediaRouter_instances, skipWithWarning_fn, resolveTicks_fn, resolveSeconds_fn, _moqAudioWarmed, tryActivateMulticast_fn, commitMulticastActivation_fn, rejectMulticastActivation_fn, emitForTrack_fn, handleOverlayFrame_fn;
+var MediaRouter = class {
+  constructor(options) {
+    __privateAdd(this, _MediaRouter_instances);
+    __privateAdd(this, _active, "moq");
+    __privateAdd(this, _multicastVideoKeyed, false);
+    __privateAdd(this, _multicastAudioReceived, false);
+    __privateAdd(this, _moqVideoKeyframeEmitted, false);
+    __privateAdd(this, _requireAudio);
+    __privateAdd(this, _suppressed, false);
+    // true after multicast confirmed — suppresses MoQ
+    __privateAdd(this, _audioFallbackTimer, null);
+    // Configurable constants (from catalog/FEC config, not magic numbers)
+    __privateAdd(this, _audioFallbackMs);
+    __privateAdd(this, _crossfadeFrames);
+    __privateAdd(this, _maxOverlayBuffer);
+    __privateAdd(this, _allowDeltaMulticastTakeoverAfterMoqKeyframe);
+    // ── Keyframe repair state ────────────────────────────────────────
+    /** Groups currently being repaired — idempotent guard per Pitfall 2 (T-13-01 mitigation) */
+    __privateAdd(this, _repairInFlight, /* @__PURE__ */ new Set());
+    /** Max concurrent repairs — prevents relay SUBSCRIBE flood (T-13-01 mitigation) */
+    __privateAdd(this, _maxRepairInFlight);
+    /** Callback to request MoQ subscribe for a specific group (wired by player) */
+    __privateAdd(this, _onRepairRequest, null);
+    __privateAdd(this, _onVideoFrame, null);
+    __privateAdd(this, _onAudioFrame, null);
+    __privateAdd(this, _onOverlayFrame, null);
+    __privateAdd(this, _onSourceSwitch, null);
+    __privateAdd(this, _sourceSwitchReady, null);
+    __privateAdd(this, _sourceSwitchToken, 0);
+    __privateAdd(this, _pendingMulticastToken, null);
+    __privateAdd(this, _pendingMulticastVideo, null);
+    __privateAdd(this, _pendingMulticastAudio, null);
+    // Per-track source state
+    __privateAdd(this, _trackSources, /* @__PURE__ */ new Map());
+    // Track type registry: trackName → { type, source }.
+    // Init data / inline signaling is authoritative until catalog updates.
+    // Priority: 'init' > 'catalog' > 'name' (backward compat fallback).
+    __privateAdd(this, _trackTypes, /* @__PURE__ */ new Map());
+    // Crossfade state: maps trackName → remaining binary-path frames allowed during window
+    __privateAdd(this, _crossfadeCounters, /* @__PURE__ */ new Map());
+    // Overlay alignment state
+    __privateAdd(this, _overlayBoundaryReached, false);
+    __privateAdd(this, _overlayBuffer, []);
+    // ── Phase 14: deltaActive state machine (D-11..D-14) ─────────────
+    // No timers — state transitions driven entirely by notifyDeltaBlock() callbacks.
+    // All thresholds derived from catalog fields or throw at configureDelta() time.
+    __privateAdd(this, _deltaConfigured, false);
+    __privateAdd(this, _deltaActive, true);
+    __privateAdd(this, _deltaWindow, []);
+    // ring buffer: true = block failed
+    __privateAdd(this, _deltaWindowSize, 0);
+    __privateAdd(this, _deltaFailThresholdRatio, 0);
+    // P/K
+    __privateAdd(this, _deltaRecoverThresholdRatio, 0);
+    // (P/K)/2 — hysteresis (D-13)
+    __privateAdd(this, _deltaProbeIntervalMs, 0);
+    __privateAdd(this, _lastProbeAt, 0);
+    __privateAdd(this, _onDeltaFallbackCb, null);
+    __privateAdd(this, _onDeltaRecoverCb, null);
+    // ── Group-alignment observer (align.ts formula) ──────────────────
+    // Observation only — does NOT alter routing. Producers are wired in
+    // follow-up PRs; when they land they will call
+    // CmcdProducer.incrementSwitchMiscount() + emitSwitchDrift() from the
+    // onGroupDrift callback so divergence between packet-stamped groupIds
+    // and the shared formula surfaces on `x-bc-switch-drift-us` /
+    // `x-bc-switch-miscount`. Canonical Go impl: Blockcast/multicast
+    // cmd/caddy/sender/group_align.go (commit 104eeff). Canonical Rust impl:
+    // moqtail/moqtail apps/relay/src/server/abr.rs (branch
+    // experimental/server-side-abr, commit 39accbf).
+    __privateAdd(this, _onGroupDrift, null);
+    __privateAdd(this, _groupAlignWarnCounts, /* @__PURE__ */ new Map());
+    /**
+     * MoQ unicast audio warmup gate. When audio is required, multicast takeover
+     * waits until the MoQ unicast audio decoder has emitted at least one frame
+     * (so downstream samples-before-takeover counters observe nonzero) or until
+     * the existing audio-fallback timer forces the flag true.
+     */
+    __privateAdd(this, _moqAudioWarmed, false);
+    __privateSet(this, _requireAudio, options?.requireAudio ?? true);
+    __privateSet(this, _audioFallbackMs, options?.audioFallbackMs ?? 0);
+    __privateSet(this, _crossfadeFrames, options?.crossfadeFrames ?? DEFAULT_CROSSFADE_FRAMES);
+    __privateSet(this, _maxOverlayBuffer, options?.maxOverlayBuffer ?? DEFAULT_MAX_OVERLAY_BUFFER);
+    __privateSet(this, _maxRepairInFlight, options?.maxRepairInFlight ?? 2);
+    __privateSet(this, _allowDeltaMulticastTakeoverAfterMoqKeyframe, options?.allowDeltaMulticastTakeoverAfterMoqKeyframe ?? false);
+  }
+  onVideoFrame(cb) {
+    __privateSet(this, _onVideoFrame, cb);
+  }
+  onAudioFrame(cb) {
+    __privateSet(this, _onAudioFrame, cb);
+  }
+  onOverlayFrame(cb) {
+    __privateSet(this, _onOverlayFrame, cb);
+  }
+  onSourceSwitch(cb) {
+    __privateSet(this, _onSourceSwitch, cb);
+  }
+  onGroupDrift(cb) {
+    __privateSet(this, _onGroupDrift, cb);
+  }
+  notifyGroupBoundary(trackName, packetGroupId, timingOrMediaTimeSec, groupDurationSec) {
+    if (!__privateGet(this, _onGroupDrift)) return;
+    const resolved = typeof timingOrMediaTimeSec === "object" && timingOrMediaTimeSec !== null ? __privateMethod(this, _MediaRouter_instances, resolveTicks_fn).call(this, trackName, timingOrMediaTimeSec) : __privateMethod(this, _MediaRouter_instances, resolveSeconds_fn).call(this, trackName, timingOrMediaTimeSec, groupDurationSec);
+    if (!resolved) return;
+    if (resolved.mediaTimeSec === 0 && packetGroupId !== 0) return;
+    const expected = resolved.expected;
+    const result = driftCheck(expected, packetGroupId);
+    if (result.kind === "aligned") return;
+    try {
+      __privateGet(this, _onGroupDrift).call(this, {
+        trackName,
+        expectedGroupId: expected,
+        actualGroupId: packetGroupId,
+        deltaGroups: result.deltaGroups,
+        mediaTimeSec: resolved.mediaTimeSec,
+        groupDurationSec: resolved.groupDurationSec,
+        ...resolved.timing ? { timing: resolved.timing } : {}
+      });
+    } catch (err) {
+      __privateMethod(this, _MediaRouter_instances, skipWithWarning_fn).call(this, "callback-threw", `[MediaRouter] onGroupDrift callback threw (track=${trackName} expected=${expected} actual=${packetGroupId}); continuing: ${err?.message ?? err}`);
+    }
+  }
+  get activeSource() {
+    return __privateGet(this, _active);
+  }
+  // ── Keyframe repair API ──────────────────────────────────────────
+  /** Register callback for keyframe repair requests. Player wires this to issue MoQ SUBSCRIBE. */
+  onRepairRequest(cb) {
+    __privateSet(this, _onRepairRequest, cb);
+  }
+  /**
+   * Request repair for a lost keyframe group. Only fires when activeSource is 'multicast'.
+   * Idempotent per groupId — duplicate calls for the same group are suppressed.
+   * @param expectedGroupId - The group ID expected but not received
+   * @param trackName - Track name for the SUBSCRIBE (e.g. 'video'). Default: 'video'.
+   */
+  repairLostGroup(expectedGroupId, trackName = "video") {
+    var _a;
+    if (__privateGet(this, _active) !== "multicast") return;
+    if (__privateGet(this, _repairInFlight).has(expectedGroupId)) return;
+    if (__privateGet(this, _repairInFlight).size >= __privateGet(this, _maxRepairInFlight)) {
+      console.warn(
+        `[MediaRouter] max repair in flight (${__privateGet(this, _maxRepairInFlight)}), dropping repair for group ${expectedGroupId}`
+      );
+      return;
+    }
+    __privateGet(this, _repairInFlight).add(expectedGroupId);
+    (_a = __privateGet(this, _onRepairRequest)) == null ? void 0 : _a.call(this, expectedGroupId, trackName);
+  }
+  /**
+   * Feed a recovered keyframe frame from the repair path.
+   * Bypasses source arbitration entirely — goes directly to decoder callbacks.
+   * Does NOT change activeSource. Does NOT trigger failbackToMoq.
+   */
+  feedRepair(data, meta, kind) {
+    var _a, _b;
+    if (__privateGet(this, _active) !== "multicast") return;
+    const routedMeta = { ...meta, source: "repair", recovered: true };
+    if (kind === "video") (_a = __privateGet(this, _onVideoFrame)) == null ? void 0 : _a.call(this, data, routedMeta);
+    else (_b = __privateGet(this, _onAudioFrame)) == null ? void 0 : _b.call(this, data, routedMeta);
+  }
+  /**
+   * Clear repair-in-flight state for a group (called after repair completes or times out).
+   */
+  clearRepairInFlight(groupId) {
+    __privateGet(this, _repairInFlight).delete(groupId);
+  }
+  // ── Phase 14: deltaActive state machine API ──────────────────────
+  /**
+   * Configure the delta-track fallback state machine from catalog parameters.
+   *
+   * D-11: Thresholds derive from fec.sourceSymbols, fec.repairSymbols, framerate.
+   * D-13: Probe interval derives from deltaProbeIntervalMs or interleaveDepthMs*2.
+   * CLAUDE.md: error on bad init — throws if required inputs are absent.
+   *
+   * Calling again resets deltaActive=true and clears the window buffer (stream restart).
+   */
+  configureDelta(cfg) {
+    if (typeof cfg.framerate !== "number" || !Number.isFinite(cfg.framerate) || cfg.framerate <= 0) {
+      throw new Error("[MediaRouter] configureDelta: framerate required and must be > 0");
+    }
+    if (typeof cfg.sourceSymbols !== "number" || cfg.sourceSymbols <= 0) {
+      throw new Error("[MediaRouter] configureDelta: sourceSymbols (K_delta) required and must be > 0");
+    }
+    if (typeof cfg.repairSymbols !== "number" || cfg.repairSymbols <= 0) {
+      throw new Error("[MediaRouter] configureDelta: repairSymbols (P_delta) required and must be > 0");
+    }
+    if (cfg.deltaProbeIntervalMs === void 0 && cfg.interleaveDepthMs === void 0) {
+      throw new Error(
+        "[MediaRouter] configureDelta: either deltaProbeIntervalMs or interleaveDepthMs required for probe interval derivation"
+      );
+    }
+    __privateSet(this, _deltaWindowSize, cfg.deltaFailWindowBlocks ?? Math.ceil(cfg.framerate));
+    __privateSet(this, _deltaFailThresholdRatio, cfg.repairSymbols / cfg.sourceSymbols);
+    __privateSet(this, _deltaRecoverThresholdRatio, __privateGet(this, _deltaFailThresholdRatio) / 2);
+    __privateSet(this, _deltaProbeIntervalMs, cfg.deltaProbeIntervalMs ?? computeFecDeliveryWindowMs({
+      interleaveDepthMs: cfg.interleaveDepthMs,
+      sourceSymbols: cfg.sourceSymbols
+    }));
+    __privateSet(this, _deltaActive, true);
+    __privateSet(this, _deltaWindow, []);
+    __privateSet(this, _lastProbeAt, 0);
+    __privateSet(this, _deltaConfigured, true);
+  }
+  /**
+   * Notify the state machine of a completed FEC block for the delta track.
+   *
+   * @param failed - true if the block was unrecoverable (FEC failure)
+   * @param nowMs  - caller-injected monotonic ms (no internal timer — D-13, CLAUDE.md)
+   *
+   * If configureDelta() has not been called, this is a silent no-op (pre-catalog state).
+   */
+  notifyDeltaBlock(failed, nowMs) {
+    var _a, _b;
+    if (!__privateGet(this, _deltaConfigured)) return;
+    __privateGet(this, _deltaWindow).push(failed);
+    if (__privateGet(this, _deltaWindow).length > __privateGet(this, _deltaWindowSize)) {
+      __privateGet(this, _deltaWindow).shift();
+    }
+    if (__privateGet(this, _deltaWindow).length < __privateGet(this, _deltaWindowSize)) return;
+    const failedCount = __privateGet(this, _deltaWindow).filter((x) => x).length;
+    const ratio = failedCount / __privateGet(this, _deltaWindowSize);
+    if (__privateGet(this, _deltaActive)) {
+      if (ratio > __privateGet(this, _deltaFailThresholdRatio)) {
+        __privateSet(this, _deltaActive, false);
+        __privateSet(this, _lastProbeAt, nowMs);
+        (_a = __privateGet(this, _onDeltaFallbackCb)) == null ? void 0 : _a.call(this);
+      }
+    } else {
+      if (nowMs - __privateGet(this, _lastProbeAt) >= __privateGet(this, _deltaProbeIntervalMs) && ratio < __privateGet(this, _deltaRecoverThresholdRatio)) {
+        __privateSet(this, _deltaActive, true);
+        __privateSet(this, _lastProbeAt, nowMs);
+        (_b = __privateGet(this, _onDeltaRecoverCb)) == null ? void 0 : _b.call(this);
+      }
+    }
+  }
+  /** Register callback fired when delta track degrades past threshold (D-12). */
+  onDeltaFallback(cb) {
+    __privateSet(this, _onDeltaFallbackCb, cb);
+  }
+  /** Register callback fired when delta track recovers below recovery threshold (D-13). */
+  onDeltaRecover(cb) {
+    __privateSet(this, _onDeltaRecoverCb, cb);
+  }
+  /** Whether the delta track is currently considered healthy (true = active). */
+  get deltaActive() {
+    return __privateGet(this, _deltaActive);
+  }
+  // ── Test-visible accessors for threshold verification ────────────
+  // These expose internal derived values for test assertions (Tests 3,4,5,6,7).
+  // Prefixed with 'delta' to namespace clearly within the public API surface.
+  /** Derived window size — exposed for test assertions (Test 3, 4). */
+  get deltaWindowSize() {
+    return __privateGet(this, _deltaWindowSize);
+  }
+  /** Derived fail threshold ratio (P/K) — exposed for test assertions (Test 6). */
+  get deltaFailThresholdRatio() {
+    return __privateGet(this, _deltaFailThresholdRatio);
+  }
+  /** Derived recovery threshold ratio ((P/K)/2) — exposed for test assertions (Test 7). */
+  get deltaRecoverThresholdRatio() {
+    return __privateGet(this, _deltaRecoverThresholdRatio);
+  }
+  /** Derived probe interval ms — exposed for test assertions (Test 5a). */
+  get deltaProbeIntervalMs() {
+    return __privateGet(this, _deltaProbeIntervalMs);
+  }
+  /**
+   * Register a track name → type mapping from catalog.
+   * Catalog is the default authority. Init data / inline signaling
+   * takes precedence until the next catalog update.
+   */
+  registerTrackType(trackName, type) {
+    __privateGet(this, _trackTypes).set(trackName, { type, source: "catalog" });
+  }
+  /**
+   * Register a track name → type from init data / inline signaling (MMTP FT=0).
+   * Authoritative until the next catalog update per §5.3.
+   * Does NOT overwrite an existing catalog registration.
+   */
+  registerTrackTypeFromInit(trackName, type) {
+    const existing = __privateGet(this, _trackTypes).get(trackName);
+    if (existing?.source === "catalog") return;
+    __privateGet(this, _trackTypes).set(trackName, { type, source: "init" });
+  }
+  /**
+   * Assign a per-track source. Frames from this source bypass the binary
+   * MoQ↔multicast switching for this track only.
+   *
+   * Throws TrackSourceConflictError if a source is already assigned for this
+   * track without a clearTrackSource() in between.
+   */
+  setTrackSource(trackName, source, opts) {
+    if (__privateGet(this, _trackSources).has(trackName)) {
+      throw new TrackSourceConflictError(trackName);
+    }
+    const effectivePolicy = opts?.policy ?? (opts?.overlay ? "wait" : void 0);
+    if (effectivePolicy === "crossfade") {
+      __privateGet(this, _crossfadeCounters).set(trackName, __privateGet(this, _crossfadeFrames));
+    }
+    const record = {
+      source,
+      unsubscribeFrame: () => {
+      },
+      emitCount: 0
+    };
+    record.unsubscribeFrame = source.onFrame((data, meta) => {
+      record.emitCount++;
+      if (effectivePolicy === "wait") {
+        __privateMethod(this, _MediaRouter_instances, handleOverlayFrame_fn).call(this, data, meta);
+      } else {
+        __privateMethod(this, _MediaRouter_instances, emitForTrack_fn).call(this, trackName, data, meta);
+      }
+    });
+    if (source.onError) {
+      record.unsubscribeError = source.onError(() => {
+        this.clearTrackSource(trackName);
+      });
+    }
+    __privateGet(this, _trackSources).set(trackName, record);
+  }
+  /**
+   * Remove the per-track source for the given track.
+   * Binary switching resumes for this track after this call.
+   */
+  clearTrackSource(trackName) {
+    const record = __privateGet(this, _trackSources).get(trackName);
+    if (!record) return;
+    record.unsubscribeFrame();
+    record.unsubscribeError?.();
+    record.source.dispose?.();
+    __privateGet(this, _trackSources).delete(trackName);
+    __privateGet(this, _crossfadeCounters).delete(trackName);
+    const reg = __privateGet(this, _trackTypes).get(trackName);
+    const isMedia = reg?.type === "video" || reg?.type === "audio" || reg === void 0 && (trackName === "video" || trackName === "audio");
+    if (!isMedia) {
+      __privateSet(this, _overlayBoundaryReached, false);
+      __privateSet(this, _overlayBuffer, []);
+    }
+  }
+  /**
+   * Signal that a FEC block boundary has been reached on the base track.
+   * Overlay tracks waiting for alignment flush their buffered frames now.
+   */
+  notifyFecBlockBoundary() {
+    var _a;
+    if (__privateGet(this, _overlayBoundaryReached)) return;
+    __privateSet(this, _overlayBoundaryReached, true);
+    const buffered = __privateGet(this, _overlayBuffer).splice(0);
+    for (const { data, meta } of buffered) {
+      (_a = __privateGet(this, _onOverlayFrame)) == null ? void 0 : _a.call(this, data, meta);
+    }
+  }
+  /**
+   * Return the number of frames emitted from the per-track source for a given
+   * track. Used in test-mode to verify per-track routing histogram.
+   * Returns 0 if no per-track source is active for the track.
+   */
+  trackSourceEmitCount(trackName) {
+    return __privateGet(this, _trackSources).get(trackName)?.emitCount ?? 0;
+  }
+  /** Feed a frame from the MoQ path. Suppressed when multicast is active OR a per-track source owns this track. */
+  feedMoq(data, meta, kind) {
+    var _a, _b;
+    if (__privateGet(this, _trackSources).has(kind)) {
+      const remaining = __privateGet(this, _crossfadeCounters).get(kind);
+      if (remaining && remaining > 0) {
+        const next = remaining - 1;
+        if (next === 0) {
+          __privateGet(this, _crossfadeCounters).delete(kind);
+        } else {
+          __privateGet(this, _crossfadeCounters).set(kind, next);
+        }
+      } else {
+        return;
+      }
+    }
+    if (__privateGet(this, _suppressed)) return;
+    const routedMeta = { ...meta, source: "moq" };
+    if (kind === "video") (_a = __privateGet(this, _onVideoFrame)) == null ? void 0 : _a.call(this, data, routedMeta);
+    else (_b = __privateGet(this, _onAudioFrame)) == null ? void 0 : _b.call(this, data, routedMeta);
+  }
+  /** Feed a frame from the multicast path. Video waits for keyframe before activating. */
+  feedMulticast(data, meta, kind) {
+    var _a, _b;
+    if (__privateGet(this, _trackSources).has(kind)) {
+      const remaining = __privateGet(this, _crossfadeCounters).get(kind);
+      if (remaining && remaining > 0) {
+        const next = remaining - 1;
+        if (next === 0) {
+          __privateGet(this, _crossfadeCounters).delete(kind);
+        } else {
+          __privateGet(this, _crossfadeCounters).set(kind, next);
+        }
+      } else {
+        return;
+      }
+    }
+    if (kind === "video") {
+      if (!__privateGet(this, _multicastVideoKeyed)) {
+        const moqSeededDelta = !meta.keyframe && __privateGet(this, _allowDeltaMulticastTakeoverAfterMoqKeyframe) && __privateGet(this, _moqVideoKeyframeEmitted);
+        if (!meta.keyframe && !moqSeededDelta) return;
+        __privateSet(this, _multicastVideoKeyed, true);
+        const pendingMeta = { ...meta, source: "multicast" };
+        if (!moqSeededDelta) pendingMeta.sourceDiscontinuity = true;
+        __privateSet(this, _pendingMulticastVideo, {
+          data: data.slice(),
+          meta: pendingMeta
+        });
+        if (__privateGet(this, _requireAudio) && __privateGet(this, _audioFallbackMs) > 0 && !__privateGet(this, _multicastAudioReceived) && !__privateGet(this, _audioFallbackTimer)) {
+          __privateSet(this, _audioFallbackTimer, setTimeout(() => {
+            if (!__privateGet(this, _multicastAudioReceived) && __privateGet(this, _active) !== "multicast") {
+              __privateSet(this, _multicastAudioReceived, true);
+              __privateSet(this, _moqAudioWarmed, true);
+              __privateMethod(this, _MediaRouter_instances, tryActivateMulticast_fn).call(this);
+            }
+          }, __privateGet(this, _audioFallbackMs)));
+        }
+      } else if (__privateGet(this, _active) !== "multicast") {
+        if (meta.keyframe) {
+          __privateSet(this, _pendingMulticastVideo, {
+            data: data.slice(),
+            meta: { ...meta, source: "multicast", sourceDiscontinuity: true }
+          });
+        }
+        __privateMethod(this, _MediaRouter_instances, tryActivateMulticast_fn).call(this);
+        return;
+      }
+      if (__privateGet(this, _active) === "multicast") (_a = __privateGet(this, _onVideoFrame)) == null ? void 0 : _a.call(this, data, { ...meta, source: "multicast" });
+      __privateMethod(this, _MediaRouter_instances, tryActivateMulticast_fn).call(this);
+    } else {
+      __privateSet(this, _multicastAudioReceived, true);
+      if (__privateGet(this, _audioFallbackTimer)) {
+        clearTimeout(__privateGet(this, _audioFallbackTimer));
+        __privateSet(this, _audioFallbackTimer, null);
+      }
+      if (!__privateGet(this, _moqAudioWarmed)) __privateSet(this, _moqAudioWarmed, true);
+      __privateMethod(this, _MediaRouter_instances, tryActivateMulticast_fn).call(this);
+      if (__privateGet(this, _active) === "multicast") {
+        (_b = __privateGet(this, _onAudioFrame)) == null ? void 0 : _b.call(this, data, { ...meta, source: "multicast" });
+      } else if (__privateGet(this, _pendingMulticastToken) !== null) {
+        __privateSet(this, _pendingMulticastAudio, { data: data.slice(), meta: { ...meta, source: "multicast" } });
+      }
+    }
+  }
+  /** Called by the player when the MoQ unicast audio decoder emits first frame. */
+  notifyMoqAudioEmit() {
+    if (__privateGet(this, _moqAudioWarmed)) return;
+    __privateSet(this, _moqAudioWarmed, true);
+    __privateMethod(this, _MediaRouter_instances, tryActivateMulticast_fn).call(this);
+  }
+  /**
+   * Called by the player after a MoQ video keyframe has reached the active
+   * decoder path. Used only by MSE/MMTP continuity switching; decoder-reset
+   * paths leave allowDeltaMulticastTakeoverAfterMoqKeyframe disabled.
+   */
+  notifyMoqVideoKeyframeEmit() {
+    __privateSet(this, _moqVideoKeyframeEmitted, true);
+    __privateMethod(this, _MediaRouter_instances, tryActivateMulticast_fn).call(this);
+  }
+  /** Switch back to MoQ immediately (called on multicast failback). */
+  failbackToMoq() {
+    var _a;
+    const hadPendingMulticast = __privateGet(this, _pendingMulticastToken) !== null;
+    if (__privateGet(this, _active) === "moq" && !hadPendingMulticast) return;
+    ++__privateWrapper(this, _sourceSwitchToken)._;
+    __privateSet(this, _active, "moq");
+    __privateSet(this, _suppressed, false);
+    __privateSet(this, _pendingMulticastToken, null);
+    __privateSet(this, _pendingMulticastVideo, null);
+    __privateSet(this, _pendingMulticastAudio, null);
+    __privateSet(this, _sourceSwitchReady, null);
+    __privateSet(this, _multicastVideoKeyed, false);
+    __privateSet(this, _multicastAudioReceived, false);
+    __privateSet(this, _moqVideoKeyframeEmitted, false);
+    if (__privateGet(this, _audioFallbackTimer)) {
+      clearTimeout(__privateGet(this, _audioFallbackTimer));
+      __privateSet(this, _audioFallbackTimer, null);
+    }
+    (_a = __privateGet(this, _onSourceSwitch)) == null ? void 0 : _a.call(this, "moq");
+  }
+  /** Dispose timers and per-track sources. Call on teardown to prevent
+   *  stale timer callbacks firing into garbage-collected closures (WR-03). */
+  dispose() {
+    if (__privateGet(this, _audioFallbackTimer)) {
+      clearTimeout(__privateGet(this, _audioFallbackTimer));
+      __privateSet(this, _audioFallbackTimer, null);
+    }
+    for (const [name] of __privateGet(this, _trackSources)) {
+      this.clearTrackSource(name);
+    }
+  }
+};
+_active = new WeakMap();
+_multicastVideoKeyed = new WeakMap();
+_multicastAudioReceived = new WeakMap();
+_moqVideoKeyframeEmitted = new WeakMap();
+_requireAudio = new WeakMap();
+_suppressed = new WeakMap();
+_audioFallbackTimer = new WeakMap();
+_audioFallbackMs = new WeakMap();
+_crossfadeFrames = new WeakMap();
+_maxOverlayBuffer = new WeakMap();
+_allowDeltaMulticastTakeoverAfterMoqKeyframe = new WeakMap();
+_repairInFlight = new WeakMap();
+_maxRepairInFlight = new WeakMap();
+_onRepairRequest = new WeakMap();
+_onVideoFrame = new WeakMap();
+_onAudioFrame = new WeakMap();
+_onOverlayFrame = new WeakMap();
+_onSourceSwitch = new WeakMap();
+_sourceSwitchReady = new WeakMap();
+_sourceSwitchToken = new WeakMap();
+_pendingMulticastToken = new WeakMap();
+_pendingMulticastVideo = new WeakMap();
+_pendingMulticastAudio = new WeakMap();
+_trackSources = new WeakMap();
+_trackTypes = new WeakMap();
+_crossfadeCounters = new WeakMap();
+_overlayBoundaryReached = new WeakMap();
+_overlayBuffer = new WeakMap();
+_deltaConfigured = new WeakMap();
+_deltaActive = new WeakMap();
+_deltaWindow = new WeakMap();
+_deltaWindowSize = new WeakMap();
+_deltaFailThresholdRatio = new WeakMap();
+_deltaRecoverThresholdRatio = new WeakMap();
+_deltaProbeIntervalMs = new WeakMap();
+_lastProbeAt = new WeakMap();
+_onDeltaFallbackCb = new WeakMap();
+_onDeltaRecoverCb = new WeakMap();
+_onGroupDrift = new WeakMap();
+_groupAlignWarnCounts = new WeakMap();
+_MediaRouter_instances = new WeakSet();
+/**
+ * Warn at most `GROUP_ALIGN_WARN_BUDGET[reason]` times **per reason**, across
+ * every skip and post-emit failure on the drift path.
+ *
+ * Note the two call shapes: the resolvers call this *instead of* computing a
+ * groupId, and return its `null` to skip the drift check; the `onGroupDrift`
+ * catch calls it after the check already ran and the event was already
+ * emitted, so there only the warn is coalesced and the `null` is discarded.
+ *
+ * Keyed on a short stable `reason` tag, NOT on the formatted message: the
+ * messages interpolate track name and operand values, so message-keying
+ * would hand a malformed stream a fresh warn slot on every boundary — the
+ * log flood this coalescing exists to prevent.
+ *
+ * Per-reason rather than one shared boolean (PCL-2211, #329 review): the
+ * budget is never reset — not by `dispose()`, not on source switch — so a
+ * single flag means the FIRST malformed boundary of a long-running stream
+ * permanently silences every later, genuinely different failure mode. The
+ * throw/overflow diagnostics carry the operand values (`ticks=`, `durTicks=`,
+ * `err.message`) an incident responder actually needs, and under one shared
+ * flag those are precisely the ones most likely to be already spent by an
+ * unrelated NaN at catalog load.
+ *
+ * A closed, bounded set of reasons times a small per-reason budget is still
+ * bounded, so this cannot flood. See `GROUP_ALIGN_WARN_BUDGET` for why the
+ * budget is not uniform.
+ */
+skipWithWarning_fn = function(reason, message) {
+  const seen = __privateGet(this, _groupAlignWarnCounts).get(reason) ?? 0;
+  if (seen < GROUP_ALIGN_WARN_BUDGET[reason]) {
+    __privateGet(this, _groupAlignWarnCounts).set(reason, seen + 1);
+    console.warn(message);
+  }
+  return null;
+};
+/**
+ * Exact path: integers straight from the catalog, no rounding. `mediaTimeSec`
+ * / `groupDurationSec` are derived for reporting only and never feed the
+ * groupId computation.
+ */
+resolveTicks_fn = function(trackName, timing) {
+  const { mediaTimeTicks, groupDurationTicks, timescale } = timing;
+  if (!Number.isInteger(mediaTimeTicks) || !Number.isInteger(groupDurationTicks) || groupDurationTicks <= 0 || !Number.isInteger(timescale) || timescale <= 0) {
+    return __privateMethod(this, _MediaRouter_instances, skipWithWarning_fn).call(this, "invalid-tick-inputs", `[MediaRouter] notifyGroupBoundary invalid tick inputs (track=${trackName} mediaTimeTicks=${mediaTimeTicks} groupDurationTicks=${groupDurationTicks} timescale=${timescale}); skipping drift check. Pre-validate at catalog load time.`);
+  }
+  try {
+    return {
+      expected: groupIdForTicks(mediaTimeTicks, groupDurationTicks),
+      mediaTimeSec: mediaTimeTicks / timescale,
+      groupDurationSec: groupDurationTicks / timescale,
+      // Snapshot, not the caller's reference: a producer that reuses one
+      // scratch object per boundary would otherwise retroactively mutate
+      // every GroupDriftEvent it has already emitted. Three integers.
+      timing: { mediaTimeTicks, groupDurationTicks, timescale }
+    };
+  } catch (err) {
+    return __privateMethod(this, _MediaRouter_instances, skipWithWarning_fn).call(this, "ticks-formula-threw", `[MediaRouter] notifyGroupBoundary: groupIdForTicks threw (track=${trackName} mediaTimeTicks=${mediaTimeTicks} groupDurationTicks=${groupDurationTicks}); skipping drift check: ${err?.message ?? err}`);
+  }
+};
+/**
+ * Legacy seconds path. Quantizes to a synthetic 1e9 Hz timescale — the exact
+ * behaviour the deprecated `align.groupIdFor` wrapper had, reproduced here so
+ * that wrapper has no non-test callers left and can be deleted (BLO-21176).
+ *
+ * Inherits that wrapper's ns-rounding error; see the `@deprecated` overload.
+ * Delete this branch once every caller passes ticks.
+ */
+resolveSeconds_fn = function(trackName, mediaTimeSec, groupDurationSec) {
+  if (!Number.isFinite(groupDurationSec) || groupDurationSec <= 0 || !Number.isFinite(mediaTimeSec)) {
+    return __privateMethod(this, _MediaRouter_instances, skipWithWarning_fn).call(this, "invalid-seconds-inputs", `[MediaRouter] notifyGroupBoundary invalid inputs (track=${trackName} mediaTimeSec=${mediaTimeSec} groupDurationSec=${groupDurationSec}); skipping drift check. Pre-validate at catalog load time.`);
+  }
+  const TS = 1e9;
+  const ticks = mediaTimeSec < 0 ? 0 : Math.round(mediaTimeSec * TS);
+  const durTicks = Math.round(groupDurationSec * TS);
+  if (durTicks <= 0) {
+    return __privateMethod(this, _MediaRouter_instances, skipWithWarning_fn).call(this, "sub-nanosecond-duration", `[MediaRouter] notifyGroupBoundary: groupDurationSec=${groupDurationSec} rounds to <1 tick at 1e9 Hz (track=${trackName}); skipping drift check. Pass GroupBoundaryTicks for sub-nanosecond durations.`);
+  }
+  if (!Number.isSafeInteger(ticks)) {
+    return __privateMethod(this, _MediaRouter_instances, skipWithWarning_fn).call(this, "media-time-overflow", `[MediaRouter] notifyGroupBoundary: mediaTimeSec=${mediaTimeSec} overflows safe-integer ticks at 1e9 Hz (>~104 days, track=${trackName}); skipping drift check. Pass GroupBoundaryTicks with the catalog timescale.`);
+  }
+  try {
+    return {
+      expected: groupIdForTicks(ticks, durTicks),
+      mediaTimeSec,
+      groupDurationSec
+    };
+  } catch (err) {
+    return __privateMethod(this, _MediaRouter_instances, skipWithWarning_fn).call(this, "seconds-formula-threw", `[MediaRouter] notifyGroupBoundary: groupIdForTicks threw (track=${trackName} mediaTimeSec=${mediaTimeSec} groupDurationSec=${groupDurationSec} ticks=${ticks} durTicks=${durTicks}); skipping drift check: ${err?.message ?? err}`);
+  }
+};
+_moqAudioWarmed = new WeakMap();
+tryActivateMulticast_fn = function() {
+  var _a;
+  if (__privateGet(this, _active) === "multicast") return;
+  if (__privateGet(this, _pendingMulticastToken) !== null) return;
+  if (!__privateGet(this, _multicastVideoKeyed)) return;
+  if (__privateGet(this, _requireAudio) && !__privateGet(this, _multicastAudioReceived)) return;
+  if (__privateGet(this, _requireAudio) && !__privateGet(this, _moqAudioWarmed)) return;
+  const token = ++__privateWrapper(this, _sourceSwitchToken)._;
+  const maybeReady = (_a = __privateGet(this, _onSourceSwitch)) == null ? void 0 : _a.call(this, "multicast");
+  if (!maybeReady || typeof maybeReady.then !== "function") {
+    __privateMethod(this, _MediaRouter_instances, commitMulticastActivation_fn).call(this, token);
+    return;
+  }
+  const ready = Promise.resolve(maybeReady);
+  __privateSet(this, _pendingMulticastToken, token);
+  __privateSet(this, _sourceSwitchReady, ready);
+  void ready.then(
+    () => __privateMethod(this, _MediaRouter_instances, commitMulticastActivation_fn).call(this, token),
+    (err) => __privateMethod(this, _MediaRouter_instances, rejectMulticastActivation_fn).call(this, token, err)
+  ).finally(() => {
+    if (__privateGet(this, _sourceSwitchReady) === ready) __privateSet(this, _sourceSwitchReady, null);
+  });
+};
+commitMulticastActivation_fn = function(token) {
+  var _a, _b;
+  if (token !== __privateGet(this, _sourceSwitchToken)) return;
+  __privateSet(this, _active, "multicast");
+  __privateSet(this, _suppressed, true);
+  __privateSet(this, _pendingMulticastToken, null);
+  const video = __privateGet(this, _pendingMulticastVideo);
+  __privateSet(this, _pendingMulticastVideo, null);
+  const audio = __privateGet(this, _pendingMulticastAudio);
+  __privateSet(this, _pendingMulticastAudio, null);
+  if (video) (_a = __privateGet(this, _onVideoFrame)) == null ? void 0 : _a.call(this, video.data, video.meta);
+  if (audio) (_b = __privateGet(this, _onAudioFrame)) == null ? void 0 : _b.call(this, audio.data, audio.meta);
+};
+rejectMulticastActivation_fn = function(token, err) {
+  if (token !== __privateGet(this, _sourceSwitchToken)) return;
+  if (__privateGet(this, _pendingMulticastToken) === token) __privateSet(this, _pendingMulticastToken, null);
+  __privateSet(this, _pendingMulticastVideo, null);
+  __privateSet(this, _pendingMulticastAudio, null);
+  console.warn("[MediaRouter] onSourceSwitch(multicast) failed", err);
+};
+// ── Private helpers ──────────────────────────────────────────────────────
+/** Emit a frame on the correct per-track callback using the type registry.
+ *  Falls back to name match if no type registered (backward compat). */
+emitForTrack_fn = function(trackName, data, meta) {
+  var _a, _b, _c, _d, _e, _f;
+  const reg = __privateGet(this, _trackTypes).get(trackName);
+  if (reg?.type === "video") {
+    (_a = __privateGet(this, _onVideoFrame)) == null ? void 0 : _a.call(this, data, meta);
+  } else if (reg?.type === "audio") {
+    (_b = __privateGet(this, _onAudioFrame)) == null ? void 0 : _b.call(this, data, meta);
+  } else if (reg !== void 0) {
+    (_c = __privateGet(this, _onOverlayFrame)) == null ? void 0 : _c.call(this, data, meta);
+  } else {
+    if (trackName === "video") (_d = __privateGet(this, _onVideoFrame)) == null ? void 0 : _d.call(this, data, meta);
+    else if (trackName === "audio") (_e = __privateGet(this, _onAudioFrame)) == null ? void 0 : _e.call(this, data, meta);
+    else (_f = __privateGet(this, _onOverlayFrame)) == null ? void 0 : _f.call(this, data, meta);
+  }
+};
+/** Handle an overlay frame: buffer until first FEC block boundary, then pass through. */
+handleOverlayFrame_fn = function(data, meta) {
+  var _a;
+  if (__privateGet(this, _overlayBoundaryReached)) {
+    (_a = __privateGet(this, _onOverlayFrame)) == null ? void 0 : _a.call(this, data, meta);
+    return;
+  }
+  if (__privateGet(this, _overlayBuffer).length >= __privateGet(this, _maxOverlayBuffer)) {
+    console.warn(
+      `[MediaRouter] overlay buffer full (${__privateGet(this, _maxOverlayBuffer)} frames); dropping frame ts=${meta.timestamp}`
+    );
+    return;
+  }
+  __privateGet(this, _overlayBuffer).push({ data, meta });
+};
+export {
+  MediaRouter,
+  TrackSourceConflictError
+};
+//# sourceMappingURL=media-router.js.map