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

package/dist/track-pipeline.js

@@ -0,0 +1,229 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/track-pipeline.ts
+var AUTO_CHAIN = ["multicast", "amt", "moq"];
+var DEFAULT_POLICY = {
+  audio: "crossfade",
+  video: "wait"
+};
+var _router, _sourceFactory, _tracks, _capabilities, _onTransportChange, _onQualityChange, _TrackPipeline_instances, resolve_fn, resolveTrack_fn, applyTransport_fn, expandPreferred_fn, isAvailable_fn, defaultPolicy_fn;
+var TrackPipeline = class {
+  constructor(router) {
+    __privateAdd(this, _TrackPipeline_instances);
+    __privateAdd(this, _router);
+    __privateAdd(this, _sourceFactory, null);
+    __privateAdd(this, _tracks, /* @__PURE__ */ new Map());
+    __privateAdd(this, _capabilities, null);
+    __privateAdd(this, _onTransportChange, null);
+    __privateAdd(this, _onQualityChange, null);
+    __privateSet(this, _router, router);
+  }
+  // ---------------------------------------------------------------------------
+  // Configuration
+  // ---------------------------------------------------------------------------
+  /**
+   * Register a factory that creates TrackSource instances for a given transport.
+   * The factory is called when the pipeline resolves a track to a new transport
+   * and needs to wire it into the MediaRouter.
+   *
+   * The factory returns null if the transport is not available for that track
+   * (e.g., no multicast socket for this group).
+   */
+  setSourceFactory(factory) {
+    __privateSet(this, _sourceFactory, factory);
+  }
+  /** Listen for transport change events (after setTrackSource is called). */
+  onTransportChange(cb) {
+    __privateSet(this, _onTransportChange, cb);
+  }
+  /** Listen for ABR-driven quality change requests. */
+  onQualityChange(cb) {
+    __privateSet(this, _onQualityChange, cb);
+  }
+  // ---------------------------------------------------------------------------
+  // Preferences + Capabilities
+  // ---------------------------------------------------------------------------
+  /**
+   * Set per-track transport preferences. Triggers resolution if capabilities
+   * are already known. Safe to call multiple times (replaces previous prefs).
+   */
+  setPreferences(prefs) {
+    for (const pref of prefs) {
+      const existing = __privateGet(this, _tracks).get(pref.trackName);
+      __privateGet(this, _tracks).set(pref.trackName, {
+        currentTransport: existing?.currentTransport ?? null,
+        preference: pref,
+        resolution: existing?.resolution ?? null
+      });
+    }
+    for (const name of __privateGet(this, _tracks).keys()) {
+      if (!prefs.find((p) => p.trackName === name)) {
+        __privateGet(this, _router).clearTrackSource(name);
+        __privateGet(this, _tracks).delete(name);
+      }
+    }
+    if (__privateGet(this, _capabilities)) __privateMethod(this, _TrackPipeline_instances, resolve_fn).call(this);
+  }
+  /**
+   * Update capability snapshot. Triggers re-resolution against current prefs.
+   * Called by the IWA's CapabilityObserver, or by the player's extension bridge
+   * on capability change events.
+   */
+  updateCapabilities(caps) {
+    __privateSet(this, _capabilities, caps);
+    if (__privateGet(this, _tracks).size > 0) __privateMethod(this, _TrackPipeline_instances, resolve_fn).call(this);
+  }
+  /**
+   * Force a specific transport for a track (e.g., user override, debug).
+   * Skips the resolver; applies immediately.
+   */
+  forceTransport(trackName, transport, policy) {
+    const state = __privateGet(this, _tracks).get(trackName);
+    if (!state) return;
+    const effectivePolicy = policy ?? __privateMethod(this, _TrackPipeline_instances, defaultPolicy_fn).call(this, state.preference.trackType);
+    __privateMethod(this, _TrackPipeline_instances, applyTransport_fn).call(this, trackName, transport, effectivePolicy);
+  }
+  // ---------------------------------------------------------------------------
+  // ABR Integration
+  // ---------------------------------------------------------------------------
+  /**
+   * Notify the pipeline of an ABR quality change. The pipeline adjusts the
+   * transport ceiling and may trigger a transport switch if the new quality
+   * exceeds the current transport's capacity.
+   */
+  notifyQualityChange(trackName, quality) {
+    var _a;
+    (_a = __privateGet(this, _onQualityChange)) == null ? void 0 : _a.call(this, trackName, quality);
+    if (__privateGet(this, _capabilities)) __privateMethod(this, _TrackPipeline_instances, resolve_fn).call(this);
+  }
+  // ---------------------------------------------------------------------------
+  // Query
+  // ---------------------------------------------------------------------------
+  /** Current transport for a track (null if not yet resolved). */
+  getTransport(trackName) {
+    return __privateGet(this, _tracks).get(trackName)?.currentTransport ?? null;
+  }
+  /** Current resolution for a track (null if not yet resolved). */
+  getResolution(trackName) {
+    return __privateGet(this, _tracks).get(trackName)?.resolution ?? null;
+  }
+  /** All track names managed by this pipeline. */
+  get trackNames() {
+    return [...__privateGet(this, _tracks).keys()];
+  }
+  // ---------------------------------------------------------------------------
+  // Teardown
+  // ---------------------------------------------------------------------------
+  dispose() {
+    for (const name of __privateGet(this, _tracks).keys()) {
+      __privateGet(this, _router).clearTrackSource(name);
+    }
+    __privateGet(this, _tracks).clear();
+    __privateSet(this, _capabilities, null);
+    __privateSet(this, _onTransportChange, null);
+    __privateSet(this, _onQualityChange, null);
+  }
+};
+_router = new WeakMap();
+_sourceFactory = new WeakMap();
+_tracks = new WeakMap();
+_capabilities = new WeakMap();
+_onTransportChange = new WeakMap();
+_onQualityChange = new WeakMap();
+_TrackPipeline_instances = new WeakSet();
+// ---------------------------------------------------------------------------
+// Internal
+// ---------------------------------------------------------------------------
+/** Run the resolver and apply transport changes. */
+resolve_fn = function() {
+  const caps = __privateGet(this, _capabilities);
+  for (const [trackName, state] of __privateGet(this, _tracks)) {
+    const resolution = __privateMethod(this, _TrackPipeline_instances, resolveTrack_fn).call(this, state.preference, caps);
+    state.resolution = resolution;
+    if (resolution.assignedTransport !== state.currentTransport) {
+      __privateMethod(this, _TrackPipeline_instances, applyTransport_fn).call(this, trackName, resolution.assignedTransport, resolution.migrationPolicy);
+    }
+  }
+};
+/** Pure per-track resolution (inline, no dependency on @blockcast/shared). */
+resolveTrack_fn = function(pref, caps) {
+  const chain = __privateMethod(this, _TrackPipeline_instances, expandPreferred_fn).call(this, pref.preferred);
+  for (let i = 0; i < chain.length; i++) {
+    const transport = chain[i];
+    if (!__privateMethod(this, _TrackPipeline_instances, isAvailable_fn).call(this, transport, caps)) continue;
+    return {
+      trackName: pref.trackName,
+      assignedTransport: transport,
+      reason: i === 0 ? "preferred" : "fallback",
+      migrationPolicy: pref.migrationPolicy ?? __privateMethod(this, _TrackPipeline_instances, defaultPolicy_fn).call(this, pref.trackType)
+    };
+  }
+  return {
+    trackName: pref.trackName,
+    assignedTransport: "moq",
+    reason: "capability-limited",
+    migrationPolicy: pref.migrationPolicy ?? __privateMethod(this, _TrackPipeline_instances, defaultPolicy_fn).call(this, pref.trackType)
+  };
+};
+/** Apply a resolved transport to a track via MediaRouter. */
+applyTransport_fn = function(trackName, transport, policy) {
+  var _a, _b;
+  const state = __privateGet(this, _tracks).get(trackName);
+  if (!state) return;
+  const prev = state.currentTransport;
+  if (transport === "moq") {
+    __privateGet(this, _router).clearTrackSource(trackName);
+    state.currentTransport = "moq";
+    if (prev !== "moq") {
+      (_a = __privateGet(this, _onTransportChange)) == null ? void 0 : _a.call(this, trackName, prev, "moq", policy);
+    }
+    return;
+  }
+  if (!__privateGet(this, _sourceFactory)) {
+    console.warn(`[TrackPipeline] No source factory registered; cannot create source for ${trackName}/${transport}`);
+    return;
+  }
+  const source = __privateGet(this, _sourceFactory).call(this, trackName, transport);
+  if (!source) {
+    console.warn(`[TrackPipeline] Factory returned null for ${trackName}/${transport}; keeping current transport`);
+    return;
+  }
+  if (prev && prev !== "moq") {
+    __privateGet(this, _router).clearTrackSource(trackName);
+  }
+  __privateGet(this, _router).setTrackSource(trackName, source, { policy });
+  state.currentTransport = transport;
+  (_b = __privateGet(this, _onTransportChange)) == null ? void 0 : _b.call(this, trackName, prev, transport, policy);
+};
+expandPreferred_fn = function(preferred) {
+  const out = [];
+  for (const t of preferred) {
+    if (t === "auto") out.push(...AUTO_CHAIN);
+    else out.push(t);
+  }
+  return out;
+};
+isAvailable_fn = function(transport, caps) {
+  switch (transport) {
+    case "multicast":
+      return caps.nativeMulticast.confirmed;
+    case "amt":
+      return caps.amt.available;
+    case "moq":
+      return caps.moqRelay.reachable;
+  }
+};
+defaultPolicy_fn = function(trackType) {
+  return DEFAULT_POLICY[trackType];
+};
+export {
+  TrackPipeline
+};
+//# sourceMappingURL=track-pipeline.js.map

package/dist/track-pipeline.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/track-pipeline.ts"],
+  "sourcesContent": ["/**\n * TrackPipeline \u2014 per-track transport promotion + ABR integration.\n *\n * Coordinates transport promotion (MoQ \u2192 multicast/AMT) on a per-track basis.\n * Shared by both web players (moq-lib, moqtail) and the IWA.\n *\n * Responsibilities:\n *   1. Takes per-track transport preferences and current capabilities\n *   2. Runs the pure resolveTransports() function to get assignments\n *   3. Calls MediaRouter.setTrackSource() per-track with the resolved policy\n *   4. Re-resolves when capabilities change (network switch, multicast detected)\n *   5. Integrates ABR quality changes with track-level subscription management\n *\n * NOT responsible for:\n *   - Socket management (that's MulticastTransport / NativeMulticastManager)\n *   - FEC decode (that's FECManager)\n *   - MMTP parsing (that's MmtpRouter)\n *   - Binary MoQ\u2194multicast switching (that's MediaRouter.feedMoq/feedMulticast)\n *\n * Usage:\n *   const pipeline = new TrackPipeline(mediaRouter);\n *   pipeline.setPreferences(prefs);\n *   pipeline.updateCapabilities(caps);\n *   // pipeline calls mediaRouter.setTrackSource() automatically\n *   // listen for transport changes:\n *   pipeline.onTransportChange((trackName, from, to, policy) => { ... });\n */\n\nimport type { MediaRouter, TrackSource } from './media-router.js'\nimport type { MigrationPolicy } from './media-router.js'\n\n// Inline transport types to avoid dep on @blockcast/shared at runtime.\n// These MUST stay compatible with @blockcast/shared/transport-settings.\nexport type TrackTransport = 'multicast' | 'amt' | 'moq' | 'auto'\n\nexport interface TrackTransportPreference {\n  trackName: string\n  /** Actual media type from catalog (never inferred from name). */\n  trackType: 'video' | 'audio'\n  preferred: TrackTransport[]\n  maxLatencyMs?: number\n  migrationPolicy?: MigrationPolicy\n}\n\nexport interface TransportCapabilityReport {\n  nativeMulticast: { confirmed: boolean; lastPacketAt?: number }\n  amt: { available: boolean; relay?: string; rttMs?: number }\n  moqRelay: { reachable: boolean; rttMs?: number }\n  networkHint?: 'wifi' | 'cellular' | 'ethernet' | 'unknown'\n  observedAt: number\n}\n\nexport interface TrackTransportResolution {\n  trackName: string\n  assignedTransport: TrackTransport\n  reason: 'preferred' | 'fallback' | 'capability-limited' | 'latency-gated' | 'abr-override'\n  migrationPolicy: MigrationPolicy\n}\n\n/** Callback for transport change events */\ntype TransportChangeCb = (\n  trackName: string,\n  from: TrackTransport | null,\n  to: TrackTransport,\n  policy: MigrationPolicy,\n) => void\n\n/** Callback for ABR quality change requests */\ntype QualityChangeCb = (trackName: string, quality: { name: string; bitrate: number }) => void\n\n/** Factory that creates a TrackSource for a given transport + track */\nexport type TrackSourceFactory = (\n  trackName: string,\n  transport: TrackTransport,\n) => TrackSource | null\n\n// Default auto expansion: multicast \u2192 amt \u2192 moq\nconst AUTO_CHAIN: Exclude<TrackTransport, 'auto'>[] = ['multicast', 'amt', 'moq']\n\n// Default migration policies\nconst DEFAULT_POLICY: Record<string, MigrationPolicy> = {\n  audio: 'crossfade',\n  video: 'wait',\n}\n\n/** Per-track state tracked by the pipeline */\ninterface TrackState {\n  currentTransport: TrackTransport | null\n  preference: TrackTransportPreference\n  resolution: TrackTransportResolution | null\n}\n\nexport class TrackPipeline {\n  #router: MediaRouter\n  #sourceFactory: TrackSourceFactory | null = null\n  #tracks = new Map<string, TrackState>()\n  #capabilities: TransportCapabilityReport | null = null\n  #onTransportChange: TransportChangeCb | null = null\n  #onQualityChange: QualityChangeCb | null = null\n\n  constructor(router: MediaRouter) {\n    this.#router = router\n  }\n\n  // ---------------------------------------------------------------------------\n  // Configuration\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Register a factory that creates TrackSource instances for a given transport.\n   * The factory is called when the pipeline resolves a track to a new transport\n   * and needs to wire it into the MediaRouter.\n   *\n   * The factory returns null if the transport is not available for that track\n   * (e.g., no multicast socket for this group).\n   */\n  setSourceFactory(factory: TrackSourceFactory): void {\n    this.#sourceFactory = factory\n  }\n\n  /** Listen for transport change events (after setTrackSource is called). */\n  onTransportChange(cb: TransportChangeCb): void {\n    this.#onTransportChange = cb\n  }\n\n  /** Listen for ABR-driven quality change requests. */\n  onQualityChange(cb: QualityChangeCb): void {\n    this.#onQualityChange = cb\n  }\n\n  // ---------------------------------------------------------------------------\n  // Preferences + Capabilities\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Set per-track transport preferences. Triggers resolution if capabilities\n   * are already known. Safe to call multiple times (replaces previous prefs).\n   */\n  setPreferences(prefs: TrackTransportPreference[]): void {\n    for (const pref of prefs) {\n      const existing = this.#tracks.get(pref.trackName)\n      this.#tracks.set(pref.trackName, {\n        currentTransport: existing?.currentTransport ?? null,\n        preference: pref,\n        resolution: existing?.resolution ?? null,\n      })\n    }\n    // Remove tracks no longer in prefs\n    for (const name of this.#tracks.keys()) {\n      if (!prefs.find(p => p.trackName === name)) {\n        this.#router.clearTrackSource(name)\n        this.#tracks.delete(name)\n      }\n    }\n    if (this.#capabilities) this.#resolve()\n  }\n\n  /**\n   * Update capability snapshot. Triggers re-resolution against current prefs.\n   * Called by the IWA's CapabilityObserver, or by the player's extension bridge\n   * on capability change events.\n   */\n  updateCapabilities(caps: TransportCapabilityReport): void {\n    this.#capabilities = caps\n    if (this.#tracks.size > 0) this.#resolve()\n  }\n\n  /**\n   * Force a specific transport for a track (e.g., user override, debug).\n   * Skips the resolver; applies immediately.\n   */\n  forceTransport(trackName: string, transport: TrackTransport, policy?: MigrationPolicy): void {\n    const state = this.#tracks.get(trackName)\n    if (!state) return\n\n    const effectivePolicy = policy ?? this.#defaultPolicy(state.preference.trackType)\n    this.#applyTransport(trackName, transport, effectivePolicy)\n  }\n\n  // ---------------------------------------------------------------------------\n  // ABR Integration\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Notify the pipeline of an ABR quality change. The pipeline adjusts the\n   * transport ceiling and may trigger a transport switch if the new quality\n   * exceeds the current transport's capacity.\n   */\n  notifyQualityChange(trackName: string, quality: { name: string; bitrate: number }): void {\n    this.#onQualityChange?.(trackName, quality)\n    // Re-resolve: ABR quality may push a track to a different transport\n    if (this.#capabilities) this.#resolve()\n  }\n\n  // ---------------------------------------------------------------------------\n  // Query\n  // ---------------------------------------------------------------------------\n\n  /** Current transport for a track (null if not yet resolved). */\n  getTransport(trackName: string): TrackTransport | null {\n    return this.#tracks.get(trackName)?.currentTransport ?? null\n  }\n\n  /** Current resolution for a track (null if not yet resolved). */\n  getResolution(trackName: string): TrackTransportResolution | null {\n    return this.#tracks.get(trackName)?.resolution ?? null\n  }\n\n  /** All track names managed by this pipeline. */\n  get trackNames(): string[] {\n    return [...this.#tracks.keys()]\n  }\n\n  // ---------------------------------------------------------------------------\n  // Teardown\n  // ---------------------------------------------------------------------------\n\n  dispose(): void {\n    for (const name of this.#tracks.keys()) {\n      this.#router.clearTrackSource(name)\n    }\n    this.#tracks.clear()\n    this.#capabilities = null\n    this.#onTransportChange = null\n    this.#onQualityChange = null\n  }\n\n  // ---------------------------------------------------------------------------\n  // Internal\n  // ---------------------------------------------------------------------------\n\n  /** Run the resolver and apply transport changes. */\n  #resolve(): void {\n    const caps = this.#capabilities!\n    for (const [trackName, state] of this.#tracks) {\n      const resolution = this.#resolveTrack(state.preference, caps)\n      state.resolution = resolution\n\n      if (resolution.assignedTransport !== state.currentTransport) {\n        this.#applyTransport(trackName, resolution.assignedTransport, resolution.migrationPolicy)\n      }\n    }\n  }\n\n  /** Pure per-track resolution (inline, no dependency on @blockcast/shared). */\n  #resolveTrack(\n    pref: TrackTransportPreference,\n    caps: TransportCapabilityReport,\n  ): TrackTransportResolution {\n    const chain = this.#expandPreferred(pref.preferred)\n\n    for (let i = 0; i < chain.length; i++) {\n      const transport = chain[i]!\n      if (!this.#isAvailable(transport, caps)) continue\n\n      return {\n        trackName: pref.trackName,\n        assignedTransport: transport,\n        reason: i === 0 ? 'preferred' : 'fallback',\n        migrationPolicy: pref.migrationPolicy ?? this.#defaultPolicy(pref.trackType),\n      }\n    }\n\n    // Nothing available \u2014 stay on current or fall back to moq\n    return {\n      trackName: pref.trackName,\n      assignedTransport: 'moq',\n      reason: 'capability-limited',\n      migrationPolicy: pref.migrationPolicy ?? this.#defaultPolicy(pref.trackType),\n    }\n  }\n\n  /** Apply a resolved transport to a track via MediaRouter. */\n  #applyTransport(trackName: string, transport: TrackTransport, policy: MigrationPolicy): void {\n    const state = this.#tracks.get(trackName)\n    if (!state) return\n\n    const prev = state.currentTransport\n\n    // MoQ is the default binary path \u2014 clear per-track source to fall back\n    if (transport === 'moq') {\n      this.#router.clearTrackSource(trackName)\n      state.currentTransport = 'moq'\n      if (prev !== 'moq') {\n        this.#onTransportChange?.(trackName, prev, 'moq', policy)\n      }\n      return\n    }\n\n    // For multicast/amt: create a TrackSource via the factory\n    if (!this.#sourceFactory) {\n      console.warn(`[TrackPipeline] No source factory registered; cannot create source for ${trackName}/${transport}`)\n      return\n    }\n\n    const source = this.#sourceFactory(trackName, transport)\n    if (!source) {\n      console.warn(`[TrackPipeline] Factory returned null for ${trackName}/${transport}; keeping current transport`)\n      return\n    }\n\n    // Clear previous per-track source (if any) before setting new one\n    if (prev && prev !== 'moq') {\n      this.#router.clearTrackSource(trackName)\n    }\n\n    this.#router.setTrackSource(trackName, source, { policy })\n    state.currentTransport = transport\n    this.#onTransportChange?.(trackName, prev, transport, policy)\n  }\n\n  #expandPreferred(preferred: TrackTransport[]): Exclude<TrackTransport, 'auto'>[] {\n    const out: Exclude<TrackTransport, 'auto'>[] = []\n    for (const t of preferred) {\n      if (t === 'auto') out.push(...AUTO_CHAIN)\n      else out.push(t)\n    }\n    return out\n  }\n\n  #isAvailable(transport: Exclude<TrackTransport, 'auto'>, caps: TransportCapabilityReport): boolean {\n    switch (transport) {\n      case 'multicast': return caps.nativeMulticast.confirmed\n      case 'amt': return caps.amt.available\n      case 'moq': return caps.moqRelay.reachable\n    }\n  }\n\n  #defaultPolicy(trackType: 'video' | 'audio'): MigrationPolicy {\n    return DEFAULT_POLICY[trackType]!\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/track-session.d.ts

@@ -0,0 +1,398 @@
+/**
+ * TrackSession — per-track transport state machine.
+ * SessionManager — orchestrates all sessions + TransportPool.
+ *
+ * Implements Patent Claim 9 (draft-ramadan-moq-fec APPLICATION-1):
+ *   (a) subscribe unicast
+ *   (b) simultaneously join multicast
+ *   (c) render from unicast during join
+ *   (d) activate multicast on RAP, suppress unicast
+ *   (e) cross-transport FEC repair during transition
+ *   (f) hysteresis before switching away from multicast
+ *   (g) re-subscribe unicast on sustained failure
+ *
+ * PIM: manages transport state without inspecting packet contents.
+ */
+import { TransportPool, type Subscription, type SubscriptionMode, type TransportPoolOptions } from './transport-pool.js';
+export type TrackState = 'idle' | 'unicast' | 'unicast-fallback' | 'joining' | 'multicast' | 'amt' | 'failing';
+export interface TrackSessionConfig {
+    trackName: string;
+    trackType: 'video' | 'audio';
+    packetId: number;
+    /** FEC interleave depth from catalog (ms). Used for hysteresis timer. */
+    fecInterleaveMs: number;
+    /** Explicit catalog jitter/reorder allowance in ms. */
+    fecReorderToleranceMs?: number;
+    /** FEC K from catalog. Used for audio worklet latency calculation. */
+    fecK: number;
+    /** FEC repair symbols per block (P). NOT symbol size. */
+    fecRepairCount: number;
+    /**
+     * Repair symbols per block this receiver actually joined: the sum of
+     * `repairSymbols` over the joined BASE layers, not a count of layers
+     * (draft-ramadan-moq-fec 6.3). A keyframe overlay is a separate FEC instance
+     * and is not included.
+     *
+     * This is runtime join state, not catalog geometry: a receiver on a clean
+     * path joins layer 0 only while a lossy one adds layers, so the catalog's
+     * total P is not what this receiver is receiving. Diagnostics that report P
+     * (the worker snapshot, CMCD `x-bc-fec-p`) must read this.
+     *
+     * Absent when the caller joins no layers explicitly, in which case P_0 is
+     * what was joined. That is an identity on a single-layer track, not a
+     * catalog default: with one layer, P_0 is the total.
+     */
+    joinedRepairCount?: number;
+    /** FEC symbol size in bytes (T). Required for WASM decoder OTI. */
+    fecSymbolSize: number;
+    /** MoQ repair track name from catalog FEC config. */
+    repairTrackName?: string;
+    /** Frame samples from initData parsing (audio-init-parser.ts). */
+    frameSamples?: number;
+    /** Audio sample rate from catalog. */
+    sampleRate?: number;
+    /** Ordered transport preference: best first. */
+    preferredTransports: SubscriptionMode[];
+    /** Subscription key for multicast/AMT: "(S,G,port)". */
+    multicastKey?: string;
+    /** MoQ track name for unicast subscription. */
+    moqTrackName?: string;
+    /** AMT relay address (if AMT is in preference chain). */
+    amtRelay?: string;
+    /** MoQ relay URL (for WebTransport subscription). */
+    moqRelayUrl?: string;
+}
+export interface SessionManagerCallbacks {
+    /** Fired on every transport state transition. */
+    onStateChange?(trackName: string, from: TrackState, to: TrackState): void;
+    /** Fired to suppress/unsuppress unicast for this track (transport arbitration). */
+    onSuppress?(trackName: string, suppressed: boolean): void;
+    /**
+     * Fired when a track sat in `joining` for SessionManager.takeoverDeadlineMs
+     * without a RAP (BLO-9413/D9). The session has already returned to `unicast`
+     * (nothing was suppressed, so nothing to restore) and it keeps its FEC
+     * decoder armed, because the multicast socket is still joined and the router
+     * still admits the stream's symbols. The host should abandon the router-side
+     * attempt (e.g. MediaRouter.failbackToMoq()) so the router stops waiting for
+     * a keyframe that is never coming; it must not dispose the decoder here. The
+     * decoder is released on the next transport edge (unsubscribe, failbackAll,
+     * or transportFailed falling back to unicast) through fec-teardown.
+     */
+    onTakeoverTimeout?(trackName: string): void;
+}
+/**
+ * MMTP track events (discriminated union).
+ * Each protocol layer defines its own event union — MMTP events cover
+ * media resets, latency, and FEC lifecycle.
+ */
+export type MmtpTrackEvent = {
+    type: 'reset';
+} | {
+    type: 'latency';
+    latencyMs: number;
+} | {
+    type: 'fec-setup';
+} | {
+    type: 'fec-teardown';
+};
+/**
+ * MMTP application-layer extension of SessionManagerCallbacks.
+ * Single onTrackEvent dispatches all MMTP-specific events.
+ * PIM consumers use the base SessionManagerCallbacks (no onTrackEvent).
+ *
+ * IWA can define its own subinterface with its own TrackEvent union
+ * (e.g., IwaTrackEvent for socket health, AMT state) using the same pattern.
+ */
+export interface MmtpSessionCallbacks extends SessionManagerCallbacks {
+    onTrackEvent?(trackName: string, event: MmtpTrackEvent, config: TrackSessionConfig): void;
+}
+/**
+ * Loss-hysteresis window covering the signaled FEC block span plus jitter.
+ *
+ * `fecK` no longer feeds the math; it is still validated as a catalog
+ * well-formedness guard and kept in the signature for positional API compat
+ * (removal is a follow-up with the next cross-repo pin bump).
+ */
+export declare function computeFecLossWindowMs(fecInterleaveMs: number, fecK: number, jitterBufferMs?: number): number;
+export interface FecDeliveryWindowConfig {
+    interleaveDepthMs: number;
+    sourceSymbols: number;
+    repairSymbols?: number;
+    symbolSize?: number;
+    mediaUnitsPerSecond?: number;
+    bandwidthBps?: number;
+    /**
+     * Explicit jitter/reorder allowance in ms, added once to the complete span.
+     * Callers pass their signaled catalog allowance, never a local default.
+     */
+    jitterBufferMs?: number;
+}
+/**
+ * The catalog interleaveDepthMs is the complete FEC block span, including the
+ * repair tail. K, P, cadence, and bandwidth must not expand it again. Geometry
+ * fields remain accepted for existing callers, but do not feed deadline math.
+ */
+export declare function computeFecDeliveryWindowMs(config: FecDeliveryWindowConfig): number;
+/** Convert the shared FEC delivery deadline into an integer media timescale. */
+export declare function computeFecDeliveryWindowMediaUnits(config: FecDeliveryWindowConfig, timestampTimescale: number): number;
+export declare class TrackSession {
+    #private;
+    readonly config: TrackSessionConfig;
+    constructor(config: TrackSessionConfig, manager: SessionManager);
+    get state(): TrackState;
+    get subscription(): Subscription | null;
+    /** True while this session's onSuppress(true) is outstanding (no matching
+     *  onSuppress(false) yet). Test/assertion surface for failback coherence. */
+    get isSuppressed(): boolean;
+    /** Current active transport mode, or null if idle. */
+    get transport(): SubscriptionMode | null;
+    /** Audio worklet latency: max(fecInterleaveMs, frameDurationMs * fecK).
+     *  Returns undefined if frame duration unknown (no initData). */
+    get audioLatencyMs(): number | undefined;
+    /** Frame duration in ms, derived from frameSamples + sampleRate. */
+    get frameDurationMs(): number | undefined;
+    /** idle → unicast: player subscribes to this track. */
+    subscribe(): void;
+    /** unicast → joining: multicast/AMT capability detected, join in progress. */
+    joinStarted(): void;
+    /**
+     * any non-fallback state → unicast-fallback. Used when the SSM bridge is
+     * absent (vanilla Chromium / no extension) and the host falls back to a
+     * MoQ unicast subscription per track. Terminal-ish: activateMulticast,
+     * failbackAll, and transportFailed are no-ops while in this state.
+     *
+     * Fires fec-setup so the per-track repair worker spins up — repair packets
+     * still flow over the MoQ repair-track subscription, so FEC source+repair
+     * can converge as in the multicast path.
+     *
+     * Audio latency is NOT re-emitted here: subscribe() already fires latency
+     * once on the idle → unicast edge, and enterUnicastFallback is only ever
+     * reached from a non-idle state (SessionManager skips idle sessions).
+     */
+    enterUnicastFallback(): void;
+    /**
+     * unicast-fallback → unicast. Called when the SSM bridge appears mid-session
+     * (extension installed after fallback engaged). Host first aborts the fallback
+     * drainers, then transitions sessions back to unicast so the regular
+     * multicast/AMT preference chain can take over via joinStarted().
+     */
+    exitUnicastFallback(): void;
+    /**
+     * joining → multicast or amt: RAP received on the joined transport (Claim 9d).
+     * Resets audio worklet, then suppresses MoQ.
+     */
+    rapReceived(mode: 'multicast' | 'amt'): void;
+    /** multicast/amt → failing: loss detected, start hysteresis timer (Claim 9f). */
+    lossDetected(): void;
+    /** failing → previous primary: loss recovered within hysteresis window. */
+    lossRecovered(): void;
+    /**
+     * Transport failed (AMT relay down, multicast interface gone).
+     * Try next transport in preference chain.
+     */
+    transportFailed(): void;
+    /** Hysteresis expired → failback to next transport (Claim 9g). */
+    hysteresisExpired(): void;
+    /** → idle: player unsubscribes / tab close / cleanup. */
+    unsubscribe(): void;
+    /** True when SessionManager.enterUnicastFallback put this track into the
+     *  host-driven unicast subscription mode. Host can iterate sessions to
+     *  decide whether to keep its fallback drainer alive across MediaRouter
+     *  arbitration events. */
+    get isUnicastFallback(): boolean;
+    /**
+     * True while this track owns a FEC decoder (fec-setup fired, fec-teardown
+     * not yet). Stays true across a takeover timeout that parked the session in
+     * `unicast`; SessionManager.failbackAll uses it to release such sessions.
+     */
+    get isFecArmed(): boolean;
+    /**
+     * Start the deadline a `joining` entry deferred while the join was inactive
+     * (SessionManager.joinActive). The track gets the FULL deadline from here,
+     * because that is when media can first arrive. No-op outside `joining` and
+     * when a deadline is already running, so it never shortens or restarts one.
+     *
+     * The `joinActive` guard is what makes this safe to call from anywhere: a
+     * track parked in `joining` with a deferred (null) timer satisfies the other
+     * two, so without it a host calling this while the join is still inactive
+     * would arm the exact deadline the gate exists to defer -- silently
+     * reinstating BLO-34289. It is a no-op for the internal caller, which writes
+     * `#joinActive = true` before iterating the sessions.
+     */
+    armDeferredJoinDeadline(): void;
+    dispose(): void;
+}
+/**
+ * Largest takeover deadline setTimeout represents faithfully. setTimeout
+ * coerces its delay to a signed 32-bit int, so a larger value fires on the
+ * next tick (Node also warns TimeoutOverflowWarning) instead of after the
+ * window the host asked for -- silently inverting the feature. Rejecting it
+ * keeps the classic units bug (seconds-as-ms, a wrong timescale) loud.
+ */
+export declare const MAX_TAKEOVER_DEADLINE_MS = 2147483647;
+/**
+ * How long `joinActive` may stay false before the library says so. The deferral
+ * is unbounded by construction -- that is the feature -- so a host that never
+ * flips it back parks every track in `joining` with no timer at all: exactly the
+ * forever-join the takeover deadline exists to prevent, only silent. MoQ stays
+ * unsuppressed so the viewer sees video, but onTakeoverTimeout never fires, the
+ * FEC decoder stays armed, and the preference chain never advances past the
+ * transport that failed. It looks like a slow join. A host is one un-awaited
+ * rejection between `false` and `true` away from it, so the library complains
+ * rather than trusting every future host to get all of its exit paths right.
+ *
+ * Generous against a genuinely slow subscribe -- a bridge reconnect or AMT relay
+ * handshake is seconds -- so anything still unsettled here is broken, not slow.
+ */
+export declare const JOIN_DEFER_WARN_MS = 30000;
+export declare class SessionManager {
+    #private;
+    readonly pool: TransportPool;
+    readonly sessions: Map<string, TrackSession>;
+    callbacks: SessionManagerCallbacks | null;
+    /**
+     * Takeover deadline (BLO-9413/D9): the time a session may sit in `joining`
+     * without a RAP before returning to `unicast` and firing onTakeoverTimeout.
+     * MoQ is never suppressed during `joining`, so expiry abandons the takeover
+     * without a playback glitch. The host derives it from the catalog (RAP
+     * cadence from groupDurationTicks/timescale plus the signaled FEC delivery
+     * window or reorder tolerance) and sets it before addTrack(). There is no
+     * default: an unset value fails addTrack() closed, and reading the getter
+     * before assignment throws the same way, so no host ever holds a
+     * `number | undefined` it could coalesce back into a default.
+     * `hasTakeoverDeadline` answers whether one was admitted. A declared 0
+     * disables the deadline. The value is an integer number of milliseconds:
+     * setTimeout truncates fractions, so a host that divides ticks by a
+     * timescale must round before assigning.
+     *
+     * Assignment validates, so the diagnostic lands at the host's own call site.
+     * That is what bounds the blast radius: `joining` is entered from
+     * joinStarted(), from the transportFailed() failover branch -- itself
+     * reachable from a setTimeout via hysteresisExpired(), where no caller could
+     * catch a throw -- and from the activateMulticast()/activateAmt()/pool-failure
+     * loops, where a throw on one session would abandon its siblings mid-loop
+     * (the split-brain those loops exist to prevent). Refusing a bad value at
+     * assignment means no host mutation can make an already-admitted session
+     * throw out of a transport edge.
+     */
+    get takeoverDeadlineMs(): number;
+    set takeoverDeadlineMs(value: number);
+    /** True once the host has admitted a deadline; a declared 0 counts. */
+    get hasTakeoverDeadline(): boolean;
+    /**
+     * Whether the transport the joining tracks are waiting on is actually
+     * subscribed. The takeover deadline is a media-arrival budget and media
+     * cannot arrive before the join exists, so while this is false, entering
+     * `joining` arms no deadline; flipping it true starts the FULL deadline for
+     * every track already parked there.
+     *
+     * Default true, which is the arm-on-`joining` behaviour every host had
+     * before: a host that only calls joinStarted() after its own join resolves
+     * (moqtail-private's player, post-BLO-33339) is already at the right edge and
+     * needs no gate. A host that arms joinStarted() up front — to have FEC
+     * decoders ready before the first datagram — sets this false before addTrack()
+     * and true when its subscribe settles. Charging a slow subscribe (bridge
+     * reconnect, AMT relay handshake) against the media budget expired the
+     * deadline before the subscription existed and abandoned the join on the
+     * happy path. BLO-34289.
+     *
+     * The flag tracks the host's primary join, not per-track transport state. A
+     * track that fails over to the next transport in its own chain while this is
+     * false (transportFailed's failover branch also enters `joining`) has that
+     * deadline gated on the primary join activating, not on its own transport.
+     * Under the documented usage -- false once at setup, true once the subscribe
+     * settles -- the two coincide.
+     *
+     * The gate is on the ENTRY into `joining`, and false cannot take back a
+     * deadline already running: the `true -> false` edge arms the warn below and
+     * clears nothing. So set it false BEFORE the `joining` entry it is meant to
+     * gate. A host that instead flipped it false after a `transportFailed()`
+     * failover had already entered `joining` would leave the full deadline
+     * counting against a subscribe that had not begun -- BLO-34289 again, on the
+     * failover edge. Clearing running deadlines on that edge is deliberately NOT
+     * done: this flag is manager-wide, so one transport's brief false would
+     * cancel an unrelated track's live deadline and then re-arm it at FULL length
+     * on the next activation (armDeferredJoinDeadline sees `joining` + a null
+     * timer and cannot tell a cleared deadline from a deferred one). Every
+     * unrelated transport blip would restart the whole budget, so under repeated
+     * failover a track that should have timed out is extended indefinitely and
+     * never advances. Only a false that never returns true loses the timer
+     * outright, and JOIN_DEFER_WARN_MS already covers that.
+     *
+     * Leaving this false is not free: see JOIN_DEFER_WARN_MS.
+     */
+    get joinActive(): boolean;
+    set joinActive(active: boolean);
+    /** Narrow to MMTP callbacks (onTrackEvent). Safe — optional chaining handles PIM-only consumers. */
+    get mmtp(): MmtpSessionCallbacks | null;
+    constructor(poolOptions?: TransportPoolOptions);
+    /** Add a track session from catalog config. */
+    addTrack(config: TrackSessionConfig): TrackSession;
+    /** Remove a track session. Releases subscription with grace period. */
+    removeTrack(trackName: string): void;
+    /**
+     * All tracks with multicast RAP → multicast state (atomic).
+     * Called when MediaRouter fires onSourceSwitch('multicast').
+     * Prevents split-brain between video and audio.
+     *
+     * A takeover deadline can return a track from `joining` to `unicast` while
+     * the multicast socket keeps delivering packets and the track keeps its FEC
+     * decoder armed. If a valid RAP arrives later, that late-RAP edge suppresses
+     * unicast and promotes multicast without a second fec-setup.
+     */
+    activateMulticast(): void;
+    /**
+     * All tracks with AMT RAP → amt state (atomic).
+     */
+    activateAmt(): void;
+    /**
+     * All tracks → unicast (failback, atomic).
+     * Called when MulticastManager fires onFailback().
+     * unicast-fallback sessions are skipped — the host owns those subscriptions
+     * and they must drain uninterrupted across transport-state events.
+     *
+     * Coherence invariant (BLO-9413): after this returns, every non-fallback
+     * session is `unicast` (or `idle`), unsuppressed, and without a FEC decoder.
+     * unsubscribe() unwinds any outstanding suppression regardless of the state
+     * it tears down from (`failing` included; see TrackSession.#suppressFired),
+     * and a session that a takeover timeout parked in `unicast` with its decoder
+     * still armed is cycled too, because this transport edge is what releases
+     * that decoder (unsubscribe fires fec-teardown).
+     */
+    failbackAll(): void;
+    /**
+     * All tracks → unicast-fallback (atomic).
+     * Called by the host when the multicast gateway is absent and
+     * the player will subscribe to source tracks over MoQ unicast and feed
+     * packets via MulticastManager.feedUnicastSource() (or manager.router
+     * directly). Sessions in this state stay terminal until the host calls
+     * unsubscribe() / disposes the SessionManager.
+     */
+    enterUnicastFallback(): void;
+    /**
+     * True if any session is currently in unicast-fallback. Hosts use this to
+     * gate `multicastTrack.close()` on failback events — closing the shared
+     * broadcast would kill the host's fallback drainers.
+     */
+    hasActiveFallback(): boolean;
+    /**
+     * All fallback tracks → unicast (atomic).
+     * Called when the SSM bridge appears mid-session and the host has aborted
+     * the fallback drainers. The session re-enters the regular preference chain
+     * via joinStarted() (issued by the host immediately after).
+     */
+    exitUnicastFallback(): void;
+    /** Tab closed — release all subscriptions for this tab (grace period). */
+    tabClosed(tabId: string): void;
+    /** Bridge WebTransport connection dropped — same as tab close. */
+    bridgeDisconnected(): void;
+    /**
+     * Track selection changed (user or ABR).
+     * Old track released (grace period), new track subscribed.
+     */
+    trackSelectionChanged(oldTrackName: string, newConfig: TrackSessionConfig): void;
+    /** Get a track session by name. */
+    getTrack(trackName: string): TrackSession | undefined;
+    dispose(): void;
+}
+//# sourceMappingURL=track-session.d.ts.map