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

package/dist/track-session.js

@@ -0,0 +1,597 @@
+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 { deriveFecInterleaveDepth } 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 (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);
+}
+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, _TrackSession_instances, transition_fn, clearHysteresis_fn, armJoinDeadline_fn, clearJoinDeadline_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);
+    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");
+    __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "fec-setup" }, this.config);
+  }
+  /**
+   * 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);
+    __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "fec-setup" }, this.config);
+  }
+  /**
+   * 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);
+    __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) {
+      if (nextMode === "moq") {
+        __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast");
+        __privateMethod(this, _TrackSession_instances, unsuppress_fn).call(this);
+        if (this.config.trackType === "audio") {
+          __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "reset" }, this.config);
+        }
+      } else {
+        __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "joining");
+        __privateMethod(this, _TrackSession_instances, unsuppress_fn).call(this);
+      }
+    } else {
+      __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast");
+      __privateMethod(this, _TrackSession_instances, unsuppress_fn).call(this);
+      if (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";
+  }
+  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);
+  }
+};
+_state = new WeakMap();
+_subscription = new WeakMap();
+_hysteresisTimer = new WeakMap();
+_joinDeadlineTimer = new WeakMap();
+_previousPrimary = new WeakMap();
+_manager = new WeakMap();
+_suppressFired = new WeakMap();
+_TrackSession_instances = new WeakSet();
+// -----------------------------------------------------------------------
+// Internal
+// -----------------------------------------------------------------------
+transition_fn = function(to) {
+  const from = __privateGet(this, _state);
+  if (from === to) return;
+  __privateSet(this, _state, to);
+  if (from === "joining") __privateMethod(this, _TrackSession_instances, clearJoinDeadline_fn).call(this);
+  if (to === "joining") __privateMethod(this, _TrackSession_instances, armJoinDeadline_fn).call(this);
+  const fecActive = (s) => s === "joining" || s === "multicast" || s === "amt" || s === "failing" || s === "unicast-fallback";
+  if (fecActive(from) && !fecActive(to)) {
+    __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "fec-teardown" }, this.config);
+  }
+  __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() {
+  __privateMethod(this, _TrackSession_instances, clearJoinDeadline_fn).call(this);
+  const deadlineMs = __privateGet(this, _manager).takeoverDeadlineMs;
+  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");
+    __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 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 SessionManager = class {
+  constructor(poolOptions) {
+    this.sessions = /* @__PURE__ */ new Map();
+    this.callbacks = null;
+    /**
+     * Takeover deadline (BLO-9413/D9): max 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 is a silent abandon —
+     * playback never glitches. Hosts tune per stream (e.g. GOP length); 0
+     * disables.
+     */
+    this.takeoverDeadlineMs = 5e3;
+    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();
+      }
+    });
+  }
+  /** Narrow to MMTP callbacks (onTrackEvent). Safe — optional chaining handles PIM-only consumers. */
+  get mmtp() {
+    return this.callbacks;
+  }
+  // -----------------------------------------------------------------------
+  // Track management
+  // -----------------------------------------------------------------------
+  /** Add a track session from catalog config. */
+  addTrack(config) {
+    if (this.sessions.has(config.trackName)) {
+      throw new Error(`[SessionManager] Track "${config.trackName}" already exists`);
+    }
+    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. If a valid RAP arrives
+   * later, allow that late-RAP edge to suppress unicast and promote multicast.
+   */
+  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`) AND unsuppressed — unsubscribe() unwinds
+   * any outstanding suppression regardless of the state it tears down from
+   * (`failing` included; see TrackSession.#suppressFired).
+   */
+  failbackAll() {
+    for (const [, session] of this.sessions) {
+      if (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() {
+    for (const [, session] of this.sessions) {
+      session.dispose();
+    }
+    this.sessions.clear();
+    this.pool.dispose();
+    this.callbacks = null;
+  }
+};
+export {
+  SessionManager,
+  TrackSession,
+  computeFecDeliveryWindowMediaUnits,
+  computeFecDeliveryWindowMs,
+  computeFecLossWindowMs
+};
+//# sourceMappingURL=track-session.js.map