@blockcast/mmt-container 0.1.0-main.0399efef1f07

package/dist/track-session.js

@@ -0,0 +1,767 @@
+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);
+
+// src/transport-pool.ts
+var _subs, _options, _failedCb, _stats;
+var TransportPool = class {
+  constructor(options) {
+    __privateAdd(this, _subs, /* @__PURE__ */ new Map());
+    __privateAdd(this, _options);
+    __privateAdd(this, _failedCb, null);
+    __privateAdd(this, _stats, { activeSubscriptions: 0, totalAcquires: 0, totalReleases: 0 });
+    __privateSet(this, _options, options ?? {});
+  }
+  /** Register callback for subscription failures. */
+  onSubscriptionFailed(cb) {
+    __privateSet(this, _failedCb, cb);
+  }
+  acquireSubscription(keyOrOpts, consumer) {
+    const key = typeof keyOrOpts === "string" ? keyOrOpts : keyOrOpts.key;
+    const cons = typeof keyOrOpts === "string" ? consumer : keyOrOpts.consumer;
+    const mode = typeof keyOrOpts === "object" ? keyOrOpts.mode : "moq";
+    let sub = __privateGet(this, _subs).get(key);
+    if (!sub) {
+      sub = { key, mode, consumers: /* @__PURE__ */ new Set() };
+      __privateGet(this, _subs).set(key, sub);
+      __privateGet(this, _stats).activeSubscriptions++;
+    }
+    ;
+    sub.consumers.add(cons);
+    __privateGet(this, _stats).totalAcquires++;
+    return sub;
+  }
+  /** Release a subscription for a consumer. Closes if last consumer. */
+  releaseSubscription(key, consumer) {
+    const sub = __privateGet(this, _subs).get(key);
+    if (!sub) return;
+    sub.consumers.delete(consumer);
+    __privateGet(this, _stats).totalReleases++;
+    if (sub.consumers.size === 0) {
+      __privateGet(this, _subs).delete(key);
+      __privateGet(this, _stats).activeSubscriptions--;
+    }
+  }
+  /** Release all subscriptions held by a consumer. */
+  releaseAllForConsumer(consumer) {
+    for (const [key, sub] of __privateGet(this, _subs)) {
+      ;
+      sub.consumers.delete(consumer);
+      if (sub.consumers.size === 0) {
+        __privateGet(this, _subs).delete(key);
+        __privateGet(this, _stats).activeSubscriptions--;
+      }
+    }
+  }
+  /** Report a subscription failure. */
+  reportFailure(key, error) {
+    var _a;
+    const sub = __privateGet(this, _subs).get(key);
+    if (sub) (_a = __privateGet(this, _failedCb)) == null ? void 0 : _a.call(this, { key, consumers: sub.consumers, error });
+  }
+  /** Get stats. */
+  get stats() {
+    return __privateGet(this, _stats);
+  }
+  /** Clean up all subscriptions. */
+  dispose() {
+    __privateGet(this, _subs).clear();
+    __privateSet(this, _failedCb, null);
+    __privateGet(this, _stats).activeSubscriptions = 0;
+  }
+  /** Number of active subscriptions. */
+  get size() {
+    return __privateGet(this, _subs).size;
+  }
+};
+_subs = new WeakMap();
+_options = new WeakMap();
+_failedCb = new WeakMap();
+_stats = new WeakMap();
+
+// src/track-session.ts
+import { fecBlockBudgetMs } from "@blockcast/mmt-fec";
+function computeFecLossWindowMs(fecInterleaveMs, fecK, jitterBufferMs) {
+  return computeFecDeliveryWindowMs({
+    interleaveDepthMs: fecInterleaveMs,
+    sourceSymbols: fecK,
+    jitterBufferMs
+  });
+}
+function computeFecDeliveryWindowMs(config) {
+  const fecInterleaveMs = config.interleaveDepthMs;
+  const fecK = config.sourceSymbols;
+  if (!Number.isFinite(fecInterleaveMs) || fecInterleaveMs <= 0) {
+    throw new Error(
+      `[TrackSession] fecInterleaveMs=${fecInterleaveMs}. Derive a positive FEC interleave window from the stream catalog.`
+    );
+  }
+  if (!Number.isFinite(fecK) || fecK <= 0) {
+    throw new Error(
+      `[TrackSession] fecK=${fecK}. Derive a positive FEC source-symbol count from the stream catalog.`
+    );
+  }
+  if (config.jitterBufferMs === void 0) return Math.ceil(fecInterleaveMs);
+  return fecBlockBudgetMs(fecInterleaveMs, config.jitterBufferMs);
+}
+function computeFecDeliveryWindowMediaUnits(config, timestampTimescale) {
+  if (!Number.isFinite(timestampTimescale) || timestampTimescale <= 0) {
+    throw new Error(
+      `[TrackSession] timestampTimescale=${timestampTimescale}. Derive a positive media timescale from the container.`
+    );
+  }
+  const deliveryWindow = Math.ceil(
+    computeFecDeliveryWindowMs(config) * timestampTimescale / 1e3
+  );
+  if (!Number.isSafeInteger(deliveryWindow)) {
+    throw new Error("[TrackSession] FEC delivery window exceeds the media timestamp range.");
+  }
+  return deliveryWindow;
+}
+var _state, _subscription, _hysteresisTimer, _joinDeadlineTimer, _previousPrimary, _manager, _suppressFired, _fecArmed, _TrackSession_instances, transition_fn, clearHysteresis_fn, armJoinDeadline_fn, clearJoinDeadline_fn, armFec_fn, disarmFec_fn, suppress_fn, unsuppress_fn;
+var TrackSession = class {
+  constructor(config, manager) {
+    __privateAdd(this, _TrackSession_instances);
+    __privateAdd(this, _state, "idle");
+    __privateAdd(this, _subscription, null);
+    __privateAdd(this, _hysteresisTimer, null);
+    __privateAdd(this, _joinDeadlineTimer, null);
+    __privateAdd(this, _previousPrimary, null);
+    __privateAdd(this, _manager);
+    // Single suppression authority flag (BLO-9413 failback coherence): every
+    // suppress this session fires is recorded here, and every path that leaves
+    // a suppressed state unwinds through #unsuppress(). Before this flag,
+    // unsubscribe() only un-suppressed from multicast/amt — a session torn down
+    // from `failing` (exactly where a starving track sits) was re-subscribed to
+    // unicast with the host's media still muted: MoQ playing into a dead sink.
+    __privateAdd(this, _suppressFired, false);
+    // Single FEC authority flag: set by the fec-setup edges (joinStarted,
+    // enterUnicastFallback), cleared by the fec-teardown edge in #transition.
+    // Setup and teardown are paired by construction, so a takeover timeout that
+    // parks the session in `unicast` keeps the decoder the still-joined
+    // transport is feeding, and the later unsubscribe still tears it down.
+    __privateAdd(this, _fecArmed, false);
+    this.config = config;
+    __privateSet(this, _manager, manager);
+  }
+  // -----------------------------------------------------------------------
+  // State
+  // -----------------------------------------------------------------------
+  get state() {
+    return __privateGet(this, _state);
+  }
+  get subscription() {
+    return __privateGet(this, _subscription);
+  }
+  /** True while this session's onSuppress(true) is outstanding (no matching
+   *  onSuppress(false) yet). Test/assertion surface for failback coherence. */
+  get isSuppressed() {
+    return __privateGet(this, _suppressFired);
+  }
+  /** Current active transport mode, or null if idle. */
+  get transport() {
+    switch (__privateGet(this, _state)) {
+      case "multicast":
+        return "multicast";
+      case "amt":
+        return "amt";
+      case "unicast":
+        return "moq";
+      case "unicast-fallback":
+        return "moq";
+      // SSM bridge absent — MoQ unicast is the only source
+      case "joining":
+        return "moq";
+      // MoQ still primary during join
+      case "failing":
+        return __privateGet(this, _previousPrimary);
+      default:
+        return null;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Computed (no magic numbers)
+  // -----------------------------------------------------------------------
+  /** Audio worklet latency: max(fecInterleaveMs, frameDurationMs * fecK).
+   *  Returns undefined if frame duration unknown (no initData). */
+  get audioLatencyMs() {
+    const fd = this.frameDurationMs;
+    if (fd === void 0) {
+      return this.config.fecInterleaveMs > 0 ? this.config.fecInterleaveMs : void 0;
+    }
+    return Math.max(this.config.fecInterleaveMs, fd * this.config.fecK);
+  }
+  /** Frame duration in ms, derived from frameSamples + sampleRate. */
+  get frameDurationMs() {
+    const { frameSamples, sampleRate } = this.config;
+    if (!frameSamples || !sampleRate || sampleRate <= 0) return void 0;
+    return frameSamples / sampleRate * 1e3;
+  }
+  // -----------------------------------------------------------------------
+  // Transitions (Patent Claim 9)
+  // -----------------------------------------------------------------------
+  /** idle → unicast: player subscribes to this track. */
+  subscribe() {
+    if (__privateGet(this, _state) !== "idle") return;
+    __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast");
+    if (this.config.trackType === "audio") {
+      const latency = this.audioLatencyMs;
+      if (latency !== void 0) {
+        __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "latency", latencyMs: latency }, this.config);
+      }
+    }
+  }
+  /** unicast → joining: multicast/AMT capability detected, join in progress. */
+  joinStarted() {
+    if (__privateGet(this, _state) !== "unicast") return;
+    __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "joining");
+    __privateMethod(this, _TrackSession_instances, armFec_fn).call(this);
+  }
+  /**
+   * any non-fallback state → unicast-fallback. Used when the SSM bridge is
+   * absent (vanilla Chromium / no extension) and the host falls back to a
+   * MoQ unicast subscription per track. Terminal-ish: activateMulticast,
+   * failbackAll, and transportFailed are no-ops while in this state.
+   *
+   * Fires fec-setup so the per-track repair worker spins up — repair packets
+   * still flow over the MoQ repair-track subscription, so FEC source+repair
+   * can converge as in the multicast path.
+   *
+   * Audio latency is NOT re-emitted here: subscribe() already fires latency
+   * once on the idle → unicast edge, and enterUnicastFallback is only ever
+   * reached from a non-idle state (SessionManager skips idle sessions).
+   */
+  enterUnicastFallback() {
+    if (__privateGet(this, _state) === "unicast-fallback") return;
+    __privateMethod(this, _TrackSession_instances, clearHysteresis_fn).call(this);
+    __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast-fallback");
+    __privateMethod(this, _TrackSession_instances, suppress_fn).call(this);
+    __privateMethod(this, _TrackSession_instances, armFec_fn).call(this);
+  }
+  /**
+   * unicast-fallback → unicast. Called when the SSM bridge appears mid-session
+   * (extension installed after fallback engaged). Host first aborts the fallback
+   * drainers, then transitions sessions back to unicast so the regular
+   * multicast/AMT preference chain can take over via joinStarted().
+   */
+  exitUnicastFallback() {
+    if (__privateGet(this, _state) !== "unicast-fallback") return;
+    __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast");
+    __privateMethod(this, _TrackSession_instances, unsuppress_fn).call(this);
+  }
+  /**
+   * joining → multicast or amt: RAP received on the joined transport (Claim 9d).
+   * Resets audio worklet, then suppresses MoQ.
+   */
+  rapReceived(mode) {
+    if (__privateGet(this, _state) !== "joining") return;
+    __privateSet(this, _previousPrimary, mode);
+    __privateMethod(this, _TrackSession_instances, transition_fn).call(this, mode);
+    if (this.config.trackType === "audio") {
+      __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "reset" }, this.config);
+    }
+    __privateMethod(this, _TrackSession_instances, suppress_fn).call(this);
+  }
+  /** multicast/amt → failing: loss detected, start hysteresis timer (Claim 9f). */
+  lossDetected() {
+    if (__privateGet(this, _state) !== "multicast" && __privateGet(this, _state) !== "amt") return;
+    __privateSet(this, _previousPrimary, __privateGet(this, _state));
+    __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "failing");
+    const hysteresisMs = computeFecLossWindowMs(
+      this.config.fecInterleaveMs,
+      this.config.fecK,
+      this.config.fecReorderToleranceMs
+    );
+    __privateSet(this, _hysteresisTimer, setTimeout(() => {
+      this.hysteresisExpired();
+    }, hysteresisMs));
+  }
+  /** failing → previous primary: loss recovered within hysteresis window. */
+  lossRecovered() {
+    if (__privateGet(this, _state) !== "failing") return;
+    __privateMethod(this, _TrackSession_instances, clearHysteresis_fn).call(this);
+    if (__privateGet(this, _previousPrimary)) {
+      __privateMethod(this, _TrackSession_instances, transition_fn).call(this, __privateGet(this, _previousPrimary));
+    }
+  }
+  /**
+   * Transport failed (AMT relay down, multicast interface gone).
+   * Try next transport in preference chain.
+   */
+  transportFailed() {
+    __privateMethod(this, _TrackSession_instances, clearHysteresis_fn).call(this);
+    if (__privateGet(this, _state) === "unicast-fallback") return;
+    const current = __privateGet(this, _previousPrimary) ?? this.transport;
+    const prefs = this.config.preferredTransports;
+    const currentIdx = current ? prefs.indexOf(current) : -1;
+    const nextMode = prefs[currentIdx + 1];
+    if (nextMode !== void 0 && nextMode !== "moq") {
+      __privateSet(this, _previousPrimary, nextMode);
+      __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "joining");
+      __privateMethod(this, _TrackSession_instances, unsuppress_fn).call(this);
+      return;
+    }
+    const from = __privateGet(this, _state);
+    __privateSet(this, _previousPrimary, null);
+    __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast");
+    __privateMethod(this, _TrackSession_instances, disarmFec_fn).call(this);
+    __privateMethod(this, _TrackSession_instances, unsuppress_fn).call(this);
+    if (from !== "unicast" && this.config.trackType === "audio") {
+      __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "reset" }, this.config);
+    }
+  }
+  /** Hysteresis expired → failback to next transport (Claim 9g). */
+  hysteresisExpired() {
+    if (__privateGet(this, _state) !== "failing") return;
+    __privateMethod(this, _TrackSession_instances, clearHysteresis_fn).call(this);
+    this.transportFailed();
+  }
+  /** → idle: player unsubscribes / tab close / cleanup. */
+  unsubscribe() {
+    __privateMethod(this, _TrackSession_instances, clearHysteresis_fn).call(this);
+    if (__privateGet(this, _state) !== "idle") {
+      __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "idle");
+      __privateMethod(this, _TrackSession_instances, unsuppress_fn).call(this);
+    }
+  }
+  /** True when SessionManager.enterUnicastFallback put this track into the
+   *  host-driven unicast subscription mode. Host can iterate sessions to
+   *  decide whether to keep its fallback drainer alive across MediaRouter
+   *  arbitration events. */
+  get isUnicastFallback() {
+    return __privateGet(this, _state) === "unicast-fallback";
+  }
+  /**
+   * True while this track owns a FEC decoder (fec-setup fired, fec-teardown
+   * not yet). Stays true across a takeover timeout that parked the session in
+   * `unicast`; SessionManager.failbackAll uses it to release such sessions.
+   */
+  get isFecArmed() {
+    return __privateGet(this, _fecArmed);
+  }
+  /**
+   * Start the deadline a `joining` entry deferred while the join was inactive
+   * (SessionManager.joinActive). The track gets the FULL deadline from here,
+   * because that is when media can first arrive. No-op outside `joining` and
+   * when a deadline is already running, so it never shortens or restarts one.
+   *
+   * The `joinActive` guard is what makes this safe to call from anywhere: a
+   * track parked in `joining` with a deferred (null) timer satisfies the other
+   * two, so without it a host calling this while the join is still inactive
+   * would arm the exact deadline the gate exists to defer -- silently
+   * reinstating BLO-34289. It is a no-op for the internal caller, which writes
+   * `#joinActive = true` before iterating the sessions.
+   */
+  armDeferredJoinDeadline() {
+    if (__privateGet(this, _state) !== "joining" || __privateGet(this, _joinDeadlineTimer) !== null) return;
+    if (!__privateGet(this, _manager).joinActive) return;
+    __privateMethod(this, _TrackSession_instances, armJoinDeadline_fn).call(this, __privateGet(this, _manager).takeoverDeadlineMs);
+  }
+  dispose() {
+    __privateMethod(this, _TrackSession_instances, clearHysteresis_fn).call(this);
+    __privateMethod(this, _TrackSession_instances, clearJoinDeadline_fn).call(this);
+    __privateSet(this, _state, "idle");
+    __privateSet(this, _subscription, null);
+    __privateMethod(this, _TrackSession_instances, disarmFec_fn).call(this);
+  }
+};
+_state = new WeakMap();
+_subscription = new WeakMap();
+_hysteresisTimer = new WeakMap();
+_joinDeadlineTimer = new WeakMap();
+_previousPrimary = new WeakMap();
+_manager = new WeakMap();
+_suppressFired = new WeakMap();
+_fecArmed = new WeakMap();
+_TrackSession_instances = new WeakSet();
+// -----------------------------------------------------------------------
+// Internal
+// -----------------------------------------------------------------------
+transition_fn = function(to, opts) {
+  const from = __privateGet(this, _state);
+  if (from === to) return;
+  const joinDeadlineMs = to === "joining" ? __privateGet(this, _manager).takeoverDeadlineMs : void 0;
+  __privateSet(this, _state, to);
+  if (from === "joining") __privateMethod(this, _TrackSession_instances, clearJoinDeadline_fn).call(this);
+  if (joinDeadlineMs !== void 0 && __privateGet(this, _manager).joinActive) {
+    __privateMethod(this, _TrackSession_instances, armJoinDeadline_fn).call(this, joinDeadlineMs);
+  }
+  const fecActive = (s) => s === "joining" || s === "multicast" || s === "amt" || s === "failing" || s === "unicast-fallback";
+  if (!fecActive(to) && !opts?.retainFec) __privateMethod(this, _TrackSession_instances, disarmFec_fn).call(this);
+  __privateGet(this, _manager).callbacks?.onStateChange?.(this.config.trackName, from, to);
+};
+clearHysteresis_fn = function() {
+  if (__privateGet(this, _hysteresisTimer) !== null) {
+    clearTimeout(__privateGet(this, _hysteresisTimer));
+    __privateSet(this, _hysteresisTimer, null);
+  }
+};
+armJoinDeadline_fn = function(deadlineMs) {
+  __privateMethod(this, _TrackSession_instances, clearJoinDeadline_fn).call(this);
+  if (deadlineMs === 0) return;
+  __privateSet(this, _joinDeadlineTimer, setTimeout(() => {
+    __privateSet(this, _joinDeadlineTimer, null);
+    if (__privateGet(this, _state) !== "joining") return;
+    __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast", { retainFec: true });
+    __privateGet(this, _manager).callbacks?.onTakeoverTimeout?.(this.config.trackName);
+  }, deadlineMs));
+};
+clearJoinDeadline_fn = function() {
+  if (__privateGet(this, _joinDeadlineTimer) !== null) {
+    clearTimeout(__privateGet(this, _joinDeadlineTimer));
+    __privateSet(this, _joinDeadlineTimer, null);
+  }
+};
+/** Fire fec-setup exactly once per FEC epoch. */
+armFec_fn = function() {
+  if (__privateGet(this, _fecArmed)) return;
+  __privateSet(this, _fecArmed, true);
+  __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "fec-setup" }, this.config);
+};
+/** Fire fec-teardown for an armed decoder; no-op when none is armed. */
+disarmFec_fn = function() {
+  if (!__privateGet(this, _fecArmed)) return;
+  __privateSet(this, _fecArmed, false);
+  __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "fec-teardown" }, this.config);
+};
+/** Fire onSuppress(true) exactly once per suppression epoch. */
+suppress_fn = function() {
+  if (__privateGet(this, _suppressFired)) return;
+  __privateSet(this, _suppressFired, true);
+  __privateGet(this, _manager).callbacks?.onSuppress?.(this.config.trackName, true);
+};
+/** Unwind an outstanding suppression; no-op when none is outstanding. */
+unsuppress_fn = function() {
+  if (!__privateGet(this, _suppressFired)) return;
+  __privateSet(this, _suppressFired, false);
+  __privateGet(this, _manager).callbacks?.onSuppress?.(this.config.trackName, false);
+};
+var MAX_TAKEOVER_DEADLINE_MS = 2147483647;
+var JOIN_DEFER_WARN_MS = 3e4;
+var _takeoverDeadlineMs, _joinActive, _joinDeferWarnTimer, _SessionManager_instances, armJoinDeferWarn_fn, clearJoinDeferWarn_fn, requireTakeoverDeadlineMs_fn;
+var SessionManager = class {
+  constructor(poolOptions) {
+    __privateAdd(this, _SessionManager_instances);
+    this.sessions = /* @__PURE__ */ new Map();
+    this.callbacks = null;
+    __privateAdd(this, _takeoverDeadlineMs);
+    __privateAdd(this, _joinActive, true);
+    __privateAdd(this, _joinDeferWarnTimer, null);
+    this.pool = new TransportPool(poolOptions);
+    this.pool.onSubscriptionFailed((sub) => {
+      for (const trackName of sub.consumers) {
+        const session = this.sessions.get(trackName);
+        if (session) session.transportFailed();
+      }
+    });
+  }
+  /**
+   * Takeover deadline (BLO-9413/D9): the time a session may sit in `joining`
+   * without a RAP before returning to `unicast` and firing onTakeoverTimeout.
+   * MoQ is never suppressed during `joining`, so expiry abandons the takeover
+   * without a playback glitch. The host derives it from the catalog (RAP
+   * cadence from groupDurationTicks/timescale plus the signaled FEC delivery
+   * window or reorder tolerance) and sets it before addTrack(). There is no
+   * default: an unset value fails addTrack() closed, and reading the getter
+   * before assignment throws the same way, so no host ever holds a
+   * `number | undefined` it could coalesce back into a default.
+   * `hasTakeoverDeadline` answers whether one was admitted. A declared 0
+   * disables the deadline. The value is an integer number of milliseconds:
+   * setTimeout truncates fractions, so a host that divides ticks by a
+   * timescale must round before assigning.
+   *
+   * Assignment validates, so the diagnostic lands at the host's own call site.
+   * That is what bounds the blast radius: `joining` is entered from
+   * joinStarted(), from the transportFailed() failover branch -- itself
+   * reachable from a setTimeout via hysteresisExpired(), where no caller could
+   * catch a throw -- and from the activateMulticast()/activateAmt()/pool-failure
+   * loops, where a throw on one session would abandon its siblings mid-loop
+   * (the split-brain those loops exist to prevent). Refusing a bad value at
+   * assignment means no host mutation can make an already-admitted session
+   * throw out of a transport edge.
+   */
+  get takeoverDeadlineMs() {
+    return __privateMethod(this, _SessionManager_instances, requireTakeoverDeadlineMs_fn).call(this);
+  }
+  set takeoverDeadlineMs(value) {
+    if (!Number.isInteger(value) || value < 0 || value > MAX_TAKEOVER_DEADLINE_MS) {
+      throw new Error(
+        `[SessionManager] takeoverDeadlineMs must be an integer from 0 to ${MAX_TAKEOVER_DEADLINE_MS} (0 disables it, larger values overflow setTimeout); got ${String(value)}`
+      );
+    }
+    __privateSet(this, _takeoverDeadlineMs, value);
+  }
+  /** True once the host has admitted a deadline; a declared 0 counts. */
+  get hasTakeoverDeadline() {
+    return __privateGet(this, _takeoverDeadlineMs) !== void 0;
+  }
+  /**
+   * Whether the transport the joining tracks are waiting on is actually
+   * subscribed. The takeover deadline is a media-arrival budget and media
+   * cannot arrive before the join exists, so while this is false, entering
+   * `joining` arms no deadline; flipping it true starts the FULL deadline for
+   * every track already parked there.
+   *
+   * Default true, which is the arm-on-`joining` behaviour every host had
+   * before: a host that only calls joinStarted() after its own join resolves
+   * (moqtail-private's player, post-BLO-33339) is already at the right edge and
+   * needs no gate. A host that arms joinStarted() up front — to have FEC
+   * decoders ready before the first datagram — sets this false before addTrack()
+   * and true when its subscribe settles. Charging a slow subscribe (bridge
+   * reconnect, AMT relay handshake) against the media budget expired the
+   * deadline before the subscription existed and abandoned the join on the
+   * happy path. BLO-34289.
+   *
+   * The flag tracks the host's primary join, not per-track transport state. A
+   * track that fails over to the next transport in its own chain while this is
+   * false (transportFailed's failover branch also enters `joining`) has that
+   * deadline gated on the primary join activating, not on its own transport.
+   * Under the documented usage -- false once at setup, true once the subscribe
+   * settles -- the two coincide.
+   *
+   * The gate is on the ENTRY into `joining`, and false cannot take back a
+   * deadline already running: the `true -> false` edge arms the warn below and
+   * clears nothing. So set it false BEFORE the `joining` entry it is meant to
+   * gate. A host that instead flipped it false after a `transportFailed()`
+   * failover had already entered `joining` would leave the full deadline
+   * counting against a subscribe that had not begun -- BLO-34289 again, on the
+   * failover edge. Clearing running deadlines on that edge is deliberately NOT
+   * done: this flag is manager-wide, so one transport's brief false would
+   * cancel an unrelated track's live deadline and then re-arm it at FULL length
+   * on the next activation (armDeferredJoinDeadline sees `joining` + a null
+   * timer and cannot tell a cleared deadline from a deferred one). Every
+   * unrelated transport blip would restart the whole budget, so under repeated
+   * failover a track that should have timed out is extended indefinitely and
+   * never advances. Only a false that never returns true loses the timer
+   * outright, and JOIN_DEFER_WARN_MS already covers that.
+   *
+   * Leaving this false is not free: see JOIN_DEFER_WARN_MS.
+   */
+  get joinActive() {
+    return __privateGet(this, _joinActive);
+  }
+  set joinActive(active) {
+    const wasActive = __privateGet(this, _joinActive);
+    __privateSet(this, _joinActive, active);
+    if (!active) {
+      if (wasActive) __privateMethod(this, _SessionManager_instances, armJoinDeferWarn_fn).call(this);
+      return;
+    }
+    __privateMethod(this, _SessionManager_instances, clearJoinDeferWarn_fn).call(this);
+    if (wasActive) return;
+    for (const [, session] of this.sessions) session.armDeferredJoinDeadline();
+  }
+  /** Narrow to MMTP callbacks (onTrackEvent). Safe — optional chaining handles PIM-only consumers. */
+  get mmtp() {
+    return this.callbacks;
+  }
+  /** Add a track session from catalog config. */
+  addTrack(config) {
+    if (this.sessions.has(config.trackName)) {
+      throw new Error(`[SessionManager] Track "${config.trackName}" already exists`);
+    }
+    __privateMethod(this, _SessionManager_instances, requireTakeoverDeadlineMs_fn).call(this);
+    const session = new TrackSession(config, this);
+    this.sessions.set(config.trackName, session);
+    return session;
+  }
+  /** Remove a track session. Releases subscription with grace period. */
+  removeTrack(trackName) {
+    const session = this.sessions.get(trackName);
+    if (!session) return;
+    session.unsubscribe();
+    const subKey = session.config.multicastKey ?? session.config.moqTrackName;
+    if (subKey) this.pool.releaseSubscription(subKey, trackName);
+    session.dispose();
+    this.sessions.delete(trackName);
+  }
+  // -----------------------------------------------------------------------
+  // Atomic multi-track operations
+  // -----------------------------------------------------------------------
+  /**
+   * All tracks with multicast RAP → multicast state (atomic).
+   * Called when MediaRouter fires onSourceSwitch('multicast').
+   * Prevents split-brain between video and audio.
+   *
+   * A takeover deadline can return a track from `joining` to `unicast` while
+   * the multicast socket keeps delivering packets and the track keeps its FEC
+   * decoder armed. If a valid RAP arrives later, that late-RAP edge suppresses
+   * unicast and promotes multicast without a second fec-setup.
+   */
+  activateMulticast() {
+    for (const [, session] of this.sessions) {
+      if (session.state === "unicast") {
+        session.joinStarted();
+      }
+      if (session.state === "joining") {
+        session.rapReceived("multicast");
+      }
+    }
+  }
+  /**
+   * All tracks with AMT RAP → amt state (atomic).
+   */
+  activateAmt() {
+    for (const [, session] of this.sessions) {
+      if (session.state === "unicast") {
+        session.joinStarted();
+      }
+      if (session.state === "joining") {
+        session.rapReceived("amt");
+      }
+    }
+  }
+  /**
+   * All tracks → unicast (failback, atomic).
+   * Called when MulticastManager fires onFailback().
+   * unicast-fallback sessions are skipped — the host owns those subscriptions
+   * and they must drain uninterrupted across transport-state events.
+   *
+   * Coherence invariant (BLO-9413): after this returns, every non-fallback
+   * session is `unicast` (or `idle`), unsuppressed, and without a FEC decoder.
+   * unsubscribe() unwinds any outstanding suppression regardless of the state
+   * it tears down from (`failing` included; see TrackSession.#suppressFired),
+   * and a session that a takeover timeout parked in `unicast` with its decoder
+   * still armed is cycled too, because this transport edge is what releases
+   * that decoder (unsubscribe fires fec-teardown).
+   */
+  failbackAll() {
+    for (const [, session] of this.sessions) {
+      const parkedWithFec = session.state === "unicast" && session.isFecArmed;
+      if (parkedWithFec || session.state !== "idle" && session.state !== "unicast" && session.state !== "unicast-fallback") {
+        session.unsubscribe();
+        session.subscribe();
+      }
+    }
+  }
+  /**
+   * All tracks → unicast-fallback (atomic).
+   * Called by the host when the multicast gateway is absent and
+   * the player will subscribe to source tracks over MoQ unicast and feed
+   * packets via MulticastManager.feedUnicastSource() (or manager.router
+   * directly). Sessions in this state stay terminal until the host calls
+   * unsubscribe() / disposes the SessionManager.
+   */
+  enterUnicastFallback() {
+    for (const [, session] of this.sessions) {
+      if (session.state === "idle") continue;
+      session.enterUnicastFallback();
+    }
+  }
+  /**
+   * True if any session is currently in unicast-fallback. Hosts use this to
+   * gate `multicastTrack.close()` on failback events — closing the shared
+   * broadcast would kill the host's fallback drainers.
+   */
+  hasActiveFallback() {
+    for (const [, session] of this.sessions) {
+      if (session.isUnicastFallback) return true;
+    }
+    return false;
+  }
+  /**
+   * All fallback tracks → unicast (atomic).
+   * Called when the SSM bridge appears mid-session and the host has aborted
+   * the fallback drainers. The session re-enters the regular preference chain
+   * via joinStarted() (issued by the host immediately after).
+   */
+  exitUnicastFallback() {
+    for (const [, session] of this.sessions) {
+      if (session.isUnicastFallback) session.exitUnicastFallback();
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Cleanup lifecycle
+  // -----------------------------------------------------------------------
+  /** Tab closed — release all subscriptions for this tab (grace period). */
+  tabClosed(tabId) {
+    for (const [trackName, session] of this.sessions) {
+      session.unsubscribe();
+      this.pool.releaseAllForConsumer(trackName);
+    }
+  }
+  /** Bridge WebTransport connection dropped — same as tab close. */
+  bridgeDisconnected() {
+    this.tabClosed("bridge");
+  }
+  /**
+   * Track selection changed (user or ABR).
+   * Old track released (grace period), new track subscribed.
+   */
+  trackSelectionChanged(oldTrackName, newConfig) {
+    this.removeTrack(oldTrackName);
+    const session = this.addTrack(newConfig);
+    session.subscribe();
+  }
+  // -----------------------------------------------------------------------
+  // Query
+  // -----------------------------------------------------------------------
+  /** Get a track session by name. */
+  getTrack(trackName) {
+    return this.sessions.get(trackName);
+  }
+  // -----------------------------------------------------------------------
+  // Cleanup
+  // -----------------------------------------------------------------------
+  dispose() {
+    __privateMethod(this, _SessionManager_instances, clearJoinDeferWarn_fn).call(this);
+    for (const [, session] of this.sessions) {
+      session.dispose();
+    }
+    this.sessions.clear();
+    this.pool.dispose();
+    this.callbacks = null;
+  }
+};
+_takeoverDeadlineMs = new WeakMap();
+_joinActive = new WeakMap();
+_joinDeferWarnTimer = new WeakMap();
+_SessionManager_instances = new WeakSet();
+armJoinDeferWarn_fn = function() {
+  __privateSet(this, _joinDeferWarnTimer, setTimeout(() => {
+    __privateSet(this, _joinDeferWarnTimer, null);
+    const deferred = [...this.sessions.values()].filter((s) => s.state === "joining").length;
+    console.warn(
+      `[SessionManager] joinActive has been false for ${JOIN_DEFER_WARN_MS} ms and ${deferred} track(s) sit in 'joining' with no takeover deadline. Set joinActive = true when the subscribe settles, on every exit path including failures, or these tracks never time out, never release their FEC decoders, and never advance to the next transport.`
+    );
+  }, JOIN_DEFER_WARN_MS));
+};
+clearJoinDeferWarn_fn = function() {
+  if (__privateGet(this, _joinDeferWarnTimer) === null) return;
+  clearTimeout(__privateGet(this, _joinDeferWarnTimer));
+  __privateSet(this, _joinDeferWarnTimer, null);
+};
+// -----------------------------------------------------------------------
+// Track management
+// -----------------------------------------------------------------------
+/**
+ * The admitted takeover deadline. Throws only when the host never set one,
+ * every other invalid value being refused by the setter, and returns a
+ * declared 0 as 0. The getter and addTrack() both route through it, so a
+ * session cannot exist without an admitted deadline, which is what makes
+ * the #transition() read unable to throw on an already-admitted session.
+ */
+requireTakeoverDeadlineMs_fn = function() {
+  const value = __privateGet(this, _takeoverDeadlineMs);
+  if (value === void 0) {
+    throw new Error(
+      "[SessionManager] takeoverDeadlineMs is unset; set a catalog-derived takeover deadline (0 disables it) before adding tracks"
+    );
+  }
+  return value;
+};
+export {
+  JOIN_DEFER_WARN_MS,
+  MAX_TAKEOVER_DEADLINE_MS,
+  SessionManager,
+  TrackSession,
+  computeFecDeliveryWindowMediaUnits,
+  computeFecDeliveryWindowMs,
+  computeFecLossWindowMs
+};
+//# sourceMappingURL=track-session.js.map