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

package/dist/media-router.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/track-session.ts", "../src/media-router.ts"],
+  "sourcesContent": ["/**\n * TrackSession \u2014 per-track transport state machine.\n * SessionManager \u2014 orchestrates all sessions + TransportPool.\n *\n * Implements Patent Claim 9 (draft-ramadan-moq-fec APPLICATION-1):\n *   (a) subscribe unicast\n *   (b) simultaneously join multicast\n *   (c) render from unicast during join\n *   (d) activate multicast on RAP, suppress unicast\n *   (e) cross-transport FEC repair during transition\n *   (f) hysteresis before switching away from multicast\n *   (g) re-subscribe unicast on sustained failure\n *\n * PIM: manages transport state without inspecting packet contents.\n */\n\nimport {\n  TransportPool,\n  type Subscription,\n  type SubscriptionMode,\n  type AcquireOptions,\n  type DirectSocketHealth,\n  type TransportPoolOptions,\n} from './transport-pool.js'\nimport { fecBlockBudgetMs } from '@blockcast/mmt-fec'\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport type TrackState =\n  | 'idle'\n  | 'unicast'\n  | 'unicast-fallback'\n  | 'joining'\n  | 'multicast'\n  | 'amt'\n  | 'failing'\n\nexport interface TrackSessionConfig {\n  trackName: string\n  trackType: 'video' | 'audio'\n  packetId: number\n  /** FEC interleave depth from catalog (ms). Used for hysteresis timer. */\n  fecInterleaveMs: number\n  /** Explicit catalog jitter/reorder allowance in ms. */\n  fecReorderToleranceMs?: number\n  /** FEC K from catalog. Used for audio worklet latency calculation. */\n  fecK: number\n  /** FEC repair symbols per block (P). NOT symbol size. */\n  fecRepairCount: number\n  /**\n   * Repair symbols per block this receiver actually joined: the sum of\n   * `repairSymbols` over the joined BASE layers, not a count of layers\n   * (draft-ramadan-moq-fec 6.3). A keyframe overlay is a separate FEC instance\n   * and is not included.\n   *\n   * This is runtime join state, not catalog geometry: a receiver on a clean\n   * path joins layer 0 only while a lossy one adds layers, so the catalog's\n   * total P is not what this receiver is receiving. Diagnostics that report P\n   * (the worker snapshot, CMCD `x-bc-fec-p`) must read this.\n   *\n   * Absent when the caller joins no layers explicitly, in which case P_0 is\n   * what was joined. That is an identity on a single-layer track, not a\n   * catalog default: with one layer, P_0 is the total.\n   */\n  joinedRepairCount?: number\n  /** FEC symbol size in bytes (T). Required for WASM decoder OTI. */\n  fecSymbolSize: number\n  /** MoQ repair track name from catalog FEC config. */\n  repairTrackName?: string\n  /** Frame samples from initData parsing (audio-init-parser.ts). */\n  frameSamples?: number\n  /** Audio sample rate from catalog. */\n  sampleRate?: number\n  /** Ordered transport preference: best first. */\n  preferredTransports: SubscriptionMode[]\n  /** Subscription key for multicast/AMT: \"(S,G,port)\". */\n  multicastKey?: string\n  /** MoQ track name for unicast subscription. */\n  moqTrackName?: string\n  /** AMT relay address (if AMT is in preference chain). */\n  amtRelay?: string\n  /** MoQ relay URL (for WebTransport subscription). */\n  moqRelayUrl?: string\n}\n\n// ---------------------------------------------------------------------------\n// PIM callbacks (protocol-independent \u2014 transport state only)\n// ---------------------------------------------------------------------------\n\nexport interface SessionManagerCallbacks {\n  /** Fired on every transport state transition. */\n  onStateChange?(trackName: string, from: TrackState, to: TrackState): void\n  /** Fired to suppress/unsuppress unicast for this track (transport arbitration). */\n  onSuppress?(trackName: string, suppressed: boolean): void\n  /**\n   * Fired when a track sat in `joining` for SessionManager.takeoverDeadlineMs\n   * without a RAP (BLO-9413/D9). The session has already returned to `unicast`\n   * (nothing was suppressed, so nothing to restore) and it keeps its FEC\n   * decoder armed, because the multicast socket is still joined and the router\n   * still admits the stream's symbols. The host should abandon the router-side\n   * attempt (e.g. MediaRouter.failbackToMoq()) so the router stops waiting for\n   * a keyframe that is never coming; it must not dispose the decoder here. The\n   * decoder is released on the next transport edge (unsubscribe, failbackAll,\n   * or transportFailed falling back to unicast) through fec-teardown.\n   */\n  onTakeoverTimeout?(trackName: string): void\n}\n\n// ---------------------------------------------------------------------------\n// MMTP application-layer extension (FEC lifecycle, media resets)\n// ---------------------------------------------------------------------------\n\n/**\n * MMTP track events (discriminated union).\n * Each protocol layer defines its own event union \u2014 MMTP events cover\n * media resets, latency, and FEC lifecycle.\n */\nexport type MmtpTrackEvent =\n  | { type: 'reset' }\n  | { type: 'latency'; latencyMs: number }\n  | { type: 'fec-setup' }\n  | { type: 'fec-teardown' }\n\n/**\n * MMTP application-layer extension of SessionManagerCallbacks.\n * Single onTrackEvent dispatches all MMTP-specific events.\n * PIM consumers use the base SessionManagerCallbacks (no onTrackEvent).\n *\n * IWA can define its own subinterface with its own TrackEvent union\n * (e.g., IwaTrackEvent for socket health, AMT state) using the same pattern.\n */\nexport interface MmtpSessionCallbacks extends SessionManagerCallbacks {\n  onTrackEvent?(trackName: string, event: MmtpTrackEvent, config: TrackSessionConfig): void\n}\n\n/**\n * Loss-hysteresis window covering the signaled FEC block span plus jitter.\n *\n * `fecK` no longer feeds the math; it is still validated as a catalog\n * well-formedness guard and kept in the signature for positional API compat\n * (removal is a follow-up with the next cross-repo pin bump).\n */\nexport function computeFecLossWindowMs(fecInterleaveMs: number, fecK: number, jitterBufferMs?: number): number {\n  return computeFecDeliveryWindowMs({\n    interleaveDepthMs: fecInterleaveMs,\n    sourceSymbols: fecK,\n    jitterBufferMs,\n  })\n}\n\nexport interface FecDeliveryWindowConfig {\n  interleaveDepthMs: number\n  sourceSymbols: number\n  repairSymbols?: number\n  symbolSize?: number\n  mediaUnitsPerSecond?: number\n  bandwidthBps?: number\n  /**\n   * Explicit jitter/reorder allowance in ms, added once to the complete span.\n   * Callers pass their signaled catalog allowance, never a local default.\n   */\n  jitterBufferMs?: number\n}\n\n/**\n * The catalog interleaveDepthMs is the complete FEC block span, including the\n * repair tail. K, P, cadence, and bandwidth must not expand it again. Geometry\n * fields remain accepted for existing callers, but do not feed deadline math.\n */\nexport function computeFecDeliveryWindowMs(\n  config: FecDeliveryWindowConfig,\n): number {\n  const fecInterleaveMs = config.interleaveDepthMs\n  const fecK = config.sourceSymbols\n  if (!Number.isFinite(fecInterleaveMs) || fecInterleaveMs <= 0) {\n    throw new Error(\n      `[TrackSession] fecInterleaveMs=${fecInterleaveMs}. ` +\n      `Derive a positive FEC interleave window from the stream catalog.`\n    )\n  }\n  if (!Number.isFinite(fecK) || fecK <= 0) {\n    throw new Error(\n      `[TrackSession] fecK=${fecK}. ` +\n      `Derive a positive FEC source-symbol count from the stream catalog.`\n    )\n  }\n\n  // Absence stays absent; it does not authorize a synthesized reorder budget.\n  if (config.jitterBufferMs === undefined) return Math.ceil(fecInterleaveMs)\n  return fecBlockBudgetMs(fecInterleaveMs, config.jitterBufferMs)\n}\n\n/** Convert the shared FEC delivery deadline into an integer media timescale. */\nexport function computeFecDeliveryWindowMediaUnits(\n  config: FecDeliveryWindowConfig,\n  timestampTimescale: number,\n): number {\n  if (!Number.isFinite(timestampTimescale) || timestampTimescale <= 0) {\n    throw new Error(\n      `[TrackSession] timestampTimescale=${timestampTimescale}. ` +\n      'Derive a positive media timescale from the container.',\n    )\n  }\n  const deliveryWindow = Math.ceil(\n    computeFecDeliveryWindowMs(config) * timestampTimescale / 1000,\n  )\n  if (!Number.isSafeInteger(deliveryWindow)) {\n    throw new Error('[TrackSession] FEC delivery window exceeds the media timestamp range.')\n  }\n  return deliveryWindow\n}\n\n// ---------------------------------------------------------------------------\n// TrackSession\n// ---------------------------------------------------------------------------\n\nexport class TrackSession {\n  readonly config: TrackSessionConfig\n  #state: TrackState = 'idle'\n  #subscription: Subscription | null = null\n  #hysteresisTimer: ReturnType<typeof setTimeout> | null = null\n  #joinDeadlineTimer: ReturnType<typeof setTimeout> | null = null\n  #previousPrimary: SubscriptionMode | null = null\n  #manager: SessionManager\n  // Single suppression authority flag (BLO-9413 failback coherence): every\n  // suppress this session fires is recorded here, and every path that leaves\n  // a suppressed state unwinds through #unsuppress(). Before this flag,\n  // unsubscribe() only un-suppressed from multicast/amt \u2014 a session torn down\n  // from `failing` (exactly where a starving track sits) was re-subscribed to\n  // unicast with the host's media still muted: MoQ playing into a dead sink.\n  #suppressFired = false\n  // Single FEC authority flag: set by the fec-setup edges (joinStarted,\n  // enterUnicastFallback), cleared by the fec-teardown edge in #transition.\n  // Setup and teardown are paired by construction, so a takeover timeout that\n  // parks the session in `unicast` keeps the decoder the still-joined\n  // transport is feeding, and the later unsubscribe still tears it down.\n  #fecArmed = false\n\n  constructor(config: TrackSessionConfig, manager: SessionManager) {\n    this.config = config\n    this.#manager = manager\n  }\n\n  // -----------------------------------------------------------------------\n  // State\n  // -----------------------------------------------------------------------\n\n  get state(): TrackState { return this.#state }\n  get subscription(): Subscription | null { return this.#subscription }\n\n  /** True while this session's onSuppress(true) is outstanding (no matching\n   *  onSuppress(false) yet). Test/assertion surface for failback coherence. */\n  get isSuppressed(): boolean { return this.#suppressFired }\n\n  /** Current active transport mode, or null if idle. */\n  get transport(): SubscriptionMode | null {\n    switch (this.#state) {\n      case 'multicast': return 'multicast'\n      case 'amt': return 'amt'\n      case 'unicast': return 'moq'\n      case 'unicast-fallback': return 'moq' // SSM bridge absent \u2014 MoQ unicast is the only source\n      case 'joining': return 'moq' // MoQ still primary during join\n      case 'failing': return this.#previousPrimary\n      default: return null\n    }\n  }\n\n  // -----------------------------------------------------------------------\n  // Computed (no magic numbers)\n  // -----------------------------------------------------------------------\n\n  /** Audio worklet latency: max(fecInterleaveMs, frameDurationMs * fecK).\n   *  Returns undefined if frame duration unknown (no initData). */\n  get audioLatencyMs(): number | undefined {\n    const fd = this.frameDurationMs\n    if (fd === undefined) {\n      return this.config.fecInterleaveMs > 0 ? this.config.fecInterleaveMs : undefined\n    }\n    return Math.max(this.config.fecInterleaveMs, fd * this.config.fecK)\n  }\n\n  /** Frame duration in ms, derived from frameSamples + sampleRate. */\n  get frameDurationMs(): number | undefined {\n    const { frameSamples, sampleRate } = this.config\n    if (!frameSamples || !sampleRate || sampleRate <= 0) return undefined\n    return (frameSamples / sampleRate) * 1000\n  }\n\n  // -----------------------------------------------------------------------\n  // Transitions (Patent Claim 9)\n  // -----------------------------------------------------------------------\n\n  /** idle \u2192 unicast: player subscribes to this track. */\n  subscribe(): void {\n    if (this.#state !== 'idle') return\n    this.#transition('unicast')\n\n    // Emit audio latency on first subscribe\n    if (this.config.trackType === 'audio') {\n      const latency = this.audioLatencyMs\n      if (latency !== undefined) {\n        this.#manager.mmtp?.onTrackEvent?.(this.config.trackName, { type: 'latency', latencyMs: latency }, this.config)\n      }\n    }\n  }\n\n  /** unicast \u2192 joining: multicast/AMT capability detected, join in progress. */\n  joinStarted(): void {\n    if (this.#state !== 'unicast') return\n    this.#transition('joining')\n    // FEC decoders must be ready before multicast data arrives (Claim 9e:\n    // cross-transport repair). A session re-joining after a takeover timeout\n    // still owns its decoder, so fec-setup fires once per FEC epoch.\n    this.#armFec()\n  }\n\n  /**\n   * any non-fallback state \u2192 unicast-fallback. Used when the SSM bridge is\n   * absent (vanilla Chromium / no extension) and the host falls back to a\n   * MoQ unicast subscription per track. Terminal-ish: activateMulticast,\n   * failbackAll, and transportFailed are no-ops while in this state.\n   *\n   * Fires fec-setup so the per-track repair worker spins up \u2014 repair packets\n   * still flow over the MoQ repair-track subscription, so FEC source+repair\n   * can converge as in the multicast path.\n   *\n   * Audio latency is NOT re-emitted here: subscribe() already fires latency\n   * once on the idle \u2192 unicast edge, and enterUnicastFallback is only ever\n   * reached from a non-idle state (SessionManager skips idle sessions).\n   */\n  enterUnicastFallback(): void {\n    if (this.#state === 'unicast-fallback') return\n    this.#clearHysteresis()\n    this.#transition('unicast-fallback')\n    // Suppress the redundant unicast media decoder. On the no-bridge path the\n    // host feeds MoQ-unicast source packets into MulticastManager (the render\n    // consumer); a second base-media subscribe (the @moq/watch decoder) would\n    // split the single connection's QUIC flow-control budget and stall delivery\n    // (BLO-8969). Fire suppress here, on the fallback edge, so the decoder is\n    // gated off before it subscribes rather than after the relay forward task\n    // has already wedged.\n    this.#suppress()\n    this.#armFec()\n  }\n\n  /**\n   * unicast-fallback \u2192 unicast. Called when the SSM bridge appears mid-session\n   * (extension installed after fallback engaged). Host first aborts the fallback\n   * drainers, then transitions sessions back to unicast so the regular\n   * multicast/AMT preference chain can take over via joinStarted().\n   */\n  exitUnicastFallback(): void {\n    if (this.#state !== 'unicast-fallback') return\n    this.#transition('unicast')\n    // Un-suppress the unicast decoder: the bridge appeared mid-session, so the\n    // host tears down the fallback drainers and the regular preference chain\n    // (joinStarted -> joining -> rapReceived) will re-suppress on multicast RAP.\n    this.#unsuppress()\n  }\n\n  /**\n   * joining \u2192 multicast or amt: RAP received on the joined transport (Claim 9d).\n   * Resets audio worklet, then suppresses MoQ.\n   */\n  rapReceived(mode: 'multicast' | 'amt'): void {\n    if (this.#state !== 'joining') return\n    this.#previousPrimary = mode\n    this.#transition(mode)\n    if (this.config.trackType === 'audio') {\n      this.#manager.mmtp?.onTrackEvent?.(this.config.trackName, { type: 'reset' }, this.config)\n    }\n    this.#suppress()\n  }\n\n  /** multicast/amt \u2192 failing: loss detected, start hysteresis timer (Claim 9f). */\n  lossDetected(): void {\n    if (this.#state !== 'multicast' && this.#state !== 'amt') return\n    this.#previousPrimary = this.#state as SubscriptionMode\n    this.#transition('failing')\n\n    // Hysteresis timer: sustained loss before failback (Claim 9f). Use the\n    // same complete span plus explicit allowance as FECManager and workers.\n    const hysteresisMs = computeFecLossWindowMs(\n      this.config.fecInterleaveMs,\n      this.config.fecK,\n      this.config.fecReorderToleranceMs,\n    )\n    this.#hysteresisTimer = setTimeout(() => {\n      this.hysteresisExpired()\n    }, hysteresisMs)\n  }\n\n  /** failing \u2192 previous primary: loss recovered within hysteresis window. */\n  lossRecovered(): void {\n    if (this.#state !== 'failing') return\n    this.#clearHysteresis()\n    if (this.#previousPrimary) {\n      this.#transition(this.#previousPrimary as TrackState)\n    }\n  }\n\n  /**\n   * Transport failed (AMT relay down, multicast interface gone).\n   * Try next transport in preference chain.\n   */\n  transportFailed(): void {\n    this.#clearHysteresis()\n    // Unicast-fallback is terminal: the host owns the subscription and\n    // SessionManager transport machinery does not arbitrate it.\n    if (this.#state === 'unicast-fallback') return\n    const current = this.#previousPrimary ?? this.transport\n    const prefs = this.config.preferredTransports\n    const currentIdx = current ? prefs.indexOf(current) : -1\n    const nextMode = prefs[currentIdx + 1]\n\n    if (nextMode !== undefined && nextMode !== 'moq') {\n      // Next is multicast or AMT: start joining. `joining` means MoQ is\n      // primary again (see transport getter), so if the failed transport had\n      // suppressed unicast, restore it for the join window or the viewer\n      // watches black video until the next RAP (which may never come).\n      // The chain position moves with the attempt: a join that times out\n      // parks the session in `unicast` with this transport recorded, so the\n      // next failure continues past it rather than re-trying the transport\n      // that already failed and re-firing onTakeoverTimeout on every lap.\n      this.#previousPrimary = nextMode\n      this.#transition('joining')\n      this.#unsuppress()\n      return\n    }\n    // MoQ is next, or the chain is exhausted: unicast either way (Claim 9g).\n    // For a session parked in `unicast` with its decoder retained after a\n    // takeover timeout, this transition is a self-edge and fires no teardown,\n    // so the release is explicit. It is the \"transportFailed falling back to\n    // unicast\" release path the onTakeoverTimeout doc names, and #disarmFec is\n    // idempotent, so it is a no-op when the transition already fired the\n    // teardown. The audio reset is not flag-guarded, so it is tied to the edge\n    // itself: a session already resting in unicast changed no transport and\n    // owes the host no reset, however many pool subscriptions fail for it.\n    const from = this.#state\n    this.#previousPrimary = null\n    this.#transition('unicast')\n    this.#disarmFec()\n    this.#unsuppress()\n    if (from !== 'unicast' && this.config.trackType === 'audio') {\n      this.#manager.mmtp?.onTrackEvent?.(this.config.trackName, { type: 'reset' }, this.config)\n    }\n  }\n\n  /** Hysteresis expired \u2192 failback to next transport (Claim 9g). */\n  hysteresisExpired(): void {\n    if (this.#state !== 'failing') return\n    this.#clearHysteresis()\n    this.transportFailed()\n  }\n\n  /** \u2192 idle: player unsubscribes / tab close / cleanup. */\n  unsubscribe(): void {\n    this.#clearHysteresis()\n    if (this.#state !== 'idle') {\n      this.#transition('idle')\n      // Unwind any outstanding suppression regardless of which state we left.\n      // The old `wasActive` check (multicast/amt only) leaked suppression when\n      // tearing down from `failing` or `unicast-fallback` \u2014 failbackAll()'s\n      // unsubscribe\u2192subscribe cycle then re-entered unicast with the host's\n      // media still muted (BLO-9413 freeze: \"failing back\" logged, video dead).\n      this.#unsuppress()\n    }\n  }\n\n  /** True when SessionManager.enterUnicastFallback put this track into the\n   *  host-driven unicast subscription mode. Host can iterate sessions to\n   *  decide whether to keep its fallback drainer alive across MediaRouter\n   *  arbitration events. */\n  get isUnicastFallback(): boolean {\n    return this.#state === 'unicast-fallback'\n  }\n\n  /**\n   * True while this track owns a FEC decoder (fec-setup fired, fec-teardown\n   * not yet). Stays true across a takeover timeout that parked the session in\n   * `unicast`; SessionManager.failbackAll uses it to release such sessions.\n   */\n  get isFecArmed(): boolean {\n    return this.#fecArmed\n  }\n\n  /**\n   * Start the deadline a `joining` entry deferred while the join was inactive\n   * (SessionManager.joinActive). The track gets the FULL deadline from here,\n   * because that is when media can first arrive. No-op outside `joining` and\n   * when a deadline is already running, so it never shortens or restarts one.\n   *\n   * The `joinActive` guard is what makes this safe to call from anywhere: a\n   * track parked in `joining` with a deferred (null) timer satisfies the other\n   * two, so without it a host calling this while the join is still inactive\n   * would arm the exact deadline the gate exists to defer -- silently\n   * reinstating BLO-34289. It is a no-op for the internal caller, which writes\n   * `#joinActive = true` before iterating the sessions.\n   */\n  armDeferredJoinDeadline(): void {\n    if (this.#state !== 'joining' || this.#joinDeadlineTimer !== null) return\n    if (!this.#manager.joinActive) return\n    this.#armJoinDeadline(this.#manager.takeoverDeadlineMs)\n  }\n\n  dispose(): void {\n    this.#clearHysteresis()\n    this.#clearJoinDeadline()\n    this.#state = 'idle'\n    this.#subscription = null\n    // Release through the teardown edge, not a bare assignment: the\n    // retained-FEC park makes `unicast` + isFecArmed a resting state, and\n    // SessionManager.dispose() calls this directly (removeTrack() reaches it\n    // via unsubscribe(), which has already disarmed). A bare assignment there\n    // drops the host's decoder without a fec-teardown -- a leaked Worker.\n    this.#disarmFec()\n  }\n\n  // -----------------------------------------------------------------------\n  // Internal\n  // -----------------------------------------------------------------------\n\n  #transition(to: TrackState, opts?: { retainFec?: boolean }): void {\n    const from = this.#state\n    if (from === to) return\n    // Takeover deadline (BLO-9413/D9): every entry into `joining` arms it\n    // (joinStarted AND transportFailed-failover both route through here);\n    // every exit cancels it. Without this, a transport that accepts the\n    // subscribe but never delivers a RAP parks the session in `joining`\n    // forever (observed live in the Phase-0 headless repro). The value is\n    // resolved before any state write, so the one residual failure -- a\n    // manager whose deadline was never set at all, which addTrack() refuses --\n    // leaves the session in its previous state rather than half-transitioned.\n    // Invalid values never reach here: SessionManager's setter refuses them.\n    // The read is unconditional even when `joinActive` defers the arm, so a\n    // manager without a deadline still fails closed on every joining edge.\n    const joinDeadlineMs = to === 'joining' ? this.#manager.takeoverDeadlineMs : undefined\n    this.#state = to\n    if (from === 'joining') this.#clearJoinDeadline()\n    if (joinDeadlineMs !== undefined && this.#manager.joinActive) {\n      this.#armJoinDeadline(joinDeadlineMs)\n    }\n    // FEC teardown: entering a state without a FEC decoder releases the one\n    // this track armed, unless the caller keeps it (takeover timeout: the\n    // transport is still joined and still feeding the decoder).\n    const fecActive = (s: TrackState) =>\n      s === 'joining' ||\n      s === 'multicast' ||\n      s === 'amt' ||\n      s === 'failing' ||\n      s === 'unicast-fallback'\n    if (!fecActive(to) && !opts?.retainFec) this.#disarmFec()\n    this.#manager.callbacks?.onStateChange?.(this.config.trackName, from, to)\n  }\n\n  #clearHysteresis(): void {\n    if (this.#hysteresisTimer !== null) {\n      clearTimeout(this.#hysteresisTimer)\n      this.#hysteresisTimer = null\n    }\n  }\n\n  #armJoinDeadline(deadlineMs: number): void {\n    this.#clearJoinDeadline()\n    if (deadlineMs === 0) return // a declared 0 disables the deadline\n    this.#joinDeadlineTimer = setTimeout(() => {\n      this.#joinDeadlineTimer = null\n      if (this.#state !== 'joining') return\n      // No RAP within the deadline: return to unicast for arbitration only.\n      // MoQ was never suppressed in `joining`, so there is nothing to restore\n      // and this edge stays silent on onSuppress (asserted in tests). The\n      // multicast socket is still joined and the router still admits this\n      // stream's symbols, so the FEC decoder stays armed; the next transport\n      // edge releases it.\n      this.#transition('unicast', { retainFec: true })\n      this.#manager.callbacks?.onTakeoverTimeout?.(this.config.trackName)\n    }, deadlineMs)\n  }\n\n  #clearJoinDeadline(): void {\n    if (this.#joinDeadlineTimer !== null) {\n      clearTimeout(this.#joinDeadlineTimer)\n      this.#joinDeadlineTimer = null\n    }\n  }\n\n  /** Fire fec-setup exactly once per FEC epoch. */\n  #armFec(): void {\n    if (this.#fecArmed) return\n    this.#fecArmed = true\n    this.#manager.mmtp?.onTrackEvent?.(this.config.trackName, { type: 'fec-setup' }, this.config)\n  }\n\n  /** Fire fec-teardown for an armed decoder; no-op when none is armed. */\n  #disarmFec(): void {\n    if (!this.#fecArmed) return\n    this.#fecArmed = false\n    this.#manager.mmtp?.onTrackEvent?.(this.config.trackName, { type: 'fec-teardown' }, this.config)\n  }\n\n  /** Fire onSuppress(true) exactly once per suppression epoch. */\n  #suppress(): void {\n    if (this.#suppressFired) return\n    this.#suppressFired = true\n    this.#manager.callbacks?.onSuppress?.(this.config.trackName, true)\n  }\n\n  /** Unwind an outstanding suppression; no-op when none is outstanding. */\n  #unsuppress(): void {\n    if (!this.#suppressFired) return\n    this.#suppressFired = false\n    this.#manager.callbacks?.onSuppress?.(this.config.trackName, false)\n  }\n}\n\n// ---------------------------------------------------------------------------\n// SessionManager\n// ---------------------------------------------------------------------------\n\n/**\n * Largest takeover deadline setTimeout represents faithfully. setTimeout\n * coerces its delay to a signed 32-bit int, so a larger value fires on the\n * next tick (Node also warns TimeoutOverflowWarning) instead of after the\n * window the host asked for -- silently inverting the feature. Rejecting it\n * keeps the classic units bug (seconds-as-ms, a wrong timescale) loud.\n */\nexport const MAX_TAKEOVER_DEADLINE_MS = 2_147_483_647\n\n/**\n * How long `joinActive` may stay false before the library says so. The deferral\n * is unbounded by construction -- that is the feature -- so a host that never\n * flips it back parks every track in `joining` with no timer at all: exactly the\n * forever-join the takeover deadline exists to prevent, only silent. MoQ stays\n * unsuppressed so the viewer sees video, but onTakeoverTimeout never fires, the\n * FEC decoder stays armed, and the preference chain never advances past the\n * transport that failed. It looks like a slow join. A host is one un-awaited\n * rejection between `false` and `true` away from it, so the library complains\n * rather than trusting every future host to get all of its exit paths right.\n *\n * Generous against a genuinely slow subscribe -- a bridge reconnect or AMT relay\n * handshake is seconds -- so anything still unsettled here is broken, not slow.\n */\nexport const JOIN_DEFER_WARN_MS = 30_000\n\nexport class SessionManager {\n  readonly pool: TransportPool\n  readonly sessions = new Map<string, TrackSession>()\n  callbacks: SessionManagerCallbacks | null = null\n  #takeoverDeadlineMs: number | undefined = undefined\n  #joinActive = true\n  #joinDeferWarnTimer: ReturnType<typeof setTimeout> | null = null\n\n  /**\n   * Takeover deadline (BLO-9413/D9): the time a session may sit in `joining`\n   * without a RAP before returning to `unicast` and firing onTakeoverTimeout.\n   * MoQ is never suppressed during `joining`, so expiry abandons the takeover\n   * without a playback glitch. The host derives it from the catalog (RAP\n   * cadence from groupDurationTicks/timescale plus the signaled FEC delivery\n   * window or reorder tolerance) and sets it before addTrack(). There is no\n   * default: an unset value fails addTrack() closed, and reading the getter\n   * before assignment throws the same way, so no host ever holds a\n   * `number | undefined` it could coalesce back into a default.\n   * `hasTakeoverDeadline` answers whether one was admitted. A declared 0\n   * disables the deadline. The value is an integer number of milliseconds:\n   * setTimeout truncates fractions, so a host that divides ticks by a\n   * timescale must round before assigning.\n   *\n   * Assignment validates, so the diagnostic lands at the host's own call site.\n   * That is what bounds the blast radius: `joining` is entered from\n   * joinStarted(), from the transportFailed() failover branch -- itself\n   * reachable from a setTimeout via hysteresisExpired(), where no caller could\n   * catch a throw -- and from the activateMulticast()/activateAmt()/pool-failure\n   * loops, where a throw on one session would abandon its siblings mid-loop\n   * (the split-brain those loops exist to prevent). Refusing a bad value at\n   * assignment means no host mutation can make an already-admitted session\n   * throw out of a transport edge.\n   */\n  get takeoverDeadlineMs(): number {\n    return this.#requireTakeoverDeadlineMs()\n  }\n\n  set takeoverDeadlineMs(value: number) {\n    if (!Number.isInteger(value) || value < 0 || value > MAX_TAKEOVER_DEADLINE_MS) {\n      throw new Error(\n        `[SessionManager] takeoverDeadlineMs must be an integer from 0 to ${MAX_TAKEOVER_DEADLINE_MS} (0 disables it, larger values overflow setTimeout); got ${String(value)}`,\n      )\n    }\n    this.#takeoverDeadlineMs = value\n  }\n\n  /** True once the host has admitted a deadline; a declared 0 counts. */\n  get hasTakeoverDeadline(): boolean {\n    return this.#takeoverDeadlineMs !== undefined\n  }\n\n  /**\n   * Whether the transport the joining tracks are waiting on is actually\n   * subscribed. The takeover deadline is a media-arrival budget and media\n   * cannot arrive before the join exists, so while this is false, entering\n   * `joining` arms no deadline; flipping it true starts the FULL deadline for\n   * every track already parked there.\n   *\n   * Default true, which is the arm-on-`joining` behaviour every host had\n   * before: a host that only calls joinStarted() after its own join resolves\n   * (moqtail-private's player, post-BLO-33339) is already at the right edge and\n   * needs no gate. A host that arms joinStarted() up front \u2014 to have FEC\n   * decoders ready before the first datagram \u2014 sets this false before addTrack()\n   * and true when its subscribe settles. Charging a slow subscribe (bridge\n   * reconnect, AMT relay handshake) against the media budget expired the\n   * deadline before the subscription existed and abandoned the join on the\n   * happy path. BLO-34289.\n   *\n   * The flag tracks the host's primary join, not per-track transport state. A\n   * track that fails over to the next transport in its own chain while this is\n   * false (transportFailed's failover branch also enters `joining`) has that\n   * deadline gated on the primary join activating, not on its own transport.\n   * Under the documented usage -- false once at setup, true once the subscribe\n   * settles -- the two coincide.\n   *\n   * The gate is on the ENTRY into `joining`, and false cannot take back a\n   * deadline already running: the `true -> false` edge arms the warn below and\n   * clears nothing. So set it false BEFORE the `joining` entry it is meant to\n   * gate. A host that instead flipped it false after a `transportFailed()`\n   * failover had already entered `joining` would leave the full deadline\n   * counting against a subscribe that had not begun -- BLO-34289 again, on the\n   * failover edge. Clearing running deadlines on that edge is deliberately NOT\n   * done: this flag is manager-wide, so one transport's brief false would\n   * cancel an unrelated track's live deadline and then re-arm it at FULL length\n   * on the next activation (armDeferredJoinDeadline sees `joining` + a null\n   * timer and cannot tell a cleared deadline from a deferred one). Every\n   * unrelated transport blip would restart the whole budget, so under repeated\n   * failover a track that should have timed out is extended indefinitely and\n   * never advances. Only a false that never returns true loses the timer\n   * outright, and JOIN_DEFER_WARN_MS already covers that.\n   *\n   * Leaving this false is not free: see JOIN_DEFER_WARN_MS.\n   */\n  get joinActive(): boolean {\n    return this.#joinActive\n  }\n\n  set joinActive(active: boolean) {\n    const wasActive = this.#joinActive\n    this.#joinActive = active\n    if (!active) {\n      // Edge-triggered: a host re-declaring false has not restarted its\n      // subscribe, and total deferral is what the warning is about.\n      if (wasActive) this.#armJoinDeferWarn()\n      return\n    }\n    this.#clearJoinDeferWarn()\n    if (wasActive) return\n    for (const [, session] of this.sessions) session.armDeferredJoinDeadline()\n  }\n\n  #armJoinDeferWarn(): void {\n    this.#joinDeferWarnTimer = setTimeout(() => {\n      this.#joinDeferWarnTimer = null\n      const deferred = [...this.sessions.values()].filter(s => s.state === 'joining').length\n      console.warn(\n        `[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.`,\n      )\n    }, JOIN_DEFER_WARN_MS)\n  }\n\n  #clearJoinDeferWarn(): void {\n    if (this.#joinDeferWarnTimer === null) return\n    clearTimeout(this.#joinDeferWarnTimer)\n    this.#joinDeferWarnTimer = null\n  }\n\n  /** Narrow to MMTP callbacks (onTrackEvent). Safe \u2014 optional chaining handles PIM-only consumers. */\n  get mmtp(): MmtpSessionCallbacks | null {\n    return this.callbacks as MmtpSessionCallbacks | null\n  }\n\n  constructor(poolOptions?: TransportPoolOptions) {\n    this.pool = new TransportPool(poolOptions)\n\n    // Wire pool failure \u2192 per-track failover\n    this.pool.onSubscriptionFailed(sub => {\n      for (const trackName of sub.consumers) {\n        const session = this.sessions.get(trackName)\n        if (session) session.transportFailed()\n      }\n    })\n  }\n\n  // -----------------------------------------------------------------------\n  // Track management\n  // -----------------------------------------------------------------------\n\n  /**\n   * The admitted takeover deadline. Throws only when the host never set one,\n   * every other invalid value being refused by the setter, and returns a\n   * declared 0 as 0. The getter and addTrack() both route through it, so a\n   * session cannot exist without an admitted deadline, which is what makes\n   * the #transition() read unable to throw on an already-admitted session.\n   */\n  #requireTakeoverDeadlineMs(): number {\n    const value = this.#takeoverDeadlineMs\n    if (value === undefined) {\n      throw new Error(\n        '[SessionManager] takeoverDeadlineMs is unset; set a catalog-derived takeover deadline (0 disables it) before adding tracks',\n      )\n    }\n    return value\n  }\n\n  /** Add a track session from catalog config. */\n  addTrack(config: TrackSessionConfig): TrackSession {\n    if (this.sessions.has(config.trackName)) {\n      throw new Error(`[SessionManager] Track \"${config.trackName}\" already exists`)\n    }\n    this.#requireTakeoverDeadlineMs()\n    const session = new TrackSession(config, this)\n    this.sessions.set(config.trackName, session)\n    return session\n  }\n\n  /** Remove a track session. Releases subscription with grace period. */\n  removeTrack(trackName: string): void {\n    const session = this.sessions.get(trackName)\n    if (!session) return\n    session.unsubscribe()\n\n    // Release pool subscription\n    const subKey = session.config.multicastKey ?? session.config.moqTrackName\n    if (subKey) this.pool.releaseSubscription(subKey, trackName)\n\n    session.dispose()\n    this.sessions.delete(trackName)\n  }\n\n  // -----------------------------------------------------------------------\n  // Atomic multi-track operations\n  // -----------------------------------------------------------------------\n\n  /**\n   * All tracks with multicast RAP \u2192 multicast state (atomic).\n   * Called when MediaRouter fires onSourceSwitch('multicast').\n   * Prevents split-brain between video and audio.\n   *\n   * A takeover deadline can return a track from `joining` to `unicast` while\n   * the multicast socket keeps delivering packets and the track keeps its FEC\n   * decoder armed. If a valid RAP arrives later, that late-RAP edge suppresses\n   * unicast and promotes multicast without a second fec-setup.\n   */\n  activateMulticast(): void {\n    for (const [, session] of this.sessions) {\n      if (session.state === 'unicast') {\n        session.joinStarted()\n      }\n      if (session.state === 'joining') {\n        session.rapReceived('multicast')\n      }\n    }\n  }\n\n  /**\n   * All tracks with AMT RAP \u2192 amt state (atomic).\n   */\n  activateAmt(): void {\n    for (const [, session] of this.sessions) {\n      if (session.state === 'unicast') {\n        session.joinStarted()\n      }\n      if (session.state === 'joining') {\n        session.rapReceived('amt')\n      }\n    }\n  }\n\n  /**\n   * All tracks \u2192 unicast (failback, atomic).\n   * Called when MulticastManager fires onFailback().\n   * unicast-fallback sessions are skipped \u2014 the host owns those subscriptions\n   * and they must drain uninterrupted across transport-state events.\n   *\n   * Coherence invariant (BLO-9413): after this returns, every non-fallback\n   * session is `unicast` (or `idle`), unsuppressed, and without a FEC decoder.\n   * unsubscribe() unwinds any outstanding suppression regardless of the state\n   * it tears down from (`failing` included; see TrackSession.#suppressFired),\n   * and a session that a takeover timeout parked in `unicast` with its decoder\n   * still armed is cycled too, because this transport edge is what releases\n   * that decoder (unsubscribe fires fec-teardown).\n   */\n  failbackAll(): void {\n    for (const [, session] of this.sessions) {\n      const parkedWithFec = session.state === 'unicast' && session.isFecArmed\n      if (\n        parkedWithFec ||\n        (session.state !== 'idle' &&\n          session.state !== 'unicast' &&\n          session.state !== 'unicast-fallback')\n      ) {\n        session.unsubscribe()\n        session.subscribe() // re-enter unicast\n      }\n    }\n  }\n\n  /**\n   * All tracks \u2192 unicast-fallback (atomic).\n   * Called by the host when the multicast gateway is absent and\n   * the player will subscribe to source tracks over MoQ unicast and feed\n   * packets via MulticastManager.feedUnicastSource() (or manager.router\n   * directly). Sessions in this state stay terminal until the host calls\n   * unsubscribe() / disposes the SessionManager.\n   */\n  enterUnicastFallback(): void {\n    for (const [, session] of this.sessions) {\n      if (session.state === 'idle') continue\n      session.enterUnicastFallback()\n    }\n  }\n\n  /**\n   * True if any session is currently in unicast-fallback. Hosts use this to\n   * gate `multicastTrack.close()` on failback events \u2014 closing the shared\n   * broadcast would kill the host's fallback drainers.\n   */\n  hasActiveFallback(): boolean {\n    for (const [, session] of this.sessions) {\n      if (session.isUnicastFallback) return true\n    }\n    return false\n  }\n\n  /**\n   * All fallback tracks \u2192 unicast (atomic).\n   * Called when the SSM bridge appears mid-session and the host has aborted\n   * the fallback drainers. The session re-enters the regular preference chain\n   * via joinStarted() (issued by the host immediately after).\n   */\n  exitUnicastFallback(): void {\n    for (const [, session] of this.sessions) {\n      if (session.isUnicastFallback) session.exitUnicastFallback()\n    }\n  }\n\n  // -----------------------------------------------------------------------\n  // Cleanup lifecycle\n  // -----------------------------------------------------------------------\n\n  /** Tab closed \u2014 release all subscriptions for this tab (grace period). */\n  tabClosed(tabId: string): void {\n    // All tracks owned by this tab \u2192 idle\n    for (const [trackName, session] of this.sessions) {\n      session.unsubscribe()\n      this.pool.releaseAllForConsumer(trackName)\n    }\n  }\n\n  /** Bridge WebTransport connection dropped \u2014 same as tab close. */\n  bridgeDisconnected(): void {\n    this.tabClosed('bridge')\n  }\n\n  /**\n   * Track selection changed (user or ABR).\n   * Old track released (grace period), new track subscribed.\n   */\n  trackSelectionChanged(oldTrackName: string, newConfig: TrackSessionConfig): void {\n    this.removeTrack(oldTrackName)\n    const session = this.addTrack(newConfig)\n    session.subscribe()\n  }\n\n  // -----------------------------------------------------------------------\n  // Query\n  // -----------------------------------------------------------------------\n\n  /** Get a track session by name. */\n  getTrack(trackName: string): TrackSession | undefined {\n    return this.sessions.get(trackName)\n  }\n\n  // -----------------------------------------------------------------------\n  // Cleanup\n  // -----------------------------------------------------------------------\n\n  dispose(): void {\n    this.#clearJoinDeferWarn()\n    for (const [, session] of this.sessions) {\n      session.dispose()\n    }\n    this.sessions.clear()\n    this.pool.dispose()\n    this.callbacks = null\n  }\n}\n", "/**\n * MediaRouter \u2014 source arbitration for MoQ \u2194 multicast switching.\n *\n * Both moq-lib and moqtail wire their MoQ and multicast frame outputs\n * through this router. The router decides which source reaches the decoder:\n *\n *   - MoQ frames pass through while multicast is inactive.\n *   - Multicast video frames are suppressed until the first keyframe.\n *   - Once multicast has both a video keyframe and audio, takeover is requested.\n *   - MoQ is suppressed only after the source-switch callback completes.\n *   - failbackToMoq() reverses the switch immediately.\n *\n * Per-track setTrackSource() allows individual tracks to be wired to a\n * specific transport source (video=multicast, audio=moq, overlay=amt) without\n * changing the binary MoQ\u2194multicast switching for other tracks.\n */\n\nimport { computeFecDeliveryWindowMs } from './track-session.js'\n\nexport type FrameMeta = {\n  timestamp: number\n  keyframe: boolean\n  packetId?: number\n  packetSequenceNumber?: number\n  source?: 'moq' | 'multicast' | 'repair'\n  recovered?: boolean\n  sourceDiscontinuity?: boolean\n  /**\n   * Raw MMTP header timestamp (RFC 5905 short NTP, 32 bits): the publisher's\n   * send-wall clock for the packet that carried this frame. On timed media it\n   * is distinct from `timestamp`, the authored media presentation time. On a\n   * non-timed MFU there is no authored presentation time, so `MmtpRouter`\n   * derives `timestamp` from this same clock and the two carry no latency\n   * between them. Populated from `RoutedFrameMeta.mmtpTimestamp` and\n   * preserved by every re-emit on this router (multicast, MoQ, and repair) so\n   * players can measure network ingress on the multicast legs; absent when\n   * the packet header could not be read.\n   */\n  mmtpTimestamp?: bigint\n}\nexport type FrameKind = 'video' | 'audio'\nexport type SourceKind = 'moq' | 'multicast'\n\ntype FrameCb = (data: Uint8Array, meta: FrameMeta) => void\ntype SwitchCb = (source: SourceKind) => void | Promise<void>\n\nexport interface MediaRouterOptions {\n  /** Set false for video-only streams. Default: true. */\n  requireAudio?: boolean\n  /**\n   * Audio fallback timeout (ms): force multicast activation if video keyframe\n   * arrived but audio hasn't within this window. Catalog-derived via\n   * computeFecDeliveryWindowMs (the single FEC recovery-window source of truth).\n   * Omit to disable the independent audio-fallback timer (no magic default).\n   */\n  audioFallbackMs?: number\n  /**\n   * Number of binary-path frames to allow through during a crossfade transition.\n   * Derive from FEC block size (e.g., ceil(K / groupsPerBlock)). Default: 10.\n   */\n  crossfadeFrames?: number\n  /**\n   * Max pre-boundary overlay frames to buffer before dropping.\n   * Derive from FEC config (e.g., ceil(K * 1.5)). Default: 128.\n   */\n  maxOverlayBuffer?: number\n  /**\n   * Max concurrent in-flight repairs. Prevents relay SUBSCRIBE flood (T-13-01 mitigation).\n   * Default: 2.\n   */\n  maxRepairInFlight?: number\n  /**\n   * Allow multicast takeover from a delta frame after the player has confirmed\n   * that MoQ already seeded the same decoder timeline with a video keyframe.\n   * Default false: decoder-reset paths still need multicast to provide a RAP.\n   */\n  allowDeltaMulticastTakeoverAfterMoqKeyframe?: boolean\n}\n\n/**\n * A per-track source that emits frames independently of the binary MoQ/multicast path.\n * Used by setTrackSource() to wire specific tracks to specific transport sources.\n */\nexport interface TrackSource {\n  name: string\n  /**\n   * Register a frame callback. Returns an unsubscribe function.\n   * MediaRouter calls unsubscribe() when clearTrackSource() is called.\n   */\n  onFrame(cb: (data: Uint8Array, meta: FrameMeta) => void): () => void\n  /**\n   * Optional error callback for when the source fails.\n   * MediaRouter uses this to trigger failback to binary switching for this track.\n   */\n  onError?(cb: () => void): () => void\n  /** Optional dispose hook called when clearTrackSource() is called. */\n  dispose?(): void\n}\n\n/**\n * Thrown when setTrackSource() is called for a track that already has a source\n * without an intervening clearTrackSource(). Prevents silent concurrent-assignment\n * races (T-02-16 mitigation).\n */\nexport class TrackSourceConflictError extends Error {\n  constructor(public readonly trackName: string) {\n    super(`Track source already assigned for '${trackName}'; call clearTrackSource first`)\n    this.name = 'TrackSourceConflictError'\n  }\n}\n\n/**\n * Migration policy for setTrackSource() transport switching.\n *\n * - 'crossfade': Overlap old (binary) and new source briefly (CROSSFADE_WINDOW_FRAMES),\n *   then suppress the binary path. Default for audio.\n * - 'drop':      Cut to new source immediately. Binary path suppressed at once.\n *                Suitable for latency-critical tracks.\n * - 'wait':      Defer migration until first FEC block boundary (same as overlay=true).\n *                Default for video \u2014 avoids decoder reset mid-block.\n */\nexport type MigrationPolicy = 'crossfade' | 'drop' | 'wait'\n\n/** Default crossfade window \u2014 override via MediaRouterOptions.crossfadeFrames. */\nconst DEFAULT_CROSSFADE_FRAMES = 10\n\n/** Options passed to setTrackSource(). */\nexport interface SetTrackSourceOptions {\n  /**\n   * If true, this source is an overlay track that must wait for the first FEC\n   * block boundary signal (via notifyFecBlockBoundary()) before emitting frames.\n   * Frames arriving before the first boundary are buffered up to MAX_OVERLAY_BUFFER.\n   *\n   * Backwards compat: equivalent to policy: 'wait'.\n   */\n  overlay?: boolean\n  /**\n   * Migration policy for the transport switch. Overrides `overlay` when provided.\n   * See MigrationPolicy for semantics.\n   */\n  policy?: MigrationPolicy\n}\n\n/** Default overlay buffer cap \u2014 override via MediaRouterOptions.maxOverlayBuffer. */\nconst DEFAULT_MAX_OVERLAY_BUFFER = 128\n\n/** Internal per-track source record. */\ninterface TrackSourceRecord {\n  source: TrackSource\n  unsubscribeFrame: () => void\n  unsubscribeError?: () => void\n  emitCount: number\n}\n\nexport class MediaRouter {\n  #active: SourceKind = 'moq'\n  #multicastVideoKeyed = false\n  #multicastAudioReceived = false\n  #moqVideoKeyframeEmitted = false\n  #requireAudio: boolean\n  #suppressed = false // true after multicast confirmed \u2014 suppresses MoQ\n  #audioFallbackTimer: ReturnType<typeof setTimeout> | null = null\n\n  // Configurable constants (from catalog/FEC config, not magic numbers)\n  readonly #audioFallbackMs: number\n  readonly #crossfadeFrames: number\n  readonly #maxOverlayBuffer: number\n  readonly #allowDeltaMulticastTakeoverAfterMoqKeyframe: boolean\n\n  // \u2500\u2500 Keyframe repair state \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  /** Groups currently being repaired \u2014 idempotent guard per Pitfall 2 (T-13-01 mitigation) */\n  #repairInFlight = new Set<number>()\n  /** Max concurrent repairs \u2014 prevents relay SUBSCRIBE flood (T-13-01 mitigation) */\n  readonly #maxRepairInFlight: number\n  /** Callback to request MoQ subscribe for a specific group (wired by player) */\n  #onRepairRequest: ((expectedGroupId: number, trackName: string) => void) | null = null\n\n  #onVideoFrame: FrameCb | null = null\n  #onAudioFrame: FrameCb | null = null\n  #onOverlayFrame: FrameCb | null = null\n  #onSourceSwitch: SwitchCb | null = null\n  #sourceSwitchReady: Promise<void> | null = null\n  #sourceSwitchToken = 0\n  #pendingMulticastToken: number | null = null\n  #pendingMulticastVideo: { data: Uint8Array; meta: FrameMeta } | null = null\n  #pendingMulticastAudio: { data: Uint8Array; meta: FrameMeta } | null = null\n\n  // Per-track source state\n  #trackSources = new Map<string, TrackSourceRecord>()\n\n  // Track type registry: trackName \u2192 { type, source }.\n  // Init data / inline signaling is authoritative until catalog updates.\n  // Priority: 'init' > 'catalog' > 'name' (backward compat fallback).\n  #trackTypes = new Map<string, { type: FrameKind; source: 'catalog' | 'init' }>()\n\n  // Crossfade state: maps trackName \u2192 remaining binary-path frames allowed during window\n  #crossfadeCounters = new Map<string, number>()\n\n  // Overlay alignment state\n  #overlayBoundaryReached = false\n  #overlayBuffer: Array<{ data: Uint8Array; meta: FrameMeta }> = []\n\n  // \u2500\u2500 Phase 14: deltaActive state machine (D-11..D-14) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  // No timers \u2014 state transitions driven entirely by notifyDeltaBlock() callbacks.\n  // All thresholds derived from catalog fields or throw at configureDelta() time.\n  #deltaConfigured = false\n  #deltaActive: boolean = true\n  #deltaWindow: boolean[] = []         // ring buffer: true = block failed\n  #deltaWindowSize: number = 0\n  #deltaFailThresholdRatio: number = 0  // P/K\n  #deltaRecoverThresholdRatio: number = 0  // (P/K)/2 \u2014 hysteresis (D-13)\n  #deltaProbeIntervalMs: number = 0\n  #lastProbeAt: number = 0\n  #onDeltaFallbackCb: (() => void) | null = null\n  #onDeltaRecoverCb: (() => void) | null = null\n\n  constructor(options?: MediaRouterOptions) {\n    this.#requireAudio = options?.requireAudio ?? true\n    // Catalog-derived \u2014 the caller passes an audioFallbackMs computed from the\n    // FEC recovery window (computeFecDeliveryWindowMs). No magic default: when\n    // absent, the independent audio-fallback timer is disabled (0) and\n    // activation waits for real audio arrival.\n    this.#audioFallbackMs = options?.audioFallbackMs ?? 0\n    this.#crossfadeFrames = options?.crossfadeFrames ?? DEFAULT_CROSSFADE_FRAMES\n    this.#maxOverlayBuffer = options?.maxOverlayBuffer ?? DEFAULT_MAX_OVERLAY_BUFFER\n    this.#maxRepairInFlight = options?.maxRepairInFlight ?? 2\n    this.#allowDeltaMulticastTakeoverAfterMoqKeyframe =\n      options?.allowDeltaMulticastTakeoverAfterMoqKeyframe ?? false\n  }\n\n  onVideoFrame(cb: FrameCb) { this.#onVideoFrame = cb }\n  onAudioFrame(cb: FrameCb) { this.#onAudioFrame = cb }\n  onOverlayFrame(cb: FrameCb) { this.#onOverlayFrame = cb }\n  onSourceSwitch(cb: SwitchCb) { this.#onSourceSwitch = cb }\n\n  get activeSource(): SourceKind { return this.#active }\n\n  // \u2500\u2500 Keyframe repair API \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  /** Register callback for keyframe repair requests. Player wires this to issue MoQ SUBSCRIBE. */\n  onRepairRequest(cb: (expectedGroupId: number, trackName: string) => void): void {\n    this.#onRepairRequest = cb\n  }\n\n  /**\n   * Request repair for a lost keyframe group. Only fires when activeSource is 'multicast'.\n   * Idempotent per groupId \u2014 duplicate calls for the same group are suppressed.\n   * @param expectedGroupId - The group ID expected but not received\n   * @param trackName - Track name for the SUBSCRIBE (e.g. 'video'). Default: 'video'.\n   */\n  repairLostGroup(expectedGroupId: number, trackName = 'video'): void {\n    if (this.#active !== 'multicast') return // only repair on multicast path\n    if (this.#repairInFlight.has(expectedGroupId)) return // idempotent\n    if (this.#repairInFlight.size >= this.#maxRepairInFlight) {\n      console.warn(\n        `[MediaRouter] max repair in flight (${this.#maxRepairInFlight}), dropping repair for group ${expectedGroupId}`,\n      )\n      return\n    }\n    this.#repairInFlight.add(expectedGroupId)\n    this.#onRepairRequest?.(expectedGroupId, trackName)\n  }\n\n  /**\n   * Feed a recovered keyframe frame from the repair path.\n   * Bypasses source arbitration entirely \u2014 goes directly to decoder callbacks.\n   * Does NOT change activeSource. Does NOT trigger failbackToMoq.\n   */\n  feedRepair(data: Uint8Array, meta: FrameMeta, kind: FrameKind): void {\n    // Repair only makes sense when multicast is active.\n    // Silently drop if MoQ became active (race with failbackToMoq) to avoid\n    // injecting stale-timestamp frames into the MoQ decoder path (WR-02).\n    if (this.#active !== 'multicast') return\n    const routedMeta = { ...meta, source: 'repair' as const, recovered: true }\n    if (kind === 'video') this.#onVideoFrame?.(data, routedMeta)\n    else this.#onAudioFrame?.(data, routedMeta)\n  }\n\n  /**\n   * Clear repair-in-flight state for a group (called after repair completes or times out).\n   */\n  clearRepairInFlight(groupId: number): void {\n    this.#repairInFlight.delete(groupId)\n  }\n\n  // \u2500\u2500 Phase 14: deltaActive state machine API \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  /**\n   * Configure the delta-track fallback state machine from catalog parameters.\n   *\n   * D-11: Thresholds derive from fec.sourceSymbols, fec.repairSymbols, framerate.\n   * D-13: Probe interval derives from deltaProbeIntervalMs or interleaveDepthMs*2.\n   * CLAUDE.md: error on bad init \u2014 throws if required inputs are absent.\n   *\n   * Calling again resets deltaActive=true and clears the window buffer (stream restart).\n   */\n  configureDelta(cfg: {\n    framerate: number\n    sourceSymbols: number\n    repairSymbols: number\n    deltaFailWindowBlocks?: number\n    deltaProbeIntervalMs?: number\n    interleaveDepthMs?: number\n  }): void {\n    if (typeof cfg.framerate !== 'number' || !Number.isFinite(cfg.framerate) || cfg.framerate <= 0) {\n      throw new Error('[MediaRouter] configureDelta: framerate required and must be > 0')\n    }\n    if (typeof cfg.sourceSymbols !== 'number' || cfg.sourceSymbols <= 0) {\n      throw new Error('[MediaRouter] configureDelta: sourceSymbols (K_delta) required and must be > 0')\n    }\n    if (typeof cfg.repairSymbols !== 'number' || cfg.repairSymbols <= 0) {\n      throw new Error('[MediaRouter] configureDelta: repairSymbols (P_delta) required and must be > 0')\n    }\n    if (cfg.deltaProbeIntervalMs === undefined && cfg.interleaveDepthMs === undefined) {\n      throw new Error(\n        '[MediaRouter] configureDelta: either deltaProbeIntervalMs or interleaveDepthMs required for probe interval derivation'\n      )\n    }\n\n    // Derivations \u2014 no magic floors, no hardcoded defaults (CLAUDE.md).\n    this.#deltaWindowSize = cfg.deltaFailWindowBlocks ?? Math.ceil(cfg.framerate)\n    this.#deltaFailThresholdRatio = cfg.repairSymbols / cfg.sourceSymbols\n    this.#deltaRecoverThresholdRatio = this.#deltaFailThresholdRatio / 2\n    // Without an explicit probe interval, use one complete signaled block span.\n    this.#deltaProbeIntervalMs = cfg.deltaProbeIntervalMs ?? computeFecDeliveryWindowMs({\n      interleaveDepthMs: cfg.interleaveDepthMs!,\n      sourceSymbols: cfg.sourceSymbols,\n    })\n\n    // Reset state \u2014 useful for stream restart.\n    this.#deltaActive = true\n    this.#deltaWindow = []\n    this.#lastProbeAt = 0\n    this.#deltaConfigured = true\n  }\n\n  /**\n   * Notify the state machine of a completed FEC block for the delta track.\n   *\n   * @param failed - true if the block was unrecoverable (FEC failure)\n   * @param nowMs  - caller-injected monotonic ms (no internal timer \u2014 D-13, CLAUDE.md)\n   *\n   * If configureDelta() has not been called, this is a silent no-op (pre-catalog state).\n   */\n  notifyDeltaBlock(failed: boolean, nowMs: number): void {\n    if (!this.#deltaConfigured) return\n\n    // Maintain sliding window \u2014 ring buffer semantics.\n    this.#deltaWindow.push(failed)\n    if (this.#deltaWindow.length > this.#deltaWindowSize) {\n      this.#deltaWindow.shift()\n    }\n\n    // Window not yet full \u2014 insufficient data for decision.\n    if (this.#deltaWindow.length < this.#deltaWindowSize) return\n\n    const failedCount = this.#deltaWindow.filter(x => x).length\n    const ratio = failedCount / this.#deltaWindowSize\n\n    if (this.#deltaActive) {\n      // Fallback transition: active \u2192 inactive (T-14-03: fires exactly once)\n      if (ratio > this.#deltaFailThresholdRatio) {\n        this.#deltaActive = false\n        this.#lastProbeAt = nowMs\n        this.#onDeltaFallbackCb?.()\n      }\n    } else {\n      // Recovery transition: inactive \u2192 active (after probe interval + low ratio)\n      if (\n        (nowMs - this.#lastProbeAt) >= this.#deltaProbeIntervalMs &&\n        ratio < this.#deltaRecoverThresholdRatio\n      ) {\n        this.#deltaActive = true\n        this.#lastProbeAt = nowMs\n        this.#onDeltaRecoverCb?.()\n      }\n    }\n  }\n\n  /** Register callback fired when delta track degrades past threshold (D-12). */\n  onDeltaFallback(cb: () => void): void {\n    this.#onDeltaFallbackCb = cb\n  }\n\n  /** Register callback fired when delta track recovers below recovery threshold (D-13). */\n  onDeltaRecover(cb: () => void): void {\n    this.#onDeltaRecoverCb = cb\n  }\n\n  /** Whether the delta track is currently considered healthy (true = active). */\n  get deltaActive(): boolean {\n    return this.#deltaActive\n  }\n\n  // \u2500\u2500 Test-visible accessors for threshold verification \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  // These expose internal derived values for test assertions (Tests 3,4,5,6,7).\n  // Prefixed with 'delta' to namespace clearly within the public API surface.\n\n  /** Derived window size \u2014 exposed for test assertions (Test 3, 4). */\n  get deltaWindowSize(): number { return this.#deltaWindowSize }\n  /** Derived fail threshold ratio (P/K) \u2014 exposed for test assertions (Test 6). */\n  get deltaFailThresholdRatio(): number { return this.#deltaFailThresholdRatio }\n  /** Derived recovery threshold ratio ((P/K)/2) \u2014 exposed for test assertions (Test 7). */\n  get deltaRecoverThresholdRatio(): number { return this.#deltaRecoverThresholdRatio }\n  /** Derived probe interval ms \u2014 exposed for test assertions (Test 5a). */\n  get deltaProbeIntervalMs(): number { return this.#deltaProbeIntervalMs }\n\n  /**\n   * Register a track name \u2192 type mapping from catalog.\n   * Catalog is the default authority. Init data / inline signaling\n   * takes precedence until the next catalog update.\n   */\n  registerTrackType(trackName: string, type: FrameKind): void {\n    // Catalog overwrites any previous registration (including init).\n    this.#trackTypes.set(trackName, { type, source: 'catalog' })\n  }\n\n  /**\n   * Register a track name \u2192 type from init data / inline signaling (MMTP FT=0).\n   * Authoritative until the next catalog update per \u00A75.3.\n   * Does NOT overwrite an existing catalog registration.\n   */\n  registerTrackTypeFromInit(trackName: string, type: FrameKind): void {\n    const existing = this.#trackTypes.get(trackName)\n    if (existing?.source === 'catalog') return // catalog already set \u2014 don't downgrade\n    this.#trackTypes.set(trackName, { type, source: 'init' })\n  }\n\n  /**\n   * Assign a per-track source. Frames from this source bypass the binary\n   * MoQ\u2194multicast switching for this track only.\n   *\n   * Throws TrackSourceConflictError if a source is already assigned for this\n   * track without a clearTrackSource() in between.\n   */\n  setTrackSource(trackName: string, source: TrackSource, opts?: SetTrackSourceOptions): void {\n    if (this.#trackSources.has(trackName)) {\n      throw new TrackSourceConflictError(trackName)\n    }\n\n    // Resolve effective policy. opts.policy takes precedence; overlay=true is legacy 'wait'.\n    const effectivePolicy: MigrationPolicy | undefined =\n      opts?.policy ?? (opts?.overlay ? 'wait' : undefined)\n\n    // For crossfade: open the binary-path window immediately so the first per-track frame\n    // triggers the window (counter starts before the frame callback is wired).\n    if (effectivePolicy === 'crossfade') {\n      this.#crossfadeCounters.set(trackName, this.#crossfadeFrames)\n    }\n\n    const record: TrackSourceRecord = {\n      source,\n      unsubscribeFrame: () => {},\n      emitCount: 0,\n    }\n\n    // Wire the frame callback\n    record.unsubscribeFrame = source.onFrame((data, meta) => {\n      record.emitCount++\n      if (effectivePolicy === 'wait') {\n        this.#handleOverlayFrame(data, meta)\n      } else {\n        // 'drop', 'crossfade', or undefined: emit immediately\n        this.#emitForTrack(trackName, data, meta)\n      }\n    })\n\n    // Wire the optional error callback \u2014 failback to binary switching\n    if (source.onError) {\n      record.unsubscribeError = source.onError(() => {\n        this.clearTrackSource(trackName)\n      })\n    }\n\n    this.#trackSources.set(trackName, record)\n  }\n\n  /**\n   * Remove the per-track source for the given track.\n   * Binary switching resumes for this track after this call.\n   */\n  clearTrackSource(trackName: string): void {\n    const record = this.#trackSources.get(trackName)\n    if (!record) return\n\n    record.unsubscribeFrame()\n    record.unsubscribeError?.()\n    record.source.dispose?.()\n    this.#trackSources.delete(trackName)\n\n    // Clean up crossfade window if one was active for this track\n    this.#crossfadeCounters.delete(trackName)\n\n    // Reset overlay buffer if removing a non-media track (overlay/unknown)\n    const reg = this.#trackTypes.get(trackName)\n    const isMedia = reg?.type === 'video' || reg?.type === 'audio' ||\n      (reg === undefined && (trackName === 'video' || trackName === 'audio'))\n    if (!isMedia) {\n      this.#overlayBoundaryReached = false\n      this.#overlayBuffer = []\n    }\n  }\n\n  /**\n   * Signal that a FEC block boundary has been reached on the base track.\n   * Overlay tracks waiting for alignment flush their buffered frames now.\n   */\n  notifyFecBlockBoundary(): void {\n    if (this.#overlayBoundaryReached) return\n    this.#overlayBoundaryReached = true\n\n    // Flush buffered overlay frames\n    const buffered = this.#overlayBuffer.splice(0)\n    for (const { data, meta } of buffered) {\n      this.#onOverlayFrame?.(data, meta)\n    }\n  }\n\n  /**\n   * Return the number of frames emitted from the per-track source for a given\n   * track. Used in test-mode to verify per-track routing histogram.\n   * Returns 0 if no per-track source is active for the track.\n   */\n  trackSourceEmitCount(trackName: string): number {\n    return this.#trackSources.get(trackName)?.emitCount ?? 0\n  }\n\n  /** Feed a frame from the MoQ path. Suppressed when multicast is active OR a per-track source owns this track. */\n  feedMoq(data: Uint8Array, meta: FrameMeta, kind: FrameKind) {\n    // Per-track source takes precedence; allow through during crossfade window\n    if (this.#trackSources.has(kind)) {\n      const remaining = this.#crossfadeCounters.get(kind)\n      if (remaining && remaining > 0) {\n        // Decrement crossfade counter and allow this frame through\n        const next = remaining - 1\n        if (next === 0) {\n          this.#crossfadeCounters.delete(kind)\n        } else {\n          this.#crossfadeCounters.set(kind, next)\n        }\n        // Fall through to emit below (no return)\n      } else {\n        return // suppressed \u2014 no crossfade window active\n      }\n    }\n    if (this.#suppressed) return\n    // Audio suppression is handled by SessionManager onSuppress callback \u2014\n    // do NOT independently suppress based on multicastAudioReceived.\n    // The state machine decides when to switch; the router just routes.\n    const routedMeta = { ...meta, source: 'moq' as const }\n    if (kind === 'video') this.#onVideoFrame?.(data, routedMeta)\n    else this.#onAudioFrame?.(data, routedMeta)\n  }\n\n  /** Feed a frame from the multicast path. Video waits for keyframe before activating. */\n  feedMulticast(data: Uint8Array, meta: FrameMeta, kind: FrameKind) {\n    // Per-track source takes precedence; allow through during crossfade window\n    if (this.#trackSources.has(kind)) {\n      const remaining = this.#crossfadeCounters.get(kind)\n      if (remaining && remaining > 0) {\n        const next = remaining - 1\n        if (next === 0) {\n          this.#crossfadeCounters.delete(kind)\n        } else {\n          this.#crossfadeCounters.set(kind, next)\n        }\n        // Fall through to emit below (no return)\n      } else {\n        return // suppressed\n      }\n    }\n\n    if (kind === 'video') {\n      if (!this.#multicastVideoKeyed) {\n        const moqSeededDelta =\n          !meta.keyframe &&\n          this.#allowDeltaMulticastTakeoverAfterMoqKeyframe &&\n          this.#moqVideoKeyframeEmitted\n        if (!meta.keyframe && !moqSeededDelta) return // drop until first safe decode point\n        this.#multicastVideoKeyed = true\n        const pendingMeta: FrameMeta = { ...meta, source: 'multicast' }\n        if (!moqSeededDelta) pendingMeta.sourceDiscontinuity = true\n        this.#pendingMulticastVideo = {\n          data: data.slice(),\n          meta: pendingMeta,\n        }\n        // If audio is required but hasn't arrived yet, start a fallback timer.\n        // Audio FEC blocks may recover after video \u2014 don't block activation forever.\n        // Only arms when a catalog-derived audioFallbackMs was supplied (>0).\n        if (this.#requireAudio && this.#audioFallbackMs > 0 && !this.#multicastAudioReceived && !this.#audioFallbackTimer) {\n          this.#audioFallbackTimer = setTimeout(() => {\n            if (!this.#multicastAudioReceived && this.#active !== 'multicast') {\n              this.#multicastAudioReceived = true // force\n              // Also release the MoQ-audio-warmup gate so the fallback actually\n              // activates \u2014 otherwise #tryActivateMulticast would still bail.\n              this.#moqAudioWarmed = true\n              this.#tryActivateMulticast()\n            }\n          }, this.#audioFallbackMs)\n        }\n      } else if (this.#active !== 'multicast') {\n        // Do not feed video into the multicast decoder while the source switch\n        // is still pending. Keep the newest keyframe as the post-activation\n        // decoder opener and drop deltas until takeover commits.\n        if (meta.keyframe) {\n          this.#pendingMulticastVideo = {\n            data: data.slice(),\n            meta: { ...meta, source: 'multicast', sourceDiscontinuity: true },\n          }\n        }\n        this.#tryActivateMulticast()\n        return\n      }\n      if (this.#active === 'multicast') this.#onVideoFrame?.(data, { ...meta, source: 'multicast' })\n      this.#tryActivateMulticast()\n    } else {\n      this.#multicastAudioReceived = true\n      if (this.#audioFallbackTimer) {\n        clearTimeout(this.#audioFallbackTimer)\n        this.#audioFallbackTimer = null\n      }\n      // BLO-3035 layer 5: in a multicast-first scenario (no MoQ unicast audio\n      // source) `notifyMoqAudioEmit()` is never called and the audio-fallback\n      // timer's force-set is bypassed (the timer's inner `!multicastAudioReceived`\n      // check returns early because audio already arrived). Without this gate\n      // `#moqAudioWarmed` stays false forever and `#tryActivateMulticast` never\n      // fires `onSourceSwitch('multicast')` \u2014 the player can't know to emit\n      // `__MULTICAST_TAKEOVER_TIME`. Treat the arrival of multicast audio as\n      // sufficient evidence to release the warmup gate. For the MoQ\u2192multicast\n      // handoff case `notifyMoqAudioEmit()` will already have set this flag, so\n      // the assignment is idempotent.\n      if (!this.#moqAudioWarmed) this.#moqAudioWarmed = true\n      // Activate BEFORE delivering the frame \u2014 the source switch callback\n      // (e.g. ring buffer reset) must fire before the first multicast audio\n      // frame reaches the backend. Otherwise the NTP timestamp hits the\n      // MoQ-era ring buffer base \u2192 overflow \u2192 silence gap.\n      this.#tryActivateMulticast()\n      // Only emit multicast audio AFTER takeover succeeds. Before takeover,\n      // MoQ audio is still flowing through feedMoq \u2192 #onAudioFrame; emitting\n      // multicast audio too would double-feed the backend (2x audio frames,\n      // pitch wobble and distortion). Post-takeover, feedMoq is suppressed\n      // (#suppressed=true) so only multicast audio reaches the backend.\n      if (this.#active === 'multicast') {\n        this.#onAudioFrame?.(data, { ...meta, source: 'multicast' })\n      } else if (this.#pendingMulticastToken !== null) {\n        this.#pendingMulticastAudio = { data: data.slice(), meta: { ...meta, source: 'multicast' } }\n      }\n    }\n  }\n\n  /**\n   * MoQ unicast audio warmup gate. When audio is required, multicast takeover\n   * waits until the MoQ unicast audio decoder has emitted at least one frame\n   * (so downstream samples-before-takeover counters observe nonzero) or until\n   * the existing audio-fallback timer forces the flag true.\n   */\n  #moqAudioWarmed = false\n\n  /** Called by the player when the MoQ unicast audio decoder emits first frame. */\n  public notifyMoqAudioEmit(): void {\n    if (this.#moqAudioWarmed) return\n    this.#moqAudioWarmed = true\n    this.#tryActivateMulticast()\n  }\n\n  /**\n   * Called by the player after a MoQ video keyframe has reached the active\n   * decoder path. Used only by MSE/MMTP continuity switching; decoder-reset\n   * paths leave allowDeltaMulticastTakeoverAfterMoqKeyframe disabled.\n   */\n  public notifyMoqVideoKeyframeEmit(): void {\n    this.#moqVideoKeyframeEmitted = true\n    this.#tryActivateMulticast()\n  }\n\n  #tryActivateMulticast() {\n    if (this.#active === 'multicast') return\n    if (this.#pendingMulticastToken !== null) return\n    if (!this.#multicastVideoKeyed) return\n    if (this.#requireAudio && !this.#multicastAudioReceived) return\n    if (this.#requireAudio && !this.#moqAudioWarmed) return\n    const token = ++this.#sourceSwitchToken\n    const maybeReady = this.#onSourceSwitch?.('multicast')\n    if (!maybeReady || typeof (maybeReady as Promise<void>).then !== 'function') {\n      this.#commitMulticastActivation(token)\n      return\n    }\n    const ready = Promise.resolve(maybeReady)\n    this.#pendingMulticastToken = token\n    this.#sourceSwitchReady = ready\n    void ready.then(\n      () => this.#commitMulticastActivation(token),\n      err => this.#rejectMulticastActivation(token, err),\n    ).finally(() => {\n      if (this.#sourceSwitchReady === ready) this.#sourceSwitchReady = null\n    })\n  }\n\n  #commitMulticastActivation(token: number) {\n    if (token !== this.#sourceSwitchToken) return\n    this.#active = 'multicast'\n    this.#suppressed = true\n    this.#pendingMulticastToken = null\n    const video = this.#pendingMulticastVideo\n    this.#pendingMulticastVideo = null\n    const audio = this.#pendingMulticastAudio\n    this.#pendingMulticastAudio = null\n    if (video) this.#onVideoFrame?.(video.data, video.meta)\n    if (audio) this.#onAudioFrame?.(audio.data, audio.meta)\n  }\n\n  #rejectMulticastActivation(token: number, err: unknown) {\n    if (token !== this.#sourceSwitchToken) return\n    if (this.#pendingMulticastToken === token) this.#pendingMulticastToken = null\n    this.#pendingMulticastVideo = null\n    this.#pendingMulticastAudio = null\n    console.warn('[MediaRouter] onSourceSwitch(multicast) failed', err)\n  }\n\n  /** Switch back to MoQ immediately (called on multicast failback). */\n  failbackToMoq() {\n    const hadPendingMulticast = this.#pendingMulticastToken !== null\n    if (this.#active === 'moq' && !hadPendingMulticast) return // already on MoQ, no-op\n    ++this.#sourceSwitchToken\n    this.#active = 'moq'\n    this.#suppressed = false\n    this.#pendingMulticastToken = null\n    this.#pendingMulticastVideo = null\n    this.#pendingMulticastAudio = null\n    this.#sourceSwitchReady = null\n    this.#multicastVideoKeyed = false\n    this.#multicastAudioReceived = false\n    this.#moqVideoKeyframeEmitted = false\n    // A pending audio-fallback timer belongs to the abandoned takeover attempt.\n    // Left running it would force-set the audio flags against the next attempt's\n    // fresh state (BLO-9413 failback coherence \u2014 every takeover-era flag/timer\n    // unwinds on this edge).\n    if (this.#audioFallbackTimer) {\n      clearTimeout(this.#audioFallbackTimer)\n      this.#audioFallbackTimer = null\n    }\n    this.#onSourceSwitch?.('moq')\n  }\n\n  /** Dispose timers and per-track sources. Call on teardown to prevent\n   *  stale timer callbacks firing into garbage-collected closures (WR-03). */\n  dispose(): void {\n    if (this.#audioFallbackTimer) {\n      clearTimeout(this.#audioFallbackTimer)\n      this.#audioFallbackTimer = null\n    }\n    for (const [name] of this.#trackSources) {\n      this.clearTrackSource(name)\n    }\n  }\n\n  // \u2500\u2500 Private helpers \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  /** Emit a frame on the correct per-track callback using the type registry.\n   *  Falls back to name match if no type registered (backward compat). */\n  #emitForTrack(trackName: string, data: Uint8Array, meta: FrameMeta): void {\n    // Prefer explicit type registry (catalog or init data)\n    const reg = this.#trackTypes.get(trackName)\n    if (reg?.type === 'video') {\n      this.#onVideoFrame?.(data, meta)\n    } else if (reg?.type === 'audio') {\n      this.#onAudioFrame?.(data, meta)\n    } else if (reg !== undefined) {\n      // Registered but unknown type \u2014 overlay\n      this.#onOverlayFrame?.(data, meta)\n    } else {\n      // Not registered \u2014 fall back to name match (backward compat for tests/legacy)\n      if (trackName === 'video') this.#onVideoFrame?.(data, meta)\n      else if (trackName === 'audio') this.#onAudioFrame?.(data, meta)\n      else this.#onOverlayFrame?.(data, meta)\n    }\n  }\n\n  /** Handle an overlay frame: buffer until first FEC block boundary, then pass through. */\n  #handleOverlayFrame(data: Uint8Array, meta: FrameMeta): void {\n    if (this.#overlayBoundaryReached) {\n      this.#onOverlayFrame?.(data, meta)\n      return\n    }\n\n    // Buffer until boundary \u2014 enforcing cap for T-02-17 DoS mitigation\n    if (this.#overlayBuffer.length >= this.#maxOverlayBuffer) {\n      console.warn(\n        `[MediaRouter] overlay buffer full (${this.#maxOverlayBuffer} frames); dropping frame ts=${meta.timestamp}`\n      )\n      return\n    }\n    this.#overlayBuffer.push({ data, meta })\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/mfu-reassembler.d.ts

@@ -0,0 +1,396 @@
+/**
+ * @mmt/container - MFU Fragment Reassembler
+ *
+ * Handles authored fragmented MFUs (Media Fragment Units) according to
+ * ISO/IEC 23008-1:2023 Section 9.2.3.3. Fragmented runs are admitted in the
+ * exact FI/fragment_counter countdown carried on the wire. FI=1 supplies the
+ * intrinsic data-unit key. Every fragmented fragment is addressed by
+ * (stream scope, MPU, packetSequenceNumber + fragmentCounter mod 2^32); a
+ * continuation joins, parks under, or is stale against the one run holding
+ * its address, and other runs are never consulted.
+ *
+ * Fragmentation Indicator (FI) values:
+ * - 0: Complete MFU (single packet, no fragmentation)
+ * - 1: First fragment
+ * - 2: Middle fragment
+ * - 3: Last fragment
+ *
+ * @packageDocumentation
+ */
+/** Source transport admitted by the MMTP router. */
+export type MmtpSourcePath = 'multicast' | 'moq';
+/**
+ * Strict whole-frame delivery provenance, folded over EVERY contributing
+ * fragment rather than the head fragment alone.
+ *
+ * This is deliberately NOT `source`. `source` answers a routing question —
+ * "is this the reliable-MoQ copy that must not confirm multicast takeover?" —
+ * and head-fragment-wins is the documented, deterministic answer to it.
+ * Provenance answers an evidence question: "did every byte of this frame
+ * physically arrive over multicast?" A frame with a multicast head and a
+ * QUIC-delivered tail is a legitimate routing win for `source: 'multicast'`
+ * and is emphatically NOT multicast-exclusive delivery.
+ *
+ *   - 'multicast' — every contributing fragment was explicitly multicast.
+ *     The ONLY value that may be counted as physical-delivery evidence.
+ *   - 'mixed'     — at least one contributing fragment arrived over MoQ.
+ *   - 'unknown'   — no fragment arrived over MoQ, but at least one carried no
+ *     attribution at all. Absence is preserved as its own state rather than
+ *     defaulted, so a consumer cannot mistake "never recorded" for "proven".
+ */
+export type MmtpDeliveryProvenance = 'multicast' | 'mixed' | 'unknown';
+/**
+ * Fold one fragment's `source` into a running provenance verdict.
+ *
+ * Fail-closed, order-independent and associative: 'mixed' absorbs everything,
+ * a missing attribution degrades 'multicast' to 'unknown', and nothing ever
+ * upgrades a verdict. Fold over an empty set is 'unknown' — no fragment ever
+ * proved anything.
+ */
+export declare function foldDeliveryProvenance(verdict: MmtpDeliveryProvenance, source: MmtpSourcePath | undefined): MmtpDeliveryProvenance;
+/** Strict provenance for a complete fragment set. */
+export declare function deliveryProvenanceOf(fragments: readonly {
+    source?: MmtpSourcePath;
+    deliveryProvenance?: MmtpDeliveryProvenance;
+}[]): MmtpDeliveryProvenance;
+/**
+ * MFU Fragment for reassembly
+ */
+export interface MFUFragment {
+    fragmentationIndicator: number;
+    mpuSequenceNumber: number;
+    fragmentCounter: number;
+    data: Uint8Array;
+    timestamp: bigint;
+    /** Random Access Point flag from MMTP header - indicates keyframe */
+    rapFlag: boolean;
+    /** MFU DU priority. FFmpeg marks random-access samples with high priority. */
+    priority?: number;
+    sampleNumber?: number;
+    movieFragmentSequenceNumber?: number;
+    sampleOffset?: number;
+    /** Non-timed MFU Item_ID from the 4-byte DU header. */
+    itemId?: number;
+    /** Authored u32 MMTP packet_sequence_number, including on recovered packets. */
+    packetSequenceNumber?: number;
+    /** True when this accepted source packet was reconstructed by FEC. */
+    recovered?: boolean;
+    /** Transport that supplied this accepted fragment. Absent for recovered data. */
+    source?: MmtpSourcePath;
+    /**
+     * Explicit provenance for this fragment, overriding what `source` implies.
+     * Set by the router for FEC-recovered fragments, which have no `source` of
+     * their own but whose FEC block's symbol provenance is known.
+     */
+    deliveryProvenance?: MmtpDeliveryProvenance;
+    /** Immutable catalog identity supplied by the owning ingress subscription. */
+    catalogTrackName?: string;
+    /** Physical MMTP stream identity when no catalog identity is available. */
+    packetId?: number;
+}
+/**
+ * Reassembled MFU result
+ */
+export interface ReassembledMFU {
+    mpuSequenceNumber: number;
+    /** MMTP packet_sequence_number of the first fragment in delivery order. */
+    packetSequenceNumber?: number;
+    /** Every authoritative MMTP source-packet sequence that formed this MFU. */
+    packetSequenceNumbers?: number[];
+    /** Subset of packetSequenceNumbers reconstructed by FEC. */
+    repairedPacketSequenceNumbers?: number[];
+    data: Uint8Array;
+    timestamp: bigint;
+    fragmentCount: number;
+    /** Random Access Point flag - indicates keyframe (from first fragment) */
+    rapFlag: boolean;
+    /** MFU DU priority from the first fragment that carried it. */
+    priority?: number;
+    sampleNumber?: number;
+    movieFragmentSequenceNumber?: number;
+    /**
+     * This DU's authored base byte offset within its sample (moqcast #37). 0
+     * for a whole-sample DU; nonzero identifies one subsample DU among
+     * siblings partitioning an oversized sample. Constant across the DU's own
+     * fragments — feed into a sample combiner to reassemble the full sample.
+     */
+    sampleOffset?: number;
+    /**
+     * Transport that supplied the accepted FI=1 head fragment (or the complete
+     * FI=0 frame). This is the deterministic winner for mixed-path assembly.
+     *
+     * ROUTING ONLY. It describes one fragment, so it is not evidence about the
+     * whole frame — read {@link ReassembledMFU.deliveryProvenance} for that.
+     */
+    source?: MmtpSourcePath;
+    /**
+     * Strict provenance folded over every contributing fragment. Only
+     * 'multicast' proves multicast-exclusive delivery of this frame.
+     */
+    deliveryProvenance: MmtpDeliveryProvenance;
+    /** Catalog identity from the accepted FI=1 head fragment, or FI=0 frame. */
+    catalogTrackName?: string;
+}
+/**
+ * Reassembler statistics
+ */
+export interface ReassemblerStats {
+    totalFragments: number;
+    reassembledMFUs: number;
+    /** Fragments rejected by strict authored DU-state validation. */
+    rejectedFragments: number;
+    /** Incomplete MFUs discarded after their configured deadline. */
+    timedOutMFUs: number;
+    /** Incomplete MFUs discarded to enforce the configured memory bound. */
+    evictedMemoryLimit: number;
+    outOfOrderFragments: number;
+}
+export declare const MFU_REASSEMBLY_ERROR_CODES: readonly ["invalid-fragment-state", "missing-data-unit-identity", "missing-packet-sequence", "conflicting-data-unit-identity", "overlapping-data-unit", "fragment-counter-mismatch", "data-unit-identity-mismatch", "offset-overflow", "active-data-unit-limit", "incomplete-terminal-fragment", "ambiguous-continuation"];
+export type MfuReassemblyErrorCode = (typeof MFU_REASSEMBLY_ERROR_CODES)[number];
+export declare function isMfuReassemblyErrorCode(value: unknown): value is MfuReassemblyErrorCode;
+export declare class MfuReassemblyError extends Error {
+    readonly code: MfuReassemblyErrorCode;
+    readonly name = "MfuReassemblyError";
+    constructor(code: MfuReassemblyErrorCode, message: string);
+}
+/**
+ * Identity-free test for a reassembly rejection.
+ *
+ * Consumers that inline `@blockcast/mmt-container` more than once (a component
+ * bundle whose `@blockcast/*` dependencies each carry their own copy) end up
+ * with several distinct `MfuReassemblyError` classes. An `instanceof` check
+ * against one copy then misses rejections raised by another, and a per-fragment
+ * rejection escapes as an uncaught throw that aborts the rest of the packet's
+ * processing. The wire contract of a rejection is its name plus one of the
+ * closed error codes, so that is what this guard checks.
+ */
+export declare function isMfuReassemblyError(error: unknown): error is MfuReassemblyError;
+export interface PendingMfuDebug {
+    key: string;
+    fragments: number;
+    fi0: number;
+    fi1: number;
+    fi2: number;
+    fi3: number;
+    firstFi: number;
+    lastFi: number;
+    firstOrder: number;
+    lastOrder: number;
+    minCounter: number;
+    maxCounter: number;
+    minOffset?: number;
+    maxOffset?: number;
+    movieFragmentSequenceNumber?: number;
+    sampleNumber?: number;
+    mpuSequenceNumber?: number;
+    sortedHead: Array<{
+        fi: number;
+        counter: number;
+        order: number;
+        seq?: number;
+        offset?: number;
+    }>;
+    sortedTail: Array<{
+        fi: number;
+        counter: number;
+        order: number;
+        seq?: number;
+        offset?: number;
+    }>;
+}
+export interface MFUReassemblerOptions {
+    /** Timeout (ms) for incomplete MFUs. Derive from frame duration or FEC interleaveDepthMs.
+     *  Pass null for live clock-free operation; memory remains bounded by maxBuffered. */
+    timeoutMs: number | null;
+    /** Max concurrent incomplete MFUs, including continuations awaiting FI=1. */
+    maxBuffered?: number;
+}
+/** Reassembly surface consumed by MmtpContainerParser and MmtpRouter.
+ * Implemented by both the TypeScript engine and the shared
+ * Rust/WASM IFC adapter. */
+export interface MfuReassemblerBackend {
+    timeoutMs: number | null;
+    readonly stats: ReassemblerStats;
+    onDeferredAssembly?: (result: ReassembledMFU) => void;
+    /** Returns null only for a valid incomplete DU; strict rejection throws
+     * `MfuReassemblyError`. */
+    addFragment(fragment: MFUFragment): ReassembledMFU | null;
+    flush(): void;
+    resetStream(catalogTrackName: string): void;
+    reset(): void;
+    readonly pendingCount: number;
+    getStatus(): {
+        bufferedMFUs: number;
+        pendingFragments: number;
+        pendingSamples: PendingMfuDebug[];
+        stats: ReassemblerStats;
+    };
+}
+/**
+ * MFU Reassembler with bounded reordered-fragment association
+ * Based on ISO/IEC 23008-1:2023 Section 9.2.3.3
+ */
+/**
+ * Completed-address window, as a multiple of maxBuffered. A late continuation
+ * is refused as stale while its data unit's address is within this window and
+ * parks as a headless data unit once the address has been forgotten. The
+ * value is a cross-engine invariant shared with the Rust reassembler
+ * (mmt-core COMPLETED_ADDRESS_WINDOW_MULTIPLE); change both together.
+ */
+export declare const COMPLETED_ADDRESS_WINDOW_MULTIPLE = 2;
+/**
+ * Cross-engine anchors for the clock-free eviction guard. The bound itself is
+ * `maxBuffered`, a host parameter — these fix the one scenario both regression
+ * corpora drive so the Rust and TypeScript guards assert the same boundary
+ * rather than each deriving its own. Shared with the Rust reassembler
+ * (`EVICTION_GUARD_MAX_BUFFERED` / `EVICTION_GUARD_DATA_UNITS` in
+ * `mmt-core/src/reassembler/policy/mmt.rs`); change both together.
+ *
+ * `EVICTION_GUARD_DATA_UNITS` headless data units admitted against a bound of
+ * `EVICTION_GUARD_MAX_BUFFERED` must evict exactly the difference.
+ */
+export declare const EVICTION_GUARD_MAX_BUFFERED = 4;
+export declare const EVICTION_GUARD_DATA_UNITS = 12;
+/**
+ * Does a parked continuation queue hold a `maxBuffered` slot of its own?
+ *
+ * One rule, four call sites. Two read the bound: the queue that is *counted*
+ * toward it (`#unopenedParkedRunCount`) is exactly the queue that is *offered*
+ * to eviction (`#evictLeastRecentlyAdmitted`). Two gate admission against it:
+ * `#parkContinuation` and the FI=1 arm of `#associateDataUnit` each ask whether
+ * this address is already charged before moving the bound. Stating the rule once
+ * is what keeps those four answers from drifting apart — a queue that charges a
+ * slot no eviction can reclaim wedges the receiver, because the bound then
+ * refuses every new data unit forever with `active-data-unit-limit`.
+ *
+ * Two exclusions, for two different reasons:
+ *
+ * - **An open run owns the address.** The data unit is already charged through
+ *   that run, so its queue costs nothing further.
+ * - **The queue is empty.** It holds nothing, so it charges nothing and offers
+ *   nothing.
+ *
+ * The emptiness half is belt-and-braces, not load-bearing. Both engines discard
+ * an emptied queue eagerly — `#deletePendingRun` here on every drain exit,
+ * `discard_empty_parked_run` in Rust — and `#parkContinuation` always inserts
+ * into a queue it just created, so an empty queue is not observable today.
+ * Correctness must not depend on that invariant holding in all three places per
+ * engine: routing every site that asks the question through this one predicate
+ * is what keeps the engines agreeing if a future edit ever misses one of them.
+ *
+ * Scope: this rule decides *slot accounting* — counted, offered, admitted. A
+ * queue carries two further per-slot facts, its admission ordinal and its
+ * retention anchor (`startedAt` plus the timer armed from it), and both must
+ * move when an empty queue is charged again. `#parkContinuation` resets them
+ * explicitly; Rust gets the same contract structurally, by deriving each from
+ * the queue's live entries. Same contract, two mechanisms.
+ *
+ * The *reap schedule* asks the same question, and every site that arms a
+ * parked queue reaches one function, `#armHeadlessPendingTimeout`, which takes
+ * the test through this rule: `set timeoutMs` calls it for every queue when
+ * the policy changes, `#parkContinuation` calls it after a created or
+ * re-anchored queue holds its first fragment, and a run closing without
+ * completing calls it for the queue it leaves behind. It never arms a timer
+ * for an empty queue, because a timeout reports a data unit that failed to
+ * complete in time and an empty queue holds no such data unit. Charging one
+ * would record an MFU that never existed. No site installs a parked-queue
+ * timer of its own, so neither the slot rule nor the `startedAt` anchoring can
+ * drift one site at a time.
+ *
+ * That is the answer Rust reaches structurally: `next_timeout_at` derives
+ * candidate deadlines from the queue's live entries, so an empty queue yields
+ * none and no sweep is ever scheduled on its account, and `cleanup_timeouts`
+ * retains by `parked_run_holds_a_slot`, so a sweep arriving for any *other*
+ * queue leaves an empty one in place rather than charging
+ * `record_policy_timeout` for it. Both engines therefore agree on when the
+ * reap is scheduled, and the recorded statistic is unchanged for every queue
+ * that really did hold a data unit: `#onPendingTimeout` charges
+ * `stats.timedOutMFUs`, the shape Rust's `record_policy_timeout` produces, and
+ * takes the same slot test before charging, so the statistic cannot be
+ * recorded for an empty queue whatever order the arming sites run in.
+ *
+ * The trade this makes, in both engines: a queue that is emptied without being
+ * discarded is invisible to the reap schedule, to the slot count, and to
+ * eviction, so nothing reclaims it until `reset()` clears the policy state.
+ * Disposal of an emptied queue therefore rests entirely on the eager discard
+ * sites (`#deletePendingRun` here, `discard_empty_parked_run` in Rust), where
+ * it is housekeeping rather than an expiry; a drain exit that skips that call
+ * leaks the queue for the life of the reassembler rather than charging a
+ * phantom timeout for it. Converged under BLO-32420. The arming half of this
+ * rule is pinned in `mfu-reassembler-eviction.test.ts`: a headless queue that
+ * holds fragments is armed by `set timeoutMs` and by its run closing, and
+ * disarmed by `timeoutMs = null`. The emptiness half is Rust-only, because
+ * `#pendingContinuations` is unreachable from this package's tests.
+ *
+ * The public counters are a separate matter and *are* governed: `pendingCount`
+ * — and through it `getStatus().bufferedMFUs` — delegates to
+ * `#unopenedParkedRunCount`, exactly as Rust's `buffered_count` is built on
+ * `unopened_parked_run_count`. Filtering either on the open run alone makes the
+ * engines report different numbers for the same state out of a host-observable
+ * API.
+ *
+ * Twin of `parked_run_holds_a_slot` in
+ * `mmt-core/src/reassembler/policy/mmt.rs`; change both together.
+ */
+export declare function parkedRunHoldsASlot(hasOpenRun: boolean, fragmentCount: number): boolean;
+export declare class MFUReassembler {
+    #private;
+    /** Statistics for debugging */
+    readonly stats: ReassemblerStats;
+    constructor(options: MFUReassemblerOptions);
+    /** Update the expiry policy for all retained and future incomplete MFUs. */
+    set timeoutMs(ms: number | null);
+    get timeoutMs(): number | null;
+    /**
+     * Add a fragment and return reassembled MFU if complete
+     */
+    addFragment(fragment: MFUFragment): ReassembledMFU | null;
+    /** Callback for deferred assembly results (set by caller for async frame delivery) */
+    onDeferredAssembly?: (result: ReassembledMFU) => void;
+    /**
+     * Flush all buffered fragments
+     */
+    flush(): void;
+    /** Drop one catalog stream's incomplete and dedup state. */
+    resetStream(catalogTrackName: string): void;
+    /** Reset all state — flush buffers and zero stats */
+    reset(): void;
+    /**
+     * Get number of pending MFUs: engine buffers plus every headless parked data
+     * unit that holds a slot.
+     *
+     * This is not one of the four charging sites, but it shares their second term,
+     * so it takes the same rule — by delegating to `#unopenedParkedRunCount`, the
+     * one site that applies it. Rust's public `buffered_count()` is
+     * `inner.buffered_count() + unopened_parked_run_count()`, and that count is
+     * `parked_run_holds_a_slot` — so filtering here on the open run alone would
+     * report a phantom slot for an empty published queue in TypeScript and not in
+     * Rust, out of a *host-observable* counter (`getStatus().bufferedMFUs`). Same
+     * state, two numbers, decided by which engine the host loaded: the divergence
+     * class this file exists to close, so the public counters have to agree too.
+     *
+     * Distinct from `#incompleteRunCount`, which sums `#activeDataUnits` rather
+     * than `#buffers`. Those are different quantities by design and are not being
+     * merged; only the parked term they share is required to agree, which is what
+     * routing both through one method makes structural rather than conventional.
+     */
+    get pendingCount(): number;
+    /**
+     * Get current buffer status
+     */
+    getStatus(): {
+        bufferedMFUs: number;
+        pendingFragments: number;
+        pendingSamples: PendingMfuDebug[];
+        stats: ReassemblerStats;
+    };
+}
+/**
+ * Create MFU fragment from MMTP packet for reassembly
+ */
+export declare function createFragment(mmtpPacket: Uint8Array): MFUFragment;
+/**
+ * Process MMTP packet with fragment reassembly
+ */
+export declare function processMMTPWithReassembly(mmtpPacket: Uint8Array, reassembler: MFUReassembler): ReassembledMFU | null;
+//# sourceMappingURL=mfu-reassembler.d.ts.map

package/dist/mfu-reassembler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mfu-reassembler.d.ts","sourceRoot":"","sources":["../src/mfu-reassembler.ts"],"names":[],"mappings":"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"}