@openmoq/playback 0.0.0-stage → 0.6.1

package/dist/browser/index.js

@@ -0,0 +1,2788 @@
+// src/jitter-buffer.ts
+function compare(a, b) {
+  if (a.groupId < b.groupId) return -1;
+  if (a.groupId > b.groupId) return 1;
+  if (a.objectId < b.objectId) return -1;
+  if (a.objectId > b.objectId) return 1;
+  return 0;
+}
+var JitterBuffer = class {
+  heap = [];
+  maxDepth;
+  constructor(maxDepth) {
+    this.maxDepth = maxDepth;
+  }
+  /** Number of objects currently buffered. */
+  get size() {
+    return this.heap.length;
+  }
+  /**
+   * Insert an object into the buffer.
+   * @returns true if accepted, false if buffer is full.
+   */
+  insert(obj) {
+    if (this.heap.length >= this.maxDepth) return false;
+    this.heap.push(obj);
+    this.bubbleUp(this.heap.length - 1);
+    return true;
+  }
+  /**
+   * Peek at the minimum object without removing it.
+   */
+  peek() {
+    return this.heap[0];
+  }
+  /**
+   * Remove and return the minimum object.
+   */
+  extract() {
+    if (this.heap.length === 0) return void 0;
+    const min = this.heap[0];
+    const last = this.heap.pop();
+    if (this.heap.length > 0) {
+      this.heap[0] = last;
+      this.sinkDown(0);
+    }
+    return min;
+  }
+  /**
+   * Check if the object at (groupId, objectId) is the minimum in the buffer.
+   */
+  hasContiguous(groupId, objectId) {
+    if (this.heap.length === 0) return false;
+    const top = this.heap[0];
+    return top.groupId === groupId && top.objectId === objectId;
+  }
+  /**
+   * Remove and return all objects for a given group, in sorted order.
+   */
+  drainGroup(groupId) {
+    const result = [];
+    const remaining = [];
+    for (const obj of this.heap) {
+      if (obj.groupId === groupId) {
+        result.push(obj);
+      } else {
+        remaining.push(obj);
+      }
+    }
+    result.sort(compare);
+    this.heap.length = 0;
+    for (const obj of remaining) {
+      this.heap.push(obj);
+    }
+    this.rebuild();
+    return result;
+  }
+  /**
+   * Remove all objects with groupId less than the given threshold.
+   * @returns Number of objects removed.
+   */
+  discardBefore(groupId) {
+    const remaining = [];
+    let removed = 0;
+    for (const obj of this.heap) {
+      if (obj.groupId < groupId) {
+        removed++;
+      } else {
+        remaining.push(obj);
+      }
+    }
+    this.heap.length = 0;
+    for (const obj of remaining) {
+      this.heap.push(obj);
+    }
+    this.rebuild();
+    return removed;
+  }
+  /**
+   * Evict the least-important object from the buffer.
+   *
+   * Finds the data object with the highest publisherPriority number
+   * (= lowest importance per §7: "lower priority number indicates higher
+   * priority"). Tiebreaker: oldest group (lowest groupId).
+   *
+   * Gap objects and objects with undefined priority are not evictable.
+   *
+   * @returns The evicted object, or undefined if no candidate exists.
+   * @see draft-ietf-moq-transport-16 §7 (Priority-based dropping)
+   */
+  evictLowestImportance() {
+    if (this.heap.length === 0) return void 0;
+    let worstIdx = -1;
+    let worstPriority = -1;
+    let worstGroupId = -1n;
+    for (let i = 0; i < this.heap.length; i++) {
+      const obj = this.heap[i];
+      if (obj.kind !== "data" || obj.publisherPriority === void 0) continue;
+      const p = obj.publisherPriority;
+      if (p > worstPriority || p === worstPriority && obj.groupId < worstGroupId) {
+        worstIdx = i;
+        worstPriority = p;
+        worstGroupId = obj.groupId;
+      }
+    }
+    if (worstIdx === -1) return void 0;
+    const evicted = this.heap[worstIdx];
+    const last = this.heap.pop();
+    if (worstIdx < this.heap.length) {
+      this.heap[worstIdx] = last;
+      this.rebuild();
+    }
+    return evicted;
+  }
+  /**
+   * Clear all buffered objects.
+   */
+  clear() {
+    this.heap.length = 0;
+  }
+  // ─── Heap internals ─────────────────────────────────────────────
+  bubbleUp(index) {
+    while (index > 0) {
+      const parentIdx = index - 1 >> 1;
+      if (compare(this.heap[index], this.heap[parentIdx]) >= 0) break;
+      this.swap(index, parentIdx);
+      index = parentIdx;
+    }
+  }
+  sinkDown(index) {
+    const length = this.heap.length;
+    while (true) {
+      let smallest = index;
+      const left = 2 * index + 1;
+      const right = 2 * index + 2;
+      if (left < length && compare(this.heap[left], this.heap[smallest]) < 0) {
+        smallest = left;
+      }
+      if (right < length && compare(this.heap[right], this.heap[smallest]) < 0) {
+        smallest = right;
+      }
+      if (smallest === index) break;
+      this.swap(index, smallest);
+      index = smallest;
+    }
+  }
+  swap(i, j) {
+    const tmp = this.heap[i];
+    this.heap[i] = this.heap[j];
+    this.heap[j] = tmp;
+  }
+  /** Rebuild the heap from an unordered array (O(n)). */
+  rebuild() {
+    for (let i = (this.heap.length >> 1) - 1; i >= 0; i--) {
+      this.sinkDown(i);
+    }
+  }
+};
+
+// src/gap-detector.ts
+var GapAction = {
+  /** Continue waiting for the missing group. */
+  WAIT: "wait",
+  /** Skip forward to the next available group with a keyframe. */
+  SKIP_FORWARD: "skip_forward",
+  /** Track has ended. */
+  TRACK_ENDED: "track_ended"
+};
+var GapDetector = class {
+  _gapTimeoutUs;
+  clock;
+  /** Set of group IDs explicitly terminated via END_OF_GROUP. */
+  endedGroups = /* @__PURE__ */ new Set();
+  /** Whether END_OF_TRACK has been received. */
+  trackEnded = false;
+  /** Earliest observation time for each group. */
+  groupFirstSeenUs = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this._gapTimeoutUs = config.gapTimeoutUs;
+    this.clock = config.clock;
+  }
+  /** Current gap timeout in microseconds. Mutable for adaptive tolerance. */
+  get gapTimeoutUs() {
+    return this._gapTimeoutUs;
+  }
+  set gapTimeoutUs(value) {
+    this._gapTimeoutUs = value;
+  }
+  /**
+   * Notify that an object has been received for a group.
+   * Records the observation time for timeout calculations.
+   */
+  observeGroup(groupId) {
+    if (!this.groupFirstSeenUs.has(groupId)) {
+      this.groupFirstSeenUs.set(groupId, this.clock.now());
+    }
+  }
+  /**
+   * Notify that an END_OF_GROUP status was received.
+   * @see draft-ietf-moq-transport-16 §10.2.1.1 — ObjectStatus 0x3
+   */
+  observeEndOfGroup(groupId) {
+    this.endedGroups.add(groupId);
+  }
+  /**
+   * Notify that an END_OF_TRACK status was received.
+   * @see draft-ietf-moq-transport-16 §10.2.1.1 — ObjectStatus 0x4
+   */
+  observeEndOfTrack() {
+    this.trackEnded = true;
+  }
+  /** Whether the track has ended. */
+  get isTrackEnded() {
+    return this.trackEnded;
+  }
+  /** Reset all state — used when resuming after pause on a live stream. */
+  reset() {
+    this.endedGroups.clear();
+    this.trackEnded = false;
+    this.groupFirstSeenUs.clear();
+  }
+  /**
+   * Evaluate the current gap state.
+   *
+   * @param lastConsumedGroupId The last group fully consumed by the decoder
+   * @param availableGroupIds Groups currently buffered (sorted ascending)
+   * @returns Decision: WAIT, SKIP_FORWARD, or TRACK_ENDED
+   */
+  evaluate(lastConsumedGroupId, availableGroupIds) {
+    if (this.trackEnded) {
+      return { action: GapAction.TRACK_ENDED };
+    }
+    if (availableGroupIds.length === 0) {
+      return { action: GapAction.WAIT };
+    }
+    const nextExpected = lastConsumedGroupId + 1n;
+    const sorted = [...availableGroupIds].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    const firstAvailable = sorted[0];
+    if (firstAvailable <= nextExpected) {
+      return { action: GapAction.WAIT };
+    }
+    let allEnded = true;
+    for (let g = nextExpected; g < firstAvailable; g++) {
+      if (!this.endedGroups.has(g)) {
+        allEnded = false;
+        break;
+      }
+    }
+    if (allEnded) {
+      return { action: GapAction.SKIP_FORWARD, targetGroupId: firstAvailable };
+    }
+    const now = this.clock.now();
+    const firstSeenAt = this.groupFirstSeenUs.get(firstAvailable);
+    if (firstSeenAt !== void 0) {
+      const elapsed = now - firstSeenAt;
+      if (elapsed >= this.gapTimeoutUs) {
+        return { action: GapAction.SKIP_FORWARD, targetGroupId: firstAvailable };
+      }
+    }
+    return { action: GapAction.WAIT };
+  }
+};
+
+// src/decoder-state.ts
+var DecoderState = {
+  /** Not yet configured. */
+  IDLE: "idle",
+  /** Configured but waiting for a keyframe. */
+  NEEDS_KEYFRAME: "needs_keyframe",
+  /** Actively decoding. */
+  DECODING: "decoding",
+  /** Track ended. */
+  ENDED: "ended"
+};
+var DecoderStateMachine = class {
+  _state = DecoderState.IDLE;
+  _mediaType;
+  lastConfig = null;
+  constructor(mediaType) {
+    this._mediaType = mediaType;
+  }
+  get state() {
+    return this._state;
+  }
+  get mediaType() {
+    return this._mediaType;
+  }
+  /**
+   * Provide codec configuration.
+   *
+   * If the config is identical to the last one, skip reconfiguration
+   * (stay in current state). This avoids resetting to NEEDS_KEYFRAME
+   * on every group boundary when the server sends videoConfig on
+   * every group's first object with unchanged codec parameters.
+   *
+   * Transitions IDLE/DECODING → NEEDS_KEYFRAME (video) or DECODING (audio)
+   * only when the config actually changes.
+   */
+  configure(config) {
+    if (this.lastConfig !== null && this.configEquals(this.lastConfig, config)) {
+      return { action: "skip", reason: "config unchanged" };
+    }
+    this.lastConfig = config;
+    if (this._mediaType === "audio") {
+      this._state = DecoderState.DECODING;
+    } else {
+      this._state = DecoderState.NEEDS_KEYFRAME;
+    }
+    return { action: "configure", config };
+  }
+  /** Byte-level config comparison. */
+  configEquals(a, b) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) return false;
+    }
+    return true;
+  }
+  /**
+   * Process a video chunk.
+   * @see draft-ietf-moq-loc-01 §2.3.2.2 (VideoFrameMarking)
+   */
+  processVideoChunk(chunk, marking) {
+    if (this._state === DecoderState.IDLE || this._state === DecoderState.ENDED) {
+      return { action: "skip", reason: `decoder is ${this._state}` };
+    }
+    if (this._state === DecoderState.NEEDS_KEYFRAME) {
+      const isKeyframe = marking?.independent === true;
+      if (!isKeyframe) {
+        return { action: "skip", reason: "waiting for keyframe" };
+      }
+      this._state = DecoderState.DECODING;
+      return { action: "decode", chunk };
+    }
+    return { action: "decode", chunk };
+  }
+  /**
+   * Process an audio chunk. Audio codecs (Opus, AAC-LC) produce
+   * independently decodable frames — no keyframe gating needed.
+   */
+  processAudioChunk(chunk) {
+    if (this._state === DecoderState.IDLE || this._state === DecoderState.ENDED) {
+      return { action: "skip", reason: `decoder is ${this._state}` };
+    }
+    this._state = DecoderState.DECODING;
+    return { action: "decode", chunk };
+  }
+  /**
+   * Signal a gap — decoder needs to wait for next keyframe (video only).
+   * Audio: stays in DECODING since all chunks are independently decodable.
+   */
+  notifyGap() {
+    if (this._mediaType === "audio") {
+      return { action: "reset", reason: "gap detected (audio will resume immediately)" };
+    }
+    this._state = DecoderState.NEEDS_KEYFRAME;
+    return { action: "reset", reason: "gap detected" };
+  }
+  /**
+   * Signal track ended.
+   * @see draft-ietf-moq-transport-16 §10.2.1.1
+   */
+  notifyTrackEnded() {
+    this._state = DecoderState.ENDED;
+    return { action: "flush" };
+  }
+};
+
+// src/sync.ts
+var DEFAULT_DROP_THRESHOLD_US = 5e5;
+var DEFAULT_WALL_CLOCK = { now: () => Date.now() * 1e3 };
+var SyncController = class {
+  _driftThresholdUs;
+  dropThresholdUs;
+  clock;
+  /** Local clock time when audio reference was set. */
+  localBaselineUs;
+  /** CaptureTimestamp of the audio reference sample. */
+  captureBaselineUs;
+  /** Accumulated drift measurement. */
+  _currentDriftUs = 0;
+  /**
+   * Video join offset — shifts video render times forward during live join.
+   *
+   * When joining a live stream, video starts from the GOP boundary
+   * (which has an older CaptureTimestamp than the current audio).
+   * This offset shifts video render times forward so the first frames
+   * render in the future instead of the past, preventing startup stutter.
+   *
+   * Snaps to zero when the video timeline catches up to the audio live edge.
+   * Audio render times are unaffected.
+   */
+  _videoJoinOffsetUs = 0;
+  // ── Catch-up state ─────────────────────────────────────────
+  wallClock;
+  targetLatencyMs;
+  maxCatchUpRate;
+  catchUpThresholdMs;
+  catchUpRecoveryMs;
+  _catchUpActive = false;
+  _currentRate = 1;
+  _lastLatencyUs = 0;
+  constructor(config) {
+    this._driftThresholdUs = config.driftThresholdUs;
+    this.dropThresholdUs = config.dropThresholdUs ?? DEFAULT_DROP_THRESHOLD_US;
+    this.clock = config.clock;
+    this.wallClock = config.wallClock ?? DEFAULT_WALL_CLOCK;
+    this.targetLatencyMs = config.targetLatencyMs;
+    this.maxCatchUpRate = config.maxCatchUpRate ?? 1;
+    this.catchUpThresholdMs = config.catchUpThresholdMs ?? 500;
+    this.catchUpRecoveryMs = config.catchUpRecoveryMs ?? 50;
+  }
+  /** Whether a sync reference has been established. */
+  get hasReference() {
+    return this.localBaselineUs !== void 0;
+  }
+  /** Current drift magnitude in microseconds. */
+  get currentDriftUs() {
+    return this._currentDriftUs;
+  }
+  /** Current drift threshold in microseconds. Mutable for adaptive tolerance. */
+  get driftThresholdUs() {
+    return this._driftThresholdUs;
+  }
+  set driftThresholdUs(value) {
+    this._driftThresholdUs = value;
+  }
+  /**
+   * Whether PRESENTATION SCHEDULE drift exceeds the threshold.
+   *
+   * Deliberately has NO live-join suppression. The exact queued schedule
+   * already contains the join offset, so missing that schedule during a join
+   * is a real miss. (The legacy PTS-era metric needed the suppression because
+   * the offset itself showed up as drift; see {@link needsResync}.)
+   */
+  get presentationDriftExceeded() {
+    return Math.abs(this._currentDriftUs) >= this._driftThresholdUs;
+  }
+  /**
+   * @deprecated Threshold check for the legacy {@link reportActualRenderTime}
+   * metric, retaining its live-join suppression. Use
+   * {@link presentationDriftExceeded} with schedule-based measurement.
+   */
+  get needsResync() {
+    if (this._videoJoinOffsetUs > 0) return false;
+    return Math.abs(this._currentDriftUs) >= this._driftThresholdUs;
+  }
+  /** Whether catch-up is currently active. */
+  get catchUpActive() {
+    return this._catchUpActive;
+  }
+  /** Current playback rate (1.0 when catch-up inactive). */
+  get currentRate() {
+    return this._currentRate;
+  }
+  /**
+   * Last measured latency in microseconds.
+   * 0 before first measurement.
+   * @see draft-ietf-moq-loc-01 §2.3.1.1
+   */
+  get latencyUs() {
+    return this._lastLatencyUs;
+  }
+  /**
+   * Establish sync reference from an audio sample.
+   * Maps captureTimestamp to the current local clock time.
+   * Resets drift measurement.
+   *
+   * @param captureTimestampUs CaptureTimestamp in microseconds
+   */
+  setAudioReference(captureTimestampUs) {
+    this.localBaselineUs = this.clock.now();
+    this.captureBaselineUs = captureTimestampUs;
+    this._currentDriftUs = 0;
+  }
+  /**
+   * Establish sync reference from a video frame (video-only mode).
+   * No-op if a reference already exists — audio has priority.
+   *
+   * @param captureTimestampUs CaptureTimestamp of the first video frame
+   */
+  setVideoReference(captureTimestampUs) {
+    if (this.hasReference) return;
+    this.localBaselineUs = this.clock.now();
+    this.captureBaselineUs = captureTimestampUs;
+    this._currentDriftUs = 0;
+  }
+  /** Current video join offset in microseconds. 0 = no offset active. */
+  get videoJoinOffsetUs() {
+    return this._videoJoinOffsetUs;
+  }
+  /**
+   * Apply video join re-anchor for live stream join.
+   *
+   * Called when the first video keyframe is decoded after a live join.
+   * Computes an offset that shifts video render times forward so the
+   * first frame renders at `now + cushion` instead of in the past.
+   *
+   * The offset is a constant added to all video render times. It preserves
+   * inter-frame timing (33ms spacing) while shifting the whole timeline.
+   * Snaps to zero when video catches up to the live edge.
+   *
+   * @param firstKeyframeCaptureUs CaptureTimestamp of the first keyframe
+   * @param cushionUs Extra future cushion (default: 16ms ≈ 1 rAF tick)
+   */
+  onVideoJoin(firstKeyframeCaptureUs, cushionUs = 16e3) {
+    if (this.localBaselineUs === void 0 || this.captureBaselineUs === void 0) return;
+    const naiveRenderTimeUs = this.localBaselineUs + Number(firstKeyframeCaptureUs - this.captureBaselineUs);
+    const nowUs = this.clock.now();
+    const gapUs = nowUs + cushionUs - naiveRenderTimeUs;
+    if (gapUs > 0) {
+      this._videoJoinOffsetUs = gapUs;
+    }
+  }
+  /**
+   * Compute render timing for a video frame.
+   *
+   * @param captureTimestampUs CaptureTimestamp in microseconds
+   */
+  computeVideoRenderTime(captureTimestampUs) {
+    const timing = this.computeRenderTime(captureTimestampUs);
+    if (timing === null) return null;
+    if (this._videoJoinOffsetUs > 0) {
+      const adjustedRenderTimeUs = timing.renderTimeUs + this._videoJoinOffsetUs;
+      const nowUs = this.clock.now();
+      if (timing.renderTimeUs > nowUs) {
+        this._videoJoinOffsetUs = 0;
+        return timing;
+      }
+      const offsetUs = adjustedRenderTimeUs - nowUs;
+      return {
+        renderTimeUs: adjustedRenderTimeUs,
+        offsetUs,
+        shouldDrop: offsetUs < -this.dropThresholdUs
+      };
+    }
+    return timing;
+  }
+  /**
+   * Compute render timing for an audio sample.
+   *
+   * @param captureTimestampUs CaptureTimestamp in microseconds
+   */
+  computeAudioRenderTime(captureTimestampUs) {
+    return this.computeRenderTime(captureTimestampUs);
+  }
+  /**
+   * Record PRESENTATION SCHEDULE drift: did the renderer present the frame
+   * when it was told to?
+   *
+   * `scheduledUs` must be the EXACT timestamp stored with the rendered frame.
+   * It already accounts for the playout cushion actually applied to that
+   * frame, the live-join offset, decode-output recomputation and late-frame
+   * handling — none of which may be recomputed or subtracted later, because an
+   * adaptive cushion can move between enqueue and presentation.
+   *
+   * The schedule is REQUIRED here. Optionality lives at
+   * `FrameRenderedFeedback`, where the pipeline suppresses the whole
+   * measurement/event transaction cleanly: missing evidence is not drift.
+   *
+   * Actual audio/video skew is measured separately as `sync_skew`.
+   */
+  reportPresentationTiming(scheduledUs, actualUs) {
+    this._currentDriftUs = actualUs - scheduledUs;
+  }
+  /**
+   * @deprecated Compares against the UNCUSHIONED PTS-anchored time, so a
+   * stream presenting exactly on its intended schedule reports the whole
+   * playout cushion as drift. Retained as a compatibility path only; use
+   * {@link reportPresentationTiming}.
+   */
+  reportActualRenderTime(captureTimestampUs, actualLocalUs) {
+    if (this.localBaselineUs === void 0 || this.captureBaselineUs === void 0) return;
+    const expectedRenderUs = this.localBaselineUs + Number(captureTimestampUs - this.captureBaselineUs);
+    this._currentDriftUs = actualLocalUs - expectedRenderUs;
+  }
+  // ─── Live Catch-Up ──────────────────────────────────────────────
+  /**
+   * Measure end-to-end latency from a wall-clock timestamp.
+   *
+   * Compares the publisher's wall-clock timestamp to the subscriber's
+   * wall clock, both in Unix epoch microseconds. A media-time timestamp
+   * (LOC-04 with Timescale) has no wall-clock meaning, so latency is
+   * unmeasurable and this returns null.
+   *
+   * @param captureTimestampUs Timestamp in microseconds
+   * @param isWallClock False when the timestamp is media time. Undefined means wall clock.
+   * @returns Latency in microseconds, or null if unmeasurable
+   * @see draft-ietf-moq-loc-01 §2.3.1.1
+   * @see draft-ietf-moq-loc-04 §2.3.1.2
+   */
+  measureLatency(captureTimestampUs, isWallClock) {
+    if (captureTimestampUs === 0n || isWallClock === false) return null;
+    return this.wallClock.now() - Number(captureTimestampUs);
+  }
+  /**
+   * Evaluate catch-up state based on current latency.
+   *
+   * Hysteresis: activates when latency > target + threshold,
+   * deactivates when latency <= target + recovery.
+   *
+   * Rate is proportional to overshoot, quantized to 0.05x increments.
+   *
+   * @param captureTimestampUs CaptureTimestamp in microseconds (Unix epoch)
+   * @returns CatchUpState if evaluated, null if catch-up is disabled or no timestamp
+   * @see draft-ietf-moq-msf-00 §5.1.16 (targetLatency)
+   */
+  evaluateCatchUp(captureTimestampUs, isWallClock) {
+    const latencyUs = this.measureLatency(captureTimestampUs, isWallClock);
+    if (latencyUs === null) return null;
+    this._lastLatencyUs = latencyUs;
+    if (this.targetLatencyMs === void 0 || this.maxCatchUpRate <= 1) return null;
+    const latencyMs = latencyUs / 1e3;
+    const targetMs = this.targetLatencyMs;
+    if (!this._catchUpActive && latencyMs > targetMs + this.catchUpThresholdMs) {
+      this._catchUpActive = true;
+    } else if (this._catchUpActive && latencyMs <= targetMs + this.catchUpRecoveryMs) {
+      this._catchUpActive = false;
+      this._currentRate = 1;
+      return { active: false, currentRate: 1, latencyMs, targetMs };
+    }
+    if (this._catchUpActive) {
+      const overshoot = latencyMs - targetMs;
+      const ratio = Math.min(Math.max(overshoot / this.catchUpThresholdMs, 0), 1);
+      const rawRate = 1 + (this.maxCatchUpRate - 1) * ratio;
+      const quantized = Math.round(rawRate * 20) / 20;
+      this._currentRate = Math.min(Math.max(quantized, 1), this.maxCatchUpRate);
+    }
+    return {
+      active: this._catchUpActive,
+      currentRate: this._currentRate,
+      latencyMs,
+      targetMs
+    };
+  }
+  /**
+   * Reset the sync reference (e.g., after a skip-forward).
+   */
+  reset() {
+    this.localBaselineUs = void 0;
+    this.captureBaselineUs = void 0;
+    this._currentDriftUs = 0;
+    this._videoJoinOffsetUs = 0;
+    this._catchUpActive = false;
+    this._currentRate = 1;
+  }
+  // ─── Internal ───────────────────────────────────────────────────
+  computeRenderTime(captureTimestampUs) {
+    if (this.localBaselineUs === void 0 || this.captureBaselineUs === void 0) {
+      return null;
+    }
+    const now = this.clock.now();
+    const renderTimeUs = this.localBaselineUs + Number(captureTimestampUs - this.captureBaselineUs);
+    const offsetUs = renderTimeUs - now;
+    const shouldDrop = offsetUs < -this.dropThresholdUs;
+    return { renderTimeUs, offsetUs, shouldDrop };
+  }
+};
+
+// src/recovery.ts
+var DefaultRecoveryController = class {
+  gapEscalationThreshold;
+  maxDecodeErrors;
+  windowedThreshold;
+  windowedWindowUs;
+  stallThresholdMs;
+  clock;
+  /** Consecutive gap events without a successful decode. */
+  consecutiveGaps = 0;
+  /**
+   * True after reduce_quality fires — gates further escalation until
+   * notifySuccess() confirms the quality reduction helped.
+   */
+  qualityReductionPending = false;
+  /** Number of decode errors seen (for escalation). */
+  decodeErrorCount = 0;
+  /** Timestamps (µs) of recent gap events for windowed escalation. */
+  gapTimestamps = [];
+  constructor(config) {
+    this.gapEscalationThreshold = config?.gapEscalationThreshold ?? 3;
+    this.maxDecodeErrors = config?.maxDecodeErrors ?? 2;
+    this.windowedThreshold = config?.windowedEscalationThreshold ?? 5;
+    this.windowedWindowUs = (config?.windowedEscalationWindowMs ?? 3e4) * 1e3;
+    this.stallThresholdMs = config?.stallThresholdMs ?? 300;
+    this.clock = null;
+  }
+  /**
+   * Attach a clock source for windowed escalation. Without a clock
+   * the windowed path is silently disabled (consecutive-only policy).
+   * Kept as a setter rather than a constructor param so existing
+   * callers that don't need windowed escalation don't break.
+   */
+  setClock(clock) {
+    this.clock = clock;
+  }
+  evaluate(trigger) {
+    switch (trigger.type) {
+      case "gap":
+        return this.handleGap();
+      case "stall":
+        return this.handleStall(trigger.durationMs);
+      case "buffer_overflow":
+        return this.escalateOrSkip("jitter buffer overflow");
+      case "too_far_behind":
+        return this.escalateOrSkip("server reported TOO_FAR_BEHIND");
+      case "delivery_timeout":
+        return { type: "resubscribe" };
+      case "decode_error":
+        return this.handleDecodeError(trigger.message);
+    }
+  }
+  /**
+   * Signal that a frame was successfully decoded/rendered.
+   *
+   * Resets the consecutive gap counter and re-arms quality escalation.
+   * This closes the feedback loop: gaps → reduce_quality → better frames
+   * arrive → notifySuccess → ready for next escalation if needed.
+   */
+  notifySuccess() {
+    this.consecutiveGaps = 0;
+    this.qualityReductionPending = false;
+  }
+  /** Reset all state — e.g., after pause→resume. */
+  reset() {
+    this.consecutiveGaps = 0;
+    this.qualityReductionPending = false;
+    this.decodeErrorCount = 0;
+    this.gapTimestamps.length = 0;
+  }
+  // ─── Internal ───────────────────────────────────────────────────
+  /**
+   * Request quality reduction, gated by the pending flag.
+   * If a reduce_quality is already pending (waiting for notifySuccess),
+   * return skip_forward instead to prevent spam.
+   */
+  escalateOrSkip(reason) {
+    if (this.qualityReductionPending) {
+      return { type: "skip_forward" };
+    }
+    this.qualityReductionPending = true;
+    return { type: "reduce_quality", reason };
+  }
+  handleGap() {
+    this.consecutiveGaps++;
+    if (this.consecutiveGaps >= this.gapEscalationThreshold) {
+      this.consecutiveGaps = 0;
+      this.gapTimestamps.length = 0;
+      return this.escalateOrSkip("repeated gaps detected");
+    }
+    if (this.clock) {
+      const now = this.clock.now();
+      this.gapTimestamps.push(now);
+      const cutoff = now - this.windowedWindowUs;
+      while (this.gapTimestamps.length > 0 && this.gapTimestamps[0] < cutoff) {
+        this.gapTimestamps.shift();
+      }
+      if (this.gapTimestamps.length >= this.windowedThreshold) {
+        this.gapTimestamps.length = 0;
+        this.consecutiveGaps = 0;
+        return this.escalateOrSkip("repeated stalls within window");
+      }
+    }
+    return { type: "skip_forward" };
+  }
+  /**
+   * Relay signals overload via PUBLISH_DONE/TOO_FAR_BEHIND (§9.13);
+   * network bottlenecks produce no server signal, so the player must
+   * self-detect via stall rate.
+   */
+  handleStall(durationMs) {
+    if (durationMs < this.stallThresholdMs) {
+      return { type: "skip_forward" };
+    }
+    if (this.clock) {
+      const now = this.clock.now();
+      this.gapTimestamps.push(now);
+      const cutoff = now - this.windowedWindowUs;
+      while (this.gapTimestamps.length > 0 && this.gapTimestamps[0] < cutoff) {
+        this.gapTimestamps.shift();
+      }
+      if (this.gapTimestamps.length >= this.windowedThreshold) {
+        this.gapTimestamps.length = 0;
+        return this.escalateOrSkip("sustained stalls within window");
+      }
+    }
+    return { type: "skip_forward" };
+  }
+  handleDecodeError(message) {
+    this.decodeErrorCount++;
+    if (this.decodeErrorCount >= this.maxDecodeErrors) {
+      return { type: "terminate", reason: `repeated decode error: ${message}` };
+    }
+    return { type: "resubscribe" };
+  }
+};
+
+// src/adaptive-tolerance.ts
+var RecoveryPhase = {
+  /** Baseline — no active jitter issues. */
+  Normal: "normal",
+  /** Gap detected, observing whether transient or persistent. */
+  Monitoring: "monitoring",
+  /** Persistent gap — waiting with extended timeout before skipping. */
+  ExtendedWait: "extended_wait"
+};
+var DEFAULT_TOLERANCE_CONFIG = {
+  emaAlpha: 0.125,
+  // 1/8 — RFC 6298 gain
+  varianceAlpha: 0.25,
+  // 1/4 — RFC 6298 gain
+  slidingWindowSize: 128,
+  // ~4s at 30fps
+  jitterMultiplier: 4,
+  // μ + 4σ ≈ 99.99% of Gaussian
+  minGapTimeoutMs: 50,
+  // floor: ~1.5 video frames
+  maxGapTimeoutMs: 2e3,
+  // ceiling
+  minDriftThresholdMs: 80,
+  driftThresholdMultiplier: 3,
+  stallIncrementMs: 33,
+  // 1 video frame interval
+  maxStallIncrements: 3,
+  // max 3 × 33ms = ~100ms added
+  monitorWindowMs: 500,
+  // observe before escalating
+  monitorCleanFrames: 60,
+  // 1s at 60fps tick rate
+  monitorCleanDurationMs: 1e3,
+  maxExtendedWaitMs: 2e3,
+  skipFrequencyThreshold: 3,
+  // 3 skips in window → quality reduce
+  skipFrequencyWindowMs: 3e4,
+  decayMinCleanFrames: 120,
+  // 2s at 60fps
+  decayMinCleanDurationMs: 2e3,
+  decayFactor: 0.9
+  // 10% reduction per decay step
+};
+var TICK_NO_SKIP = { shouldSkip: false };
+var TICK_SKIP = { shouldSkip: true };
+var SlidingMax = class {
+  buf;
+  deq;
+  capacity;
+  writePos = 0;
+  count = 0;
+  dHead = 0;
+  dTail = 0;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.buf = new Float64Array(capacity);
+    this.deq = new Uint32Array(capacity);
+  }
+  push(value) {
+    const cap = this.capacity;
+    const wIdx = this.writePos % cap;
+    if (this.count === cap && this.dHead !== this.dTail && this.deq[this.dHead % cap] === wIdx) {
+      this.dHead++;
+    }
+    while (this.dHead !== this.dTail && this.buf[this.deq[(this.dTail - 1) % cap] % cap] <= value) {
+      this.dTail--;
+    }
+    this.deq[this.dTail % cap] = wIdx;
+    this.dTail++;
+    this.buf[wIdx] = value;
+    this.writePos++;
+    if (this.count < cap) this.count++;
+  }
+  get max() {
+    if (this.dHead === this.dTail) return 0;
+    return this.buf[this.deq[this.dHead % this.capacity] % this.capacity];
+  }
+  reset() {
+    this.writePos = 0;
+    this.count = 0;
+    this.dHead = 0;
+    this.dTail = 0;
+  }
+};
+var AdaptiveToleranceController = class {
+  cfg;
+  // ── Jitter estimation ──
+  _jitterEma = 0;
+  _jitterVar = 0;
+  _lastTransitMs = 0;
+  _hasLastTransit = false;
+  _slidingMax;
+  // ── Phase state ──
+  _phase = RecoveryPhase.Normal;
+  _phaseEnteredMs = 0;
+  _monitorGapCount = 0;
+  _stallCount = 0;
+  _stallEscalationMs = 0;
+  // ── Skip frequency tracking ──
+  _skipTimestamps = [];
+  // ── Clean streak tracking (for monitoring exit + decay) ──
+  _cleanFrameCount = 0;
+  _cleanStreakStartMs = 0;
+  // ── Quality reduction ──
+  _shouldReduceQuality = false;
+  // ── Protocol signals ──
+  _deliveryTimeoutMs = 0;
+  // ── Capture timestamp jitter (for drift threshold) ──
+  _lastCaptureUs = 0;
+  _hasCaptureRef = false;
+  _captureJitterEma = 0;
+  constructor(config) {
+    this.cfg = config;
+    this._slidingMax = new SlidingMax(config.slidingWindowSize);
+  }
+  // ─── Read-only state ──────────────────────────────────────────
+  get phase() {
+    return this._phase;
+  }
+  get jitterEmaMs() {
+    return this._jitterEma;
+  }
+  get jitterVarMs() {
+    return this._jitterVar;
+  }
+  get slidingMaxMs() {
+    return this._slidingMax.max;
+  }
+  get stallCount() {
+    return this._stallCount;
+  }
+  get shouldReduceQuality() {
+    return this._shouldReduceQuality;
+  }
+  /**
+   * Auto-calibrated gap timeout in milliseconds.
+   *
+   * baseline = max(minGap, EMA + K × variance, slidingMax)
+   * effective = min(baseline + stallEscalation, maxGap, deliveryTimeout)
+   */
+  get effectiveGapTimeoutMs() {
+    const adaptive = Math.max(
+      this.cfg.minGapTimeoutMs,
+      this._jitterEma + this.cfg.jitterMultiplier * this._jitterVar,
+      this._slidingMax.max
+    );
+    const withStall = adaptive + this._stallEscalationMs;
+    let capped = Math.min(withStall, this.cfg.maxGapTimeoutMs);
+    if (this._deliveryTimeoutMs > 0) {
+      capped = Math.min(capped, this._deliveryTimeoutMs);
+    }
+    return capped;
+  }
+  /**
+   * Auto-calibrated drift threshold in milliseconds.
+   *
+   * Based on observed CaptureTimestamp interarrival jitter.
+   */
+  get effectiveDriftThresholdMs() {
+    if (!this._hasCaptureRef || this._captureJitterEma === 0) {
+      return this.cfg.minDriftThresholdMs;
+    }
+    return Math.max(
+      this.cfg.minDriftThresholdMs,
+      this._captureJitterEma * this.cfg.driftThresholdMultiplier
+    );
+  }
+  // ─── Events IN ────────────────────────────────────────────────
+  /**
+   * Notify that a frame arrived.
+   *
+   * @param nowMs Current time in milliseconds
+   * @param captureUs CaptureTimestamp in microseconds
+   * @param arrivalMs Arrival time in milliseconds
+   */
+  onFrameArrived(nowMs, captureUs, arrivalMs) {
+    const transitMs = arrivalMs - captureUs * 1e-3;
+    if (this._hasLastTransit) {
+      const d = transitMs - this._lastTransitMs;
+      const absD = d < 0 ? -d : d;
+      const emaErr = absD - this._jitterEma;
+      this._jitterEma += this.cfg.emaAlpha * emaErr;
+      this._jitterVar += this.cfg.varianceAlpha * (absD - this._jitterVar);
+      this._slidingMax.push(absD);
+    }
+    this._lastTransitMs = transitMs;
+    this._hasLastTransit = true;
+    if (this._hasCaptureRef) {
+      const captureIntervalUs = captureUs - this._lastCaptureUs;
+      const captureJitterMs = Math.abs(captureIntervalUs) * 1e-3;
+      if (this._captureJitterEma === 0) {
+        this._captureJitterEma = captureJitterMs;
+      } else {
+        this._captureJitterEma += this.cfg.emaAlpha * (captureJitterMs - this._captureJitterEma);
+      }
+    }
+    this._lastCaptureUs = captureUs;
+    this._hasCaptureRef = true;
+    this._cleanFrameCount++;
+    if (this._cleanFrameCount === 1) {
+      this._cleanStreakStartMs = nowMs;
+    }
+  }
+  /**
+   * Notify that a gap was detected.
+   *
+   * @param nowMs Current time in milliseconds
+   * @param groupId The group ID where the gap was detected
+   */
+  onGapDetected(nowMs, _groupId) {
+    this._cleanFrameCount = 0;
+    switch (this._phase) {
+      case RecoveryPhase.Normal:
+        this._phase = RecoveryPhase.Monitoring;
+        this._phaseEnteredMs = nowMs;
+        this._monitorGapCount = 1;
+        break;
+      case RecoveryPhase.Monitoring:
+        this._monitorGapCount++;
+        if (this._monitorGapCount >= 2 && nowMs - this._phaseEnteredMs <= this.cfg.monitorWindowMs) {
+          this._phase = RecoveryPhase.ExtendedWait;
+          this._phaseEnteredMs = nowMs;
+        }
+        break;
+      case RecoveryPhase.ExtendedWait:
+        break;
+    }
+  }
+  /**
+   * Periodic tick — evaluate phase transitions and decay.
+   *
+   * @param nowMs Current time in milliseconds
+   * @returns TickResult indicating whether caller should skip forward
+   */
+  tick(nowMs) {
+    switch (this._phase) {
+      case RecoveryPhase.Monitoring: {
+        if (nowMs - this._phaseEnteredMs > this.cfg.monitorWindowMs) {
+          if (this._cleanFrameCount >= this.cfg.monitorCleanFrames && nowMs - this._cleanStreakStartMs >= this.cfg.monitorCleanDurationMs) {
+            this._phase = RecoveryPhase.Normal;
+            return TICK_NO_SKIP;
+          }
+        }
+        break;
+      }
+      case RecoveryPhase.ExtendedWait: {
+        if (nowMs - this._phaseEnteredMs >= this.cfg.maxExtendedWaitMs) {
+          this._stallCount++;
+          this._stallEscalationMs = Math.min(
+            this._stallCount * this.cfg.stallIncrementMs,
+            this.cfg.maxStallIncrements * this.cfg.stallIncrementMs
+          );
+          this._skipTimestamps.push(nowMs);
+          this._pruneSkipTimestamps(nowMs);
+          if (this._skipTimestamps.length >= this.cfg.skipFrequencyThreshold) {
+            this._shouldReduceQuality = true;
+          }
+          this._phase = RecoveryPhase.Normal;
+          this._cleanFrameCount = 0;
+          return TICK_SKIP;
+        }
+        break;
+      }
+      case RecoveryPhase.Normal: {
+        if (this._stallEscalationMs > 0 && this._cleanFrameCount >= this.cfg.decayMinCleanFrames && this._cleanStreakStartMs > 0 && nowMs - this._cleanStreakStartMs >= this.cfg.decayMinCleanDurationMs) {
+          this._stallEscalationMs *= this.cfg.decayFactor;
+          if (this._stallEscalationMs < 1) {
+            this._stallEscalationMs = 0;
+            this._stallCount = 0;
+          }
+          this._cleanFrameCount = 0;
+          this._cleanStreakStartMs = nowMs;
+        }
+        if (this._shouldReduceQuality) {
+          this._pruneSkipTimestamps(nowMs);
+          if (this._skipTimestamps.length < this.cfg.skipFrequencyThreshold) {
+            this._shouldReduceQuality = false;
+          }
+        }
+        break;
+      }
+    }
+    return TICK_NO_SKIP;
+  }
+  /**
+   * Set DELIVERY_TIMEOUT from protocol negotiation.
+   * Caps the effective gap timeout.
+   *
+   * @see draft-ietf-moq-transport-16 §9.2.2.2
+   */
+  setDeliveryTimeout(timeoutMs) {
+    this._deliveryTimeoutMs = timeoutMs;
+  }
+  /** Reset all state (seek, pause→resume). */
+  reset() {
+    this._jitterEma = 0;
+    this._jitterVar = 0;
+    this._lastTransitMs = 0;
+    this._hasLastTransit = false;
+    this._slidingMax.reset();
+    this._phase = RecoveryPhase.Normal;
+    this._phaseEnteredMs = 0;
+    this._monitorGapCount = 0;
+    this._stallCount = 0;
+    this._stallEscalationMs = 0;
+    this._skipTimestamps = [];
+    this._cleanFrameCount = 0;
+    this._cleanStreakStartMs = 0;
+    this._shouldReduceQuality = false;
+    this._deliveryTimeoutMs = 0;
+    this._lastCaptureUs = 0;
+    this._hasCaptureRef = false;
+    this._captureJitterEma = 0;
+  }
+  // ─── Internal ─────────────────────────────────────────────────
+  _pruneSkipTimestamps(nowMs) {
+    const windowStart = nowMs - this.cfg.skipFrequencyWindowMs;
+    this._skipTimestamps = this._skipTimestamps.filter((t) => t >= windowStart);
+  }
+};
+
+// src/render-scheduler.ts
+var RenderScheduler = class {
+  clock;
+  cushionUs;
+  /** Wall-clock anchor: local time when the first frame was scheduled. */
+  baseTimeUs = null;
+  /** PTS anchor: captureTimestamp of the first frame. */
+  basePtsUs = null;
+  /** Previous frame's arrival time — for burst-to-live detection. */
+  lastArrivalUs = 0;
+  constructor(clock, options) {
+    this.clock = clock;
+    this.cushionUs = options?.cushionUs ?? 16e3;
+  }
+  /**
+   * Compute the wall-clock render time for a decoded frame.
+   *
+   * @param captureTimestampUs CaptureTimestamp from LOC header (microseconds)
+   * @returns Wall-clock time in microseconds when the frame should be painted
+   */
+  schedule(captureTimestampUs) {
+    const nowUs = this.clock.now();
+    const ptsUs = Number(captureTimestampUs);
+    if (this.baseTimeUs === null || this.basePtsUs === null) {
+      this.baseTimeUs = nowUs + this.cushionUs;
+      this.basePtsUs = ptsUs;
+      this.lastArrivalUs = nowUs;
+      return this.baseTimeUs;
+    }
+    const ptsDelta = ptsUs - this.basePtsUs;
+    let renderTimeUs = this.baseTimeUs + ptsDelta;
+    const arrivalDelta = nowUs - this.lastArrivalUs;
+    if (renderTimeUs < nowUs && arrivalDelta > 2e4) {
+      this.baseTimeUs = nowUs + this.cushionUs;
+      this.basePtsUs = ptsUs;
+      renderTimeUs = this.baseTimeUs;
+    }
+    this.lastArrivalUs = nowUs;
+    return renderTimeUs;
+  }
+  /** Reset anchor (seek, pause→resume, gap skip). */
+  reset() {
+    this.baseTimeUs = null;
+    this.basePtsUs = null;
+    this.lastArrivalUs = 0;
+  }
+};
+
+// src/startup-buffer.ts
+function classifyNetwork(handshakeRttMs) {
+  if (handshakeRttMs < 1) {
+    return { minFrames: 2, maxWaitMs: 80 };
+  } else if (handshakeRttMs < 5) {
+    return { minFrames: 3, maxWaitMs: 120 };
+  } else if (handshakeRttMs < 50) {
+    return { minFrames: 8, maxWaitMs: 300 };
+  } else {
+    return { minFrames: 12, maxWaitMs: 500 };
+  }
+}
+var StartupBuffer = class {
+  minFrames;
+  maxWaitMs;
+  _frameCount = 0;
+  _firstFrameMs = 0;
+  _lastFrameMs = 0;
+  _draining = false;
+  constructor(params) {
+    this.minFrames = params.minFrames;
+    this.maxWaitMs = params.maxWaitMs;
+  }
+  /**
+   * Record a frame arrival. Call from pushObject().
+   * @param nowMs Current time in milliseconds
+   */
+  recordFrame(nowMs) {
+    this._frameCount++;
+    if (this._frameCount === 1) {
+      this._firstFrameMs = nowMs;
+    }
+    this._lastFrameMs = nowMs;
+    if (!this._draining) {
+      const elapsed = this._lastFrameMs - this._firstFrameMs;
+      if (this._frameCount >= this.minFrames || elapsed >= this.maxWaitMs) {
+        this._draining = true;
+      }
+    }
+  }
+  /** Whether the pipeline should start draining (buffer phase complete). */
+  get shouldDrain() {
+    return this._draining;
+  }
+  /** Number of frames recorded. */
+  get frameCount() {
+    return this._frameCount;
+  }
+  /** Time elapsed since first frame in milliseconds. */
+  get elapsedMs() {
+    if (this._frameCount === 0) return 0;
+    return this._lastFrameMs - this._firstFrameMs;
+  }
+  /** Accelerated EMA alpha for warmup (4x standard 1/16). */
+  get warmupEmaAlpha() {
+    return 0.25;
+  }
+  /** Reset to buffering state (e.g., after seek or pause→resume). */
+  reset() {
+    this._frameCount = 0;
+    this._firstFrameMs = 0;
+    this._lastFrameMs = 0;
+    this._draining = false;
+  }
+};
+
+// src/keyframe-validator.ts
+function isKeyframePayload(codec, payload) {
+  const codecBase = codec.split(".")[0].toLowerCase();
+  switch (codecBase) {
+    case "avc1":
+    case "avc3":
+      return isH264Keyframe(payload);
+    case "hvc1":
+    case "hev1":
+      return isH265Keyframe(payload);
+    case "av01":
+      return isAV1Keyframe(payload);
+    default:
+      return null;
+  }
+}
+var MAX_NAL_UNITS_PER_AU = 256;
+function isH264Keyframe(payload) {
+  if (payload.length < 5) return null;
+  let pos = 0;
+  let iterations = 0;
+  while (pos + 4 < payload.length) {
+    if (++iterations > MAX_NAL_UNITS_PER_AU) return null;
+    const nalLen = payload[pos] << 24 | payload[pos + 1] << 16 | payload[pos + 2] << 8 | payload[pos + 3];
+    pos += 4;
+    if (nalLen <= 0 || pos >= payload.length) break;
+    const nalType = payload[pos] & 31;
+    if (nalType === 5) return true;
+    if (nalType === 7) return true;
+    if (nalType === 6 || nalType === 8 || nalType === 9) {
+      pos += nalLen;
+      continue;
+    }
+    return false;
+  }
+  return null;
+}
+function isH265Keyframe(payload) {
+  if (payload.length < 6) return null;
+  let pos = 0;
+  let iterations = 0;
+  while (pos + 4 < payload.length) {
+    if (++iterations > MAX_NAL_UNITS_PER_AU) return null;
+    const nalLen = payload[pos] << 24 | payload[pos + 1] << 16 | payload[pos + 2] << 8 | payload[pos + 3];
+    pos += 4;
+    if (nalLen <= 0 || pos + 1 >= payload.length) break;
+    const nalType = payload[pos] >> 1 & 63;
+    if (nalType === 19 || nalType === 20) return true;
+    if (nalType === 21) return true;
+    if (nalType === 32 || nalType === 33 || nalType === 34) {
+      pos += nalLen;
+      continue;
+    }
+    if (nalType === 35 || nalType === 39 || nalType === 40) {
+      pos += nalLen;
+      continue;
+    }
+    return false;
+  }
+  return null;
+}
+function isAV1Keyframe(payload) {
+  if (payload.length < 2) return null;
+  const obuType = payload[0] >> 3 & 15;
+  if (obuType === 1) return true;
+  if (obuType === 2 && payload.length >= 3) {
+    const nextObuType = payload[2] >> 3 & 15;
+    if (nextObuType === 1) return true;
+  }
+  if (obuType === 3 || obuType === 6) return false;
+  return null;
+}
+
+// ../transport/dist/primitives/varint.js
+var MAX_VARINT = 4611686018427387903n;
+function varint(n) {
+  if (typeof n === "number") {
+    if (!Number.isInteger(n) || n < 0) {
+      throw new RangeError(`Varint value must be a non-negative integer, got ${n}`);
+    }
+    if (n > Number.MAX_SAFE_INTEGER) {
+      throw new RangeError(`Varint number value ${n} exceeds MAX_SAFE_INTEGER; use bigint for values > 2^53-1`);
+    }
+    return BigInt(n);
+  }
+  if (n < 0n || n > MAX_VARINT) {
+    throw new RangeError(`Varint value must be 0 \u2264 n \u2264 ${MAX_VARINT}, got ${n}`);
+  }
+  return n;
+}
+
+// ../transport/dist/control/codes-18.js
+var SetupOption18 = {
+  PATH: 1,
+  AUTHORIZATION_TOKEN: 3,
+  MAX_AUTH_TOKEN_CACHE_SIZE: 4,
+  AUTHORITY: 5,
+  MOQT_IMPLEMENTATION: 7
+};
+var SetupOption22 = {
+  ...SetupOption18,
+  MAX_FILTER_RANGES: 6,
+  MAX_REQUEST_UPDATES: 8
+};
+var MessageParam18 = {
+  OBJECT_DELIVERY_TIMEOUT: { type: 2, kind: "varint" },
+  AUTHORIZATION_TOKEN: { type: 3, kind: "bytes" },
+  RENDEZVOUS_TIMEOUT: { type: 4, kind: "varint" },
+  SUBGROUP_DELIVERY_TIMEOUT: { type: 6, kind: "varint" },
+  EXPIRES: { type: 8, kind: "varint" },
+  LARGEST_OBJECT: { type: 9, kind: "location" },
+  FILL_TIMEOUT: { type: 10, kind: "varint" },
+  FORWARD: { type: 16, kind: "uint8" },
+  SUBSCRIBER_PRIORITY: { type: 32, kind: "uint8" },
+  SUBSCRIPTION_FILTER: { type: 33, kind: "bytes" },
+  GROUP_ORDER: { type: 34, kind: "uint8" },
+  NEW_GROUP_REQUEST: { type: 50, kind: "varint" },
+  TRACK_NAMESPACE_PREFIX: { type: 52, kind: "namespace" }
+};
+var MessageParam22 = {
+  OBJECT_DELIVERY_TIMEOUT: { type: 2, kind: "varint" },
+  AUTHORIZATION_TOKEN: { type: 3, kind: "bytes" },
+  RENDEZVOUS_TIMEOUT: { type: 4, kind: "varint" },
+  SUBGROUP_DELIVERY_TIMEOUT: { type: 6, kind: "varint" },
+  EXPIRES: { type: 8, kind: "varint" },
+  LARGEST_OBJECT: { type: 9, kind: "location" },
+  FILL_TIMEOUT: { type: 10, kind: "varint" },
+  FORWARD: { type: 16, kind: "uint8" },
+  SUBSCRIBER_PRIORITY: { type: 32, kind: "uint8" },
+  LOCATION_FILTER: { type: 33, kind: "locationFilter" },
+  GROUP_ORDER: { type: 34, kind: "uint8" },
+  FILL_PARAMETERS: { type: 35, kind: "bytes" },
+  SUBGROUP_FILTER: { type: 37, kind: "bytes" },
+  OBJECTID_FILTER: { type: 38, kind: "bytes" },
+  PRIORITY_FILTER: { type: 39, kind: "bytes" },
+  OBJECT_PROPERTY_FILTER: { type: 40, kind: "bytes" },
+  TRACK_PROPERTY_FILTER: { type: 41, kind: "bytes" },
+  NEW_GROUP_REQUEST: { type: 50, kind: "varint" },
+  TRACK_NAMESPACE_PREFIX: { type: 52, kind: "namespace" },
+  INCLUDE_PROPERTIES: { type: 53, kind: "uint8" }
+};
+
+// ../transport/dist/errors.js
+var SessionError = {
+  NO_ERROR: varint(0),
+  INTERNAL_ERROR: varint(1),
+  UNAUTHORIZED: varint(2),
+  PROTOCOL_VIOLATION: varint(3),
+  INVALID_REQUEST_ID: varint(4),
+  DUPLICATE_TRACK_ALIAS: varint(5),
+  KEY_VALUE_FORMATTING_ERROR: varint(6),
+  TOO_MANY_REQUESTS: varint(7),
+  INVALID_PATH: varint(8),
+  MALFORMED_PATH: varint(9),
+  GOAWAY_TIMEOUT: varint(16),
+  CONTROL_MESSAGE_TIMEOUT: varint(17),
+  DATA_STREAM_TIMEOUT: varint(18),
+  AUTH_TOKEN_CACHE_OVERFLOW: varint(19),
+  DUPLICATE_AUTH_TOKEN_ALIAS: varint(20),
+  VERSION_NEGOTIATION_FAILED: varint(21),
+  MALFORMED_AUTH_TOKEN: varint(22),
+  UNKNOWN_AUTH_TOKEN_ALIAS: varint(23),
+  EXPIRED_AUTH_TOKEN: varint(24),
+  INVALID_AUTHORITY: varint(25),
+  MALFORMED_AUTHORITY: varint(26),
+  /** draft-22: more than MAX_REQUEST_UPDATES updates outstanding on one request. */
+  TOO_MANY_REQUEST_UPDATES: varint(27)
+};
+var RequestError = {
+  INTERNAL_ERROR: varint(0),
+  UNAUTHORIZED: varint(1),
+  TIMEOUT: varint(2),
+  NOT_SUPPORTED: varint(3),
+  MALFORMED_AUTH_TOKEN: varint(4),
+  EXPIRED_AUTH_TOKEN: varint(5),
+  DOES_NOT_EXIST: varint(16),
+  INVALID_RANGE: varint(17),
+  MALFORMED_TRACK: varint(18),
+  DUPLICATE_SUBSCRIPTION: varint(25),
+  UNINTERESTED: varint(32),
+  PREFIX_OVERLAP: varint(48),
+  NAMESPACE_TOO_LARGE: varint(49),
+  INVALID_JOINING_REQUEST_ID: varint(50),
+  /** draft-18 §2.5.1: a Mandatory Track Property the endpoint does not understand. */
+  UNSUPPORTED_EXTENSION: varint(51),
+  /** draft-18 §10.6.2: the request is redirected; the body carries a Redirect. */
+  REDIRECT: varint(52)
+};
+var PublishDoneCode = {
+  INTERNAL_ERROR: varint(0),
+  UNAUTHORIZED: varint(1),
+  TRACK_ENDED: varint(2),
+  SUBSCRIPTION_ENDED: varint(3),
+  GOING_AWAY: varint(4),
+  EXPIRED: varint(5),
+  TOO_FAR_BEHIND: varint(6),
+  UPDATE_FAILED: varint(8),
+  MALFORMED_TRACK: varint(18)
+};
+var DataStreamError = {
+  INTERNAL_ERROR: varint(0),
+  CANCELLED: varint(1),
+  DELIVERY_TIMEOUT: varint(2),
+  SESSION_CLOSED: varint(3),
+  UNKNOWN_OBJECT_STATUS: varint(4),
+  MALFORMED_TRACK: varint(18)
+};
+var RequestError18 = {
+  INTERNAL_ERROR: varint(0),
+  UNAUTHORIZED: varint(1),
+  TIMEOUT: varint(2),
+  NOT_SUPPORTED: varint(3),
+  MALFORMED_AUTH_TOKEN: varint(4),
+  EXPIRED_AUTH_TOKEN: varint(5),
+  GOING_AWAY: varint(6),
+  EXCESSIVE_LOAD: varint(9),
+  DOES_NOT_EXIST: varint(16),
+  INVALID_RANGE: varint(17),
+  MALFORMED_TRACK: varint(18),
+  DUPLICATE_SUBSCRIPTION: varint(25),
+  UNINTERESTED: varint(32),
+  PREFIX_OVERLAP: varint(48),
+  NAMESPACE_TOO_LARGE: varint(49),
+  INVALID_JOINING_REQUEST_ID: varint(50),
+  UNSUPPORTED_EXTENSION: varint(51),
+  REDIRECT: varint(52)
+};
+var RequestError22 = {
+  INTERNAL_ERROR: varint(0),
+  UNAUTHORIZED: varint(1),
+  TIMEOUT: varint(2),
+  NOT_SUPPORTED: varint(3),
+  MALFORMED_AUTH_TOKEN: varint(4),
+  EXPIRED_AUTH_TOKEN: varint(5),
+  GOING_AWAY: varint(6),
+  EXCESSIVE_LOAD: varint(9),
+  DOES_NOT_EXIST: varint(16),
+  INVALID_RANGE: varint(17),
+  MALFORMED_TRACK: varint(18),
+  UNINTERESTED: varint(32),
+  PREFIX_OVERLAP: varint(48),
+  NAMESPACE_TOO_LARGE: varint(49),
+  UNSUPPORTED_EXTENSION: varint(51),
+  REDIRECT: varint(52),
+  CONFLICTING_FILTERS: varint(53),
+  INVALID_FILTER: varint(54)
+};
+var PublishDoneCode18 = {
+  INTERNAL_ERROR: varint(0),
+  UNAUTHORIZED: varint(1),
+  TRACK_ENDED: varint(2),
+  SUBSCRIPTION_ENDED: varint(3),
+  GOING_AWAY: varint(4),
+  TOO_FAR_BEHIND: varint(5),
+  EXPIRED: varint(6),
+  UPDATE_FAILED: varint(8),
+  EXCESSIVE_LOAD: varint(9),
+  MALFORMED_TRACK: varint(18)
+};
+var StreamResetCode18 = {
+  INTERNAL_ERROR: varint(0),
+  CANCELLED: varint(1),
+  DELIVERY_TIMEOUT: varint(2),
+  SESSION_CLOSED: varint(3),
+  GOING_AWAY: varint(4),
+  TOO_FAR_BEHIND: varint(5),
+  UNKNOWN_OBJECT_STATUS: varint(6),
+  EXPIRED_AUTH_TOKEN: varint(7),
+  EXCESSIVE_LOAD: varint(9),
+  MALFORMED_TRACK: varint(18)
+};
+
+// ../transport/dist/primitives/bytes.js
+var SESSION_NAMESPACE_FIELD = new Uint8Array([46, 115, 101, 115, 115, 105, 111, 110]);
+
+// ../transport/dist/control/message-params-18.js
+var DEFAULT_MESSAGE_PARAM_REGISTRY = new Map(Object.values(MessageParam18).map((d) => [BigInt(d.type), d.kind]));
+var DRAFT22_MESSAGE_PARAM_REGISTRY = new Map(Object.values(MessageParam22).map((d) => [BigInt(d.type), d.kind]));
+
+// ../transport/dist/primitives/reason.js
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+
+// ../transport/dist/control/codes.js
+var MessageType = {
+  REQUEST_UPDATE: varint(2),
+  SUBSCRIBE: varint(3),
+  SUBSCRIBE_OK: varint(4),
+  REQUEST_ERROR: varint(5),
+  PUBLISH_NAMESPACE: varint(6),
+  REQUEST_OK: varint(7),
+  NAMESPACE: varint(8),
+  PUBLISH_NAMESPACE_DONE: varint(9),
+  UNSUBSCRIBE: varint(10),
+  PUBLISH_DONE: varint(11),
+  PUBLISH_NAMESPACE_CANCEL: varint(12),
+  TRACK_STATUS: varint(13),
+  NAMESPACE_DONE: varint(14),
+  GOAWAY: varint(16),
+  SUBSCRIBE_NAMESPACE: varint(17),
+  MAX_REQUEST_ID: varint(21),
+  FETCH: varint(22),
+  FETCH_CANCEL: varint(23),
+  FETCH_OK: varint(24),
+  REQUESTS_BLOCKED: varint(26),
+  PUBLISH: varint(29),
+  PUBLISH_OK: varint(30),
+  CLIENT_SETUP: varint(32),
+  SERVER_SETUP: varint(33)
+};
+
+// ../transport/dist/control/parameters.js
+var SetupParam = {
+  /** @see §9.3.1.2 */
+  PATH: varint(1),
+  /** @see §9.3.1.3 */
+  MAX_REQUEST_ID: varint(2),
+  /** @see §9.3.1.5 */
+  AUTHORIZATION_TOKEN: varint(3),
+  /** @see §9.3.1.4 */
+  MAX_AUTH_TOKEN_CACHE_SIZE: varint(4),
+  /** @see §9.3.1.1 */
+  AUTHORITY: varint(5),
+  /** @see §9.3.1.6 */
+  MOQT_IMPLEMENTATION: varint(7)
+};
+var MessageParam = {
+  /** @see §9.2.2.2 */
+  DELIVERY_TIMEOUT: varint(2),
+  /**
+   * draft-18 §10.2.4: OBJECT_DELIVERY_TIMEOUT — same wire type (0x02) as the
+   * draft-14/16 DELIVERY_TIMEOUT; named alias for the draft-18 scope tables.
+   */
+  OBJECT_DELIVERY_TIMEOUT: varint(2),
+  /** @see §9.2.2.1 */
+  AUTHORIZATION_TOKEN: varint(3),
+  /** draft-18 §10.2.6: RENDEZVOUS_TIMEOUT — SUBSCRIBE only. */
+  RENDEZVOUS_TIMEOUT: varint(4),
+  /** draft-18 §10.2.3: SUBGROUP_DELIVERY_TIMEOUT — PUBLISH_OK / SUBSCRIBE / REQUEST_UPDATE. */
+  SUBGROUP_DELIVERY_TIMEOUT: varint(6),
+  /** @see §9.2.2.6 */
+  EXPIRES: varint(8),
+  /** @see §9.2.2.7 */
+  LARGEST_OBJECT: varint(9),
+  /** draft-18 §10.2.5: FILL_TIMEOUT — FETCH only. */
+  FILL_TIMEOUT: varint(10),
+  /** @see §9.2.2.8 */
+  FORWARD: varint(16),
+  /** @see §9.2.2.3 */
+  SUBSCRIBER_PRIORITY: varint(32),
+  /** @see §9.2.2.5 */
+  SUBSCRIPTION_FILTER: varint(33),
+  /** @see §9.2.2.4 */
+  GROUP_ORDER: varint(34),
+  /** @see §9.2.2.9 */
+  NEW_GROUP_REQUEST: varint(50),
+  /**
+   * draft-18 §10.2.14: Track Namespace Prefix. Carried in REQUEST_UPDATE to
+   * change the prefix of a SUBSCRIBE_NAMESPACE / SUBSCRIBE_TRACKS. Its value is a
+   * Track Namespace tuple (semantic `Uint8Array[]`), not a KVP scalar — the
+   * draft-14/16 codecs reject it at the KVP boundary.
+   */
+  TRACK_NAMESPACE_PREFIX: varint(52)
+};
+
+// ../transport/dist/control/encoder.js
+var UNIQUE_MESSAGE_PARAMS = /* @__PURE__ */ new Set([
+  MessageParam.DELIVERY_TIMEOUT,
+  MessageParam.EXPIRES,
+  MessageParam.LARGEST_OBJECT,
+  MessageParam.FORWARD,
+  MessageParam.SUBSCRIBER_PRIORITY,
+  MessageParam.SUBSCRIPTION_FILTER,
+  MessageParam.GROUP_ORDER,
+  MessageParam.NEW_GROUP_REQUEST
+]);
+var MESSAGE_PARAM_NAMES = /* @__PURE__ */ new Map([
+  [MessageParam.DELIVERY_TIMEOUT, "DELIVERY_TIMEOUT"],
+  [MessageParam.EXPIRES, "EXPIRES"],
+  [MessageParam.LARGEST_OBJECT, "LARGEST_OBJECT"],
+  [MessageParam.FORWARD, "FORWARD"],
+  [MessageParam.SUBSCRIBER_PRIORITY, "SUBSCRIBER_PRIORITY"],
+  [MessageParam.SUBSCRIPTION_FILTER, "SUBSCRIPTION_FILTER"],
+  [MessageParam.GROUP_ORDER, "GROUP_ORDER"],
+  [MessageParam.NEW_GROUP_REQUEST, "NEW_GROUP_REQUEST"]
+]);
+
+// ../transport/dist/control/decoder.js
+var codeToType = /* @__PURE__ */ new Map();
+for (const [name, code] of Object.entries(MessageType)) {
+  codeToType.set(code, name);
+}
+
+// ../transport/dist/control/draft14-codec.js
+var D14 = {
+  // Outbound (subscriber sends)
+  CLIENT_SETUP: 32,
+  SUBSCRIBE: 3,
+  SUBSCRIBE_UPDATE: 2,
+  SUBSCRIBE_NAMESPACE: 17,
+  UNSUBSCRIBE_NAMESPACE: 20,
+  UNSUBSCRIBE: 10,
+  FETCH: 22,
+  FETCH_CANCEL: 23,
+  TRACK_STATUS: 13,
+  PUBLISH_NAMESPACE_OK: 7,
+  PUBLISH_NAMESPACE_ERROR: 8,
+  // Inbound (subscriber receives)
+  SERVER_SETUP: 33,
+  SUBSCRIBE_OK: 4,
+  SUBSCRIBE_ERROR: 5,
+  FETCH_OK: 24,
+  FETCH_ERROR: 25,
+  TRACK_STATUS_OK: 14,
+  TRACK_STATUS_ERROR: 15,
+  SUBSCRIBE_NAMESPACE_OK: 18,
+  SUBSCRIBE_NAMESPACE_ERROR: 19,
+  PUBLISH_NAMESPACE: 6,
+  PUBLISH_NAMESPACE_DONE: 9,
+  PUBLISH_NAMESPACE_CANCEL: 12,
+  PUBLISH_DONE: 11,
+  GOAWAY: 16,
+  MAX_REQUEST_ID: 21,
+  REQUESTS_BLOCKED: 26,
+  // Varint-length messages
+  PUBLISH: 29,
+  PUBLISH_OK: 30,
+  PUBLISH_ERROR: 31
+};
+var VARINT_LENGTH_TYPES = /* @__PURE__ */ new Set([D14.PUBLISH, D14.PUBLISH_OK, D14.PUBLISH_ERROR]);
+
+// ../transport/dist/control/draft18-codec.js
+var TEXT_ENCODER = new TextEncoder();
+var TEXT_DECODER = new TextDecoder();
+var SETUP_SINGLETONS = /* @__PURE__ */ new Set([
+  BigInt(SetupOption18.PATH),
+  BigInt(SetupOption18.AUTHORITY),
+  BigInt(SetupOption18.MAX_AUTH_TOKEN_CACHE_SIZE),
+  BigInt(SetupOption18.MOQT_IMPLEMENTATION)
+]);
+
+// ../transport/dist/data/codes.js
+var ObjectStatus = {
+  /** Normal object (implicit for non-zero length payloads). */
+  NORMAL: varint(0),
+  /**
+   * Object does not exist at any publisher. Valid in draft-14.
+   * @see draft-ietf-moq-transport-14 §10.2.1.1
+   */
+  OBJECT_DOES_NOT_EXIST: varint(1),
+  /** No objects with same Group ID and Object ID >= this exist. */
+  END_OF_GROUP: varint(3),
+  /** No objects at location >= this exist. */
+  END_OF_TRACK: varint(4)
+};
+
+// ../transport/dist/data/decoder.js
+var VALID_STATUS_CODES_V16 = /* @__PURE__ */ new Set([
+  ObjectStatus.NORMAL,
+  ObjectStatus.END_OF_GROUP,
+  ObjectStatus.END_OF_TRACK
+]);
+var VALID_STATUS_CODES_V14 = /* @__PURE__ */ new Set([
+  ObjectStatus.NORMAL,
+  ObjectStatus.OBJECT_DOES_NOT_EXIST,
+  ObjectStatus.END_OF_GROUP,
+  ObjectStatus.END_OF_TRACK
+]);
+
+// ../transport/dist/qlog/trace.js
+var MAX_SAFE_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+
+// ../transport/dist/control/auth-token.js
+var AliasType = {
+  /** Retire a previously registered alias. Has Alias, no Type/Value. */
+  DELETE: varint(0),
+  /** Associate an alias with a Token Type + Value. Has Alias, Type, Value. */
+  REGISTER: varint(1),
+  /** Reference a previously registered token by alias. Has Alias, no Type/Value. */
+  USE_ALIAS: varint(2),
+  /** Provide Token Type + Value directly (no caching). No Alias, has Type/Value. */
+  USE_VALUE: varint(3)
+};
+
+// ../transport/dist/session/setup.js
+var KNOWN_SINGLETON_SETUP_OPTIONS_18 = /* @__PURE__ */ new Set([
+  SetupOption18.PATH,
+  // 0x01
+  SetupOption18.MAX_AUTH_TOKEN_CACHE_SIZE,
+  // 0x04
+  SetupOption18.AUTHORITY,
+  // 0x05
+  SetupOption18.MOQT_IMPLEMENTATION
+  // 0x07
+]);
+
+// ../transport/dist/session/session.js
+var KNOWN_MESSAGE_PARAMS = /* @__PURE__ */ new Set([
+  MessageParam.DELIVERY_TIMEOUT,
+  MessageParam.AUTHORIZATION_TOKEN,
+  MessageParam.EXPIRES,
+  MessageParam.LARGEST_OBJECT,
+  MessageParam.FORWARD,
+  MessageParam.SUBSCRIBER_PRIORITY,
+  MessageParam.SUBSCRIPTION_FILTER,
+  MessageParam.GROUP_ORDER,
+  MessageParam.NEW_GROUP_REQUEST,
+  MessageParam.TRACK_NAMESPACE_PREFIX
+]);
+var VALID_PARAMS_FOR_MESSAGE_TYPE = /* @__PURE__ */ new Map([
+  // §9.2.2.2: DELIVERY_TIMEOUT MAY appear in PUBLISH_OK, SUBSCRIBE, REQUEST_UPDATE
+  [MessageParam.DELIVERY_TIMEOUT, /* @__PURE__ */ new Set(["PUBLISH_OK", "SUBSCRIBE", "REQUEST_UPDATE"])],
+  // §9.2.2.1: AUTHORIZATION_TOKEN MAY appear in PUBLISH, SUBSCRIBE, REQUEST_UPDATE,
+  // SUBSCRIBE_NAMESPACE, PUBLISH_NAMESPACE, TRACK_STATUS, FETCH
+  [MessageParam.AUTHORIZATION_TOKEN, /* @__PURE__ */ new Set([
+    "PUBLISH",
+    "SUBSCRIBE",
+    "REQUEST_UPDATE",
+    "SUBSCRIBE_NAMESPACE",
+    "PUBLISH_NAMESPACE",
+    "TRACK_STATUS",
+    "FETCH"
+  ])],
+  // §9.2.2.6: EXPIRES MAY appear in SUBSCRIBE_OK, PUBLISH, PUBLISH_OK
+  [MessageParam.EXPIRES, /* @__PURE__ */ new Set(["SUBSCRIBE_OK", "PUBLISH", "PUBLISH_OK"])],
+  // §9.2.2.7: LARGEST_OBJECT MAY appear in SUBSCRIBE_OK, PUBLISH, REQUEST_OK
+  [MessageParam.LARGEST_OBJECT, /* @__PURE__ */ new Set(["SUBSCRIBE_OK", "PUBLISH", "REQUEST_OK"])],
+  // §9.2.2.8: FORWARD MAY appear in SUBSCRIBE, REQUEST_UPDATE, PUBLISH, PUBLISH_OK, SUBSCRIBE_NAMESPACE
+  [MessageParam.FORWARD, /* @__PURE__ */ new Set(["SUBSCRIBE", "REQUEST_UPDATE", "PUBLISH", "PUBLISH_OK", "SUBSCRIBE_NAMESPACE"])],
+  // §9.2.2.3: SUBSCRIBER_PRIORITY MAY appear in SUBSCRIBE, FETCH, REQUEST_UPDATE, PUBLISH_OK
+  [MessageParam.SUBSCRIBER_PRIORITY, /* @__PURE__ */ new Set(["SUBSCRIBE", "FETCH", "REQUEST_UPDATE", "PUBLISH_OK"])],
+  // §9.2.2.5: SUBSCRIPTION_FILTER MAY appear in SUBSCRIBE, PUBLISH_OK, REQUEST_UPDATE
+  [MessageParam.SUBSCRIPTION_FILTER, /* @__PURE__ */ new Set(["SUBSCRIBE", "PUBLISH_OK", "REQUEST_UPDATE"])],
+  // §9.2.2.4: GROUP_ORDER MAY appear in SUBSCRIBE, PUBLISH_OK, FETCH
+  // Draft-14 also carries it inline on PUBLISH; handle that as a versioned exception.
+  [MessageParam.GROUP_ORDER, /* @__PURE__ */ new Set(["SUBSCRIBE", "PUBLISH_OK", "FETCH"])],
+  // §9.2.2.9: NEW_GROUP_REQUEST MAY appear in PUBLISH_OK, SUBSCRIBE, REQUEST_UPDATE
+  [MessageParam.NEW_GROUP_REQUEST, /* @__PURE__ */ new Set(["PUBLISH_OK", "SUBSCRIBE", "REQUEST_UPDATE"])],
+  // draft-18 §10.2.14: TRACK_NAMESPACE_PREFIX MAY appear in REQUEST_UPDATE (to
+  // change the prefix of a SUBSCRIBE_NAMESPACE / SUBSCRIBE_TRACKS).
+  [MessageParam.TRACK_NAMESPACE_PREFIX, /* @__PURE__ */ new Set(["REQUEST_UPDATE"])]
+]);
+var KNOWN_MESSAGE_PARAMS_18 = /* @__PURE__ */ new Set([
+  MessageParam.OBJECT_DELIVERY_TIMEOUT,
+  // 0x02
+  MessageParam.AUTHORIZATION_TOKEN,
+  // 0x03
+  MessageParam.RENDEZVOUS_TIMEOUT,
+  // 0x04
+  MessageParam.SUBGROUP_DELIVERY_TIMEOUT,
+  // 0x06
+  MessageParam.EXPIRES,
+  // 0x08
+  MessageParam.LARGEST_OBJECT,
+  // 0x09
+  MessageParam.FILL_TIMEOUT,
+  // 0x0a
+  MessageParam.FORWARD,
+  // 0x10
+  MessageParam.SUBSCRIBER_PRIORITY,
+  // 0x20
+  MessageParam.SUBSCRIPTION_FILTER,
+  // 0x21
+  MessageParam.GROUP_ORDER,
+  // 0x22
+  MessageParam.NEW_GROUP_REQUEST,
+  // 0x32
+  MessageParam.TRACK_NAMESPACE_PREFIX
+]);
+var VALID_PARAMS_FOR_MESSAGE_TYPE_18 = /* @__PURE__ */ new Map([
+  // §10.2.4
+  [MessageParam.OBJECT_DELIVERY_TIMEOUT, /* @__PURE__ */ new Set(["PUBLISH_OK", "SUBSCRIBE", "REQUEST_UPDATE"])],
+  // §10.2.2
+  [MessageParam.AUTHORIZATION_TOKEN, /* @__PURE__ */ new Set([
+    "PUBLISH",
+    "SUBSCRIBE",
+    "REQUEST_UPDATE",
+    "SUBSCRIBE_NAMESPACE",
+    "SUBSCRIBE_TRACKS",
+    "PUBLISH_NAMESPACE",
+    "TRACK_STATUS",
+    "FETCH"
+  ])],
+  // §10.2.6
+  [MessageParam.RENDEZVOUS_TIMEOUT, /* @__PURE__ */ new Set(["SUBSCRIBE"])],
+  // §10.2.3
+  [MessageParam.SUBGROUP_DELIVERY_TIMEOUT, /* @__PURE__ */ new Set(["PUBLISH_OK", "SUBSCRIBE", "REQUEST_UPDATE"])],
+  // §10.2.10
+  [MessageParam.EXPIRES, /* @__PURE__ */ new Set(["SUBSCRIBE_OK", "PUBLISH", "PUBLISH_OK", "REQUEST_UPDATE_OK"])],
+  // §10.2.11
+  [MessageParam.LARGEST_OBJECT, /* @__PURE__ */ new Set(["SUBSCRIBE_OK", "PUBLISH", "REQUEST_UPDATE_OK", "TRACK_STATUS_OK"])],
+  // §10.2.5
+  [MessageParam.FILL_TIMEOUT, /* @__PURE__ */ new Set(["FETCH"])],
+  // §10.2.12
+  [MessageParam.FORWARD, /* @__PURE__ */ new Set(["SUBSCRIBE", "REQUEST_UPDATE", "PUBLISH", "PUBLISH_OK", "SUBSCRIBE_TRACKS"])],
+  // §10.2.7
+  [MessageParam.SUBSCRIBER_PRIORITY, /* @__PURE__ */ new Set(["SUBSCRIBE", "FETCH", "REQUEST_UPDATE", "PUBLISH_OK"])],
+  // §10.2.9
+  [MessageParam.SUBSCRIPTION_FILTER, /* @__PURE__ */ new Set(["SUBSCRIBE", "PUBLISH_OK", "REQUEST_UPDATE"])],
+  // §10.2.8
+  [MessageParam.GROUP_ORDER, /* @__PURE__ */ new Set(["SUBSCRIBE", "PUBLISH_OK", "FETCH"])],
+  // §10.2.13
+  [MessageParam.NEW_GROUP_REQUEST, /* @__PURE__ */ new Set(["PUBLISH_OK", "SUBSCRIBE", "REQUEST_UPDATE"])],
+  // §10.2.14 — generic REQUEST_UPDATE scope; the namespace/tracks-target restriction
+  // is enforced contextually in handleIncomingRequestUpdate.
+  [MessageParam.TRACK_NAMESPACE_PREFIX, /* @__PURE__ */ new Set(["REQUEST_UPDATE"])]
+]);
+var FILL_PARAMETERS = 0x23n;
+var RANGE_FILTER_PARAMS_22 = /* @__PURE__ */ new Set([0x25n, 0x26n, 0x27n, 0x28n, 0x29n]);
+var KNOWN_MESSAGE_PARAMS_22 = /* @__PURE__ */ new Set([
+  ...KNOWN_MESSAGE_PARAMS_18,
+  FILL_PARAMETERS,
+  ...RANGE_FILTER_PARAMS_22,
+  0x35n
+  // INCLUDE_PROPERTIES
+]);
+var VALID_PARAMS_FOR_MESSAGE_TYPE_22 = /* @__PURE__ */ new Map([
+  [MessageParam.OBJECT_DELIVERY_TIMEOUT, /* @__PURE__ */ new Set(["SUBSCRIBE", "PUBLISH", "REQUEST_UPDATE", "SUBSCRIBE_TRACKS"])],
+  [MessageParam.AUTHORIZATION_TOKEN, /* @__PURE__ */ new Set([
+    "PUBLISH",
+    "SUBSCRIBE",
+    "REQUEST_UPDATE",
+    "SUBSCRIBE_NAMESPACE",
+    "SUBSCRIBE_TRACKS",
+    "PUBLISH_NAMESPACE",
+    "TRACK_STATUS",
+    "FETCH"
+  ])],
+  [MessageParam.RENDEZVOUS_TIMEOUT, /* @__PURE__ */ new Set(["SUBSCRIBE", "SUBSCRIBE_TRACKS"])],
+  [MessageParam.SUBGROUP_DELIVERY_TIMEOUT, /* @__PURE__ */ new Set(["SUBSCRIBE", "PUBLISH", "REQUEST_UPDATE", "SUBSCRIBE_TRACKS"])],
+  [MessageParam.EXPIRES, /* @__PURE__ */ new Set([
+    "SUBSCRIBE_OK",
+    "PUBLISH",
+    "PUBLISH_OK",
+    "REQUEST_UPDATE_OK",
+    "SUBSCRIBE_NAMESPACE_OK",
+    "SUBSCRIBE_TRACKS_OK",
+    "PUBLISH_NAMESPACE_OK"
+  ])],
+  [MessageParam.LARGEST_OBJECT, /* @__PURE__ */ new Set([
+    "SUBSCRIBE_OK",
+    "PUBLISH",
+    "REQUEST_UPDATE_OK",
+    "TRACK_STATUS_OK",
+    "PUBLISH_STATE_NOTIFY"
+  ])],
+  [MessageParam.FILL_TIMEOUT, /* @__PURE__ */ new Set(["FETCH"])],
+  [MessageParam.FORWARD, /* @__PURE__ */ new Set(["SUBSCRIBE", "REQUEST_UPDATE", "PUBLISH", "SUBSCRIBE_TRACKS", "PUBLISH_STATE_NOTIFY"])],
+  [MessageParam.SUBSCRIBER_PRIORITY, /* @__PURE__ */ new Set(["SUBSCRIBE", "FETCH", "REQUEST_UPDATE", "PUBLISH", "SUBSCRIBE_TRACKS"])],
+  [MessageParam.SUBSCRIPTION_FILTER, /* @__PURE__ */ new Set([
+    "SUBSCRIBE",
+    "REQUEST_UPDATE",
+    "PUBLISH",
+    "FETCH",
+    "SUBSCRIBE_TRACKS",
+    "PUBLISH_STATE_NOTIFY"
+  ])],
+  [MessageParam.GROUP_ORDER, /* @__PURE__ */ new Set(["SUBSCRIBE", "FETCH", "PUBLISH", "SUBSCRIBE_TRACKS"])],
+  [FILL_PARAMETERS, /* @__PURE__ */ new Set(["SUBSCRIBE", "REQUEST_UPDATE", "SUBSCRIBE_TRACKS"])],
+  [0x25n, /* @__PURE__ */ new Set(["SUBSCRIBE", "FETCH", "REQUEST_UPDATE", "SUBSCRIBE_TRACKS"])],
+  [0x26n, /* @__PURE__ */ new Set(["SUBSCRIBE", "FETCH", "REQUEST_UPDATE", "SUBSCRIBE_TRACKS"])],
+  [0x27n, /* @__PURE__ */ new Set(["SUBSCRIBE", "FETCH", "REQUEST_UPDATE", "SUBSCRIBE_TRACKS"])],
+  [0x28n, /* @__PURE__ */ new Set(["SUBSCRIBE", "FETCH", "REQUEST_UPDATE", "SUBSCRIBE_TRACKS"])],
+  [0x29n, /* @__PURE__ */ new Set(["REQUEST_UPDATE", "SUBSCRIBE_TRACKS"])],
+  [MessageParam.NEW_GROUP_REQUEST, /* @__PURE__ */ new Set(["SUBSCRIBE", "REQUEST_UPDATE", "SUBSCRIBE_TRACKS"])],
+  [MessageParam.TRACK_NAMESPACE_PREFIX, /* @__PURE__ */ new Set(["REQUEST_UPDATE"])],
+  [0x35n, /* @__PURE__ */ new Set(["SUBSCRIBE", "FETCH", "TRACK_STATUS", "SUBSCRIBE_TRACKS"])]
+]);
+
+// ../loc/dist/types.js
+var Loc01PropertyId = {
+  /** Wall-clock capture time in microseconds. @see loc-01 §2.3.1.1 */
+  CAPTURE_TIMESTAMP: 2,
+  /** RFC 9626 video frame marking as an integer. @see loc-01 §2.3.2.2 */
+  VIDEO_FRAME_MARKING: 4,
+  /** RFC 6464 audio level + voice activity. @see loc-01 §2.3.3.1 */
+  AUDIO_LEVEL: 6,
+  /** Video codec configuration extradata. @see loc-01 §2.3.2.1 */
+  VIDEO_CONFIG: 13
+};
+var Loc04PropertyId = {
+  /** Timestamp units per second. Absent means microseconds. @see loc-04 §2.3.1.2 */
+  TIMESCALE: 8,
+  /** RFC 9626 video frame marking as 1 to 4 bytes. @see loc-04 §2.3.2.2 */
+  VIDEO_FRAME_MARKING: 9,
+  /** RFC 6464 audio level + voice activity. @see loc-04 §2.3.3.2 */
+  AUDIO_LEVEL: 12,
+  /** Video codec configuration extradata. @see loc-04 §2.3.2.1 */
+  VIDEO_CONFIG: 13,
+  /** Audio codec configuration. @see loc-04 §2.3.3.1 */
+  AUDIO_CONFIG: 15,
+  /** Frame timestamp in Timescale units. @see loc-04 §2.3.1.1 */
+  TIMESTAMP: 16
+};
+
+// ../loc/dist/property-map.js
+var ID01 = {
+  captureTimestamp: BigInt(Loc01PropertyId.CAPTURE_TIMESTAMP),
+  videoFrameMarking: BigInt(Loc01PropertyId.VIDEO_FRAME_MARKING),
+  audioLevel: BigInt(Loc01PropertyId.AUDIO_LEVEL),
+  videoConfig: BigInt(Loc01PropertyId.VIDEO_CONFIG)
+};
+var ID04 = {
+  timescale: BigInt(Loc04PropertyId.TIMESCALE),
+  videoFrameMarking: BigInt(Loc04PropertyId.VIDEO_FRAME_MARKING),
+  audioLevel: BigInt(Loc04PropertyId.AUDIO_LEVEL),
+  videoConfig: BigInt(Loc04PropertyId.VIDEO_CONFIG),
+  audioConfig: BigInt(Loc04PropertyId.AUDIO_CONFIG),
+  timestamp: BigInt(Loc04PropertyId.TIMESTAMP)
+};
+
+// ../loc/dist/headers.js
+function sourceTimestamp(headers) {
+  const micros = headers.captureTimestamp;
+  if (micros === void 0)
+    return void 0;
+  const scale = headers.timescale;
+  if (scale !== void 0 && (scale <= 0n || headers.timestampIsWallClock === true))
+    return void 0;
+  if (headers.timestamp !== void 0) {
+    if (scale === void 0 && headers.timestampIsWallClock === false)
+      return void 0;
+    const ticksPerSecond = scale ?? 1000000n;
+    const scaled = headers.timestamp * 1000000n;
+    const truncated = scaled / ticksPerSecond;
+    const rounded = (scaled + (scaled >= 0n ? ticksPerSecond / 2n : -(ticksPerSecond / 2n))) / ticksPerSecond;
+    if (micros !== truncated && micros !== rounded)
+      return void 0;
+    return Object.freeze({ ticks: headers.timestamp, ticksPerSecond, domain: scale === void 0 ? "unix" : "media" });
+  }
+  return Object.freeze({
+    ticks: micros,
+    ticksPerSecond: 1000000n,
+    domain: headers.timestampIsWallClock === true ? "unix" : headers.timestampIsWallClock === false || scale !== void 0 ? "media" : "unknown"
+  });
+}
+function toVideoChunkInit(payload, headers) {
+  const isKey = headers.videoFrameMarking?.independent === true;
+  const timestamp = headers.captureTimestamp !== void 0 ? Number(headers.captureTimestamp) : 0;
+  const source = sourceTimestamp(headers);
+  return {
+    type: isKey ? "key" : "delta",
+    timestamp,
+    ...source !== void 0 ? { sourceTimestamp: source } : {},
+    ...headers.duration !== void 0 ? { duration: headers.duration } : {},
+    data: payload
+  };
+}
+function toAudioChunkInit(payload, headers) {
+  const timestamp = headers.captureTimestamp !== void 0 ? Number(headers.captureTimestamp) : 0;
+  const source = sourceTimestamp(headers);
+  return {
+    type: "key",
+    timestamp,
+    ...source !== void 0 ? { sourceTimestamp: source } : {},
+    ...headers.duration !== void 0 ? { duration: headers.duration } : {},
+    data: payload
+  };
+}
+
+// src/pipeline.ts
+var PlaybackPipeline = class {
+  mediaType;
+  clock;
+  sync;
+  onCommand;
+  onEvent;
+  recovery;
+  buffer;
+  gapDetector;
+  decoderState;
+  /** Headers stored alongside objects, keyed by "groupId:objectId". */
+  headerMap = /* @__PURE__ */ new Map();
+  /** Group reference counts in the jitter buffer. */
+  bufferedGroupCounts = /* @__PURE__ */ new Map();
+  /** Next expected objectId within the current group for contiguity check. */
+  nextExpectedObjectId = 0n;
+  /** Highest group from which at least one object was consumed. -1n = nothing consumed yet. */
+  lastConsumedGroupId = -1n;
+  /** Groups for which END_OF_GROUP has been observed. */
+  endedGroups = /* @__PURE__ */ new Set();
+  /** Timestamp when we first started waiting for active group completion. */
+  activeGroupWaitStartUs = null;
+  /**
+  * Minimum group ID accepted by pushObject().
+  * Set after SKIP_FORWARD to reject stale objects from pre-skip groups
+  * that arrive late due to async QUIC stream delivery.
+  */
+  minAcceptGroupId = -1n;
+  /** Last group for which keyframe_waiting was emitted (dedup). */
+  lastKeyframeWaitingGroupId = -1n;
+  /**
+  * When true, the first tick syncs to whatever group is available
+  * without gap detection — avoids cascading recovery on initial
+  * live join or after pause→resume on a live stream.
+  *
+  * Starts `true` so the first arriving group is accepted as the
+  * starting point (joining mid-broadcast is not a gap).
+  */
+  resetPending = true;
+  /** True once track_ended has been emitted — prevents re-emission on every tick. */
+  _trackEnded = false;
+  /** Last emitted playback rate — dedup to avoid spamming commands. */
+  _lastEmittedRate = 1;
+  /**
+  * Throttle flag — set by decoder feedback when queue depth is high.
+  * While true, tick() evaluates gaps but does NOT drain the buffer.
+  * Objects still enter the jitter buffer (needed for gap detection).
+  */
+  _throttled = false;
+  /** Adaptive jitter tolerance controller (null if disabled). */
+  adaptiveTolerance;
+  /** Max objects to release per tick (video only). 0 = unlimited. */
+  maxReleasePerTick;
+  /** Max groups before shedding old ones. 0 = unlimited. */
+  maxBacklogGroups;
+  /** Video codec string from catalog (e.g., 'avc1.42c01f'). Used for keyframe validation. */
+  _videoCodec;
+  _videoOnly;
+  constructor(opts) {
+    this.mediaType = opts.mediaType;
+    this.clock = opts.clock;
+    this.sync = opts.sync;
+    this.onCommand = opts.onCommand;
+    this.onEvent = opts.onEvent;
+    this.recovery = opts.recovery;
+    this._videoOnly = opts.videoOnly ?? false;
+    const liveVideo = opts.mediaType === "video" && (opts.isLive ?? true);
+    this.maxReleasePerTick = liveVideo ? opts.config.maxReleasePerTick ?? 5 : 0;
+    this.maxBacklogGroups = liveVideo ? opts.config.maxBacklogGroups ?? 3 : 0;
+    this.buffer = new JitterBuffer(opts.config.maxBufferDepth);
+    this.gapDetector = new GapDetector({
+      gapTimeoutUs: opts.config.gapTimeoutUs,
+      clock: opts.clock
+    });
+    this.decoderState = new DecoderStateMachine(opts.mediaType);
+    this.adaptiveTolerance = opts.config.adaptiveTolerance ? new AdaptiveToleranceController(DEFAULT_TOLERANCE_CONFIG) : null;
+  }
+  /**
+  * Set the video codec string for keyframe payload validation.
+  *
+  * @param codec Codec string from catalog (e.g., 'avc1.42c01f', 'hvc1', 'av01.0.08M.10')
+  * @see draft-ietf-moq-loc-01 §4.2 (decode order)
+  */
+  setCodec(codec) {
+    this._videoCodec = codec;
+  }
+  /**
+  * Current effective gap timeout in microseconds.
+  * When adaptive tolerance is enabled, this is auto-calibrated from jitter.
+  * Otherwise, returns the fixed configured value.
+  */
+  get effectiveGapTimeoutUs() {
+    if (this.adaptiveTolerance) {
+      return this.adaptiveTolerance.effectiveGapTimeoutMs * 1e3;
+    }
+    return this.gapDetector.gapTimeoutUs;
+  }
+  /** Last consumed group ID — for track switch subscription filters. */
+  get currentGroupId() {
+    return this.lastConsumedGroupId;
+  }
+  /** Number of distinct groups currently in the jitter buffer. */
+  get bufferedGroupCount() {
+    return this.bufferedGroupCounts.size;
+  }
+  /** Whether draining is throttled due to decoder backpressure. */
+  get throttled() {
+    return this._throttled;
+  }
+  /**
+  * Handle feedback from browser adapters (decoder queue, errors, drift).
+  *
+  * @see draft-ietf-moq-loc-01 §2.3.1.1 (drift detection)
+  */
+  handleFeedback(fb) {
+    switch (fb.type) {
+      case "queue_pressure":
+        this._throttled = fb.depth >= fb.maxRecommended;
+        break;
+      case "decode_error":
+        this._throttled = false;
+        {
+          const decision = this.decoderState.notifyGap();
+          this.emitFsmDecision(decision);
+        }
+        if (this.recovery) {
+          const action = this.recovery.evaluate({ type: "decode_error", message: fb.message });
+          this.onEvent({ type: "recovery", action });
+        }
+        break;
+      case "frame_rendered":
+        if (fb.scheduledRenderUs !== void 0) {
+          this.sync.reportPresentationTiming(fb.scheduledRenderUs, fb.actualRenderUs);
+          const drift = this.sync.currentDriftUs;
+          if (this.sync.presentationDriftExceeded) {
+            this.onEvent({ type: "sync_drift", driftUs: drift });
+          }
+        }
+        break;
+      case "flush_complete":
+        break;
+    }
+  }
+  /**
+  * Provide codec configuration (from catalog or initial headers).
+  *
+  * This is also triggered automatically when a LOC object carries the
+  * matching config property: Video Config for video, Audio Config for
+  * audio.
+  *
+  * @param config Codec-specific configuration bytes
+  */
+  configure(config) {
+    const decision = this.decoderState.configure(config);
+    if (decision.action === "configure") {
+      this.onCommand({
+        type: "configure",
+        mediaType: this.mediaType,
+        config
+      });
+    }
+  }
+  /**
+  * Push an object into the pipeline.
+  *
+  * Data objects are buffered. Gap objects notify the gap detector.
+  *
+  * @param obj The MoqtObject (data or gap)
+  * @param headers Parsed LocHeaders (only meaningful for data objects)
+  */
+  pushObject(obj, headers) {
+    if (obj.kind === "gap") {
+      if (obj.status === ObjectStatus.END_OF_GROUP) {
+        this.gapDetector.observeEndOfGroup(obj.groupId);
+        this.endedGroups.add(obj.groupId);
+      } else if (obj.status === ObjectStatus.END_OF_TRACK) {
+        this.gapDetector.observeEndOfTrack();
+      }
+      return;
+    }
+    if (obj.groupId < this.minAcceptGroupId) return;
+    if (this.lastConsumedGroupId >= 0n && obj.groupId < this.lastConsumedGroupId) return;
+    if (obj.groupId === this.lastConsumedGroupId && obj.objectId < this.nextExpectedObjectId) return;
+    const key = `${obj.groupId}:${obj.objectId}`;
+    if (this.headerMap.has(key)) return;
+    if (this.buffer.insert(obj)) {
+      this.headerMap.set(key, headers ?? {});
+      const count = this.bufferedGroupCounts.get(obj.groupId) ?? 0;
+      this.bufferedGroupCounts.set(obj.groupId, count + 1);
+    } else if (obj.publisherPriority !== void 0) {
+      if (!this.tryEvictAndInsert(obj, headers) && this.recovery) {
+        this.onEvent({
+          type: "recovery",
+          action: this.recovery.evaluate({ type: "buffer_overflow" })
+        });
+      }
+    } else if (this.recovery) {
+      this.onEvent({
+        type: "recovery",
+        action: this.recovery.evaluate({ type: "buffer_overflow" })
+      });
+    }
+    if (this.adaptiveTolerance && headers?.captureTimestamp !== void 0) {
+      const nowMs = this.clock.now() / 1e3;
+      const captureUs = Number(headers.captureTimestamp);
+      this.adaptiveTolerance.onFrameArrived(nowMs, captureUs, nowMs);
+    }
+    this.gapDetector.observeGroup(obj.groupId);
+  }
+  /**
+  * Reset pipeline state for pause→resume or seek.
+  *
+  * Clears the jitter buffer, gap detector, and decoder FSM so the first
+  * arriving group after resume is accepted cleanly without cascading
+  * gap-recovery escalation from the stale pre-pause position.
+  *
+  * Emits a decoder 'reset' command so the WebCodecs decoder clears its
+  * queue and waits for the next keyframe (video) or resumes immediately
+  * (audio — Opus/AAC-LC frames are independently decodable).
+  *
+  * @param targetGroupId When seeking, set this to the target group ID.
+  *   Objects from groups before this ID are rejected — prevents stale
+  *   in-flight objects from corrupting the post-seek decoder state.
+  *   @see draft-ietf-moq-transport-16 §9.11.1 — "it might still receive
+  *   Objects outside the new range if the publisher sent them before the
+  *   update was processed."
+  */
+  /**
+  * Reset for a track switch — clears jitter buffer (old-track objects
+  * use the same groupIds as new-track per altGroup alignment), resets
+  * gap detector and group tracking. Does NOT reset decoder state or
+  * emit flush/reset commands — already-decoded frames in the renderer
+  * queue play out naturally for seamless visual transition.
+  *
+  * @param firstGroupId The first group ID from the new track — sets
+  *   lastConsumedGroupId to firstGroupId-1 so the gap detector doesn't
+  *   see a gap and trigger skip_forward (which would reset sync).
+  */
+  resetForTrackSwitch(firstGroupId) {
+    this.buffer.clear();
+    this.headerMap.clear();
+    this.bufferedGroupCounts.clear();
+    this.lastConsumedGroupId = firstGroupId - 1n;
+    this.endedGroups.add(this.lastConsumedGroupId);
+    this.nextExpectedObjectId = 0n;
+    this.minAcceptGroupId = firstGroupId;
+    this.lastKeyframeWaitingGroupId = -1n;
+    this._throttled = false;
+    this.activeGroupWaitStartUs = null;
+    this.gapDetector.reset();
+    const decision = this.decoderState.notifyGap();
+    this.emitFsmDecision(decision);
+  }
+  reset(targetGroupId) {
+    this.buffer.clear();
+    this.headerMap.clear();
+    this.bufferedGroupCounts.clear();
+    this.lastConsumedGroupId = -1n;
+    this.nextExpectedObjectId = 0n;
+    this.minAcceptGroupId = targetGroupId ?? -1n;
+    this.lastKeyframeWaitingGroupId = -1n;
+    this.resetPending = true;
+    this._throttled = false;
+    this._trackEnded = false;
+    this.endedGroups.clear();
+    this.activeGroupWaitStartUs = null;
+    this.gapDetector.reset();
+    this.adaptiveTolerance?.reset();
+    const decision = this.decoderState.notifyGap();
+    this.emitFsmDecision(decision);
+  }
+  /**
+  * Process buffered objects: evaluate gaps, feed decoder FSM, emit commands.
+  *
+  * Call this on a regular interval (e.g., requestAnimationFrame or timer).
+  */
+  tick() {
+    if (this.adaptiveTolerance) {
+      const nowMs = this.clock.now() / 1e3;
+      this.adaptiveTolerance.tick(nowMs);
+      this.gapDetector.gapTimeoutUs = this.adaptiveTolerance.effectiveGapTimeoutMs * 1e3;
+      this.sync.driftThresholdUs = this.adaptiveTolerance.effectiveDriftThresholdMs * 1e3;
+    }
+    if (this.resetPending && this.buffer.size > 0) {
+      const top = this.buffer.peek();
+      if (top.objectId !== 0n) {
+        this.buffer.extract();
+        this.decrementGroupCount(top.groupId);
+        return;
+      }
+      this.lastConsumedGroupId = top.groupId - 1n;
+      this.endedGroups.add(this.lastConsumedGroupId);
+      this.resetPending = false;
+    }
+    const availableGroupIds = [...this.bufferedGroupCounts.keys()];
+    const gapDecision = this.gapDetector.evaluate(this.lastConsumedGroupId, availableGroupIds);
+    if (gapDecision.action === GapAction.TRACK_ENDED) {
+      if (!this._trackEnded) {
+        this._trackEnded = true;
+        const decision = this.decoderState.notifyTrackEnded();
+        this.emitFsmDecision(decision);
+        this.onEvent({ type: "track_ended" });
+      }
+      return;
+    }
+    if (gapDecision.action === GapAction.SKIP_FORWARD && gapDecision.targetGroupId !== void 0) {
+      const target = gapDecision.targetGroupId;
+      if (this.mediaType === "video" && this.lastConsumedGroupId >= 0n && !this.endedGroups.has(this.lastConsumedGroupId)) {
+        this.onEvent({
+          type: "partial_group_abandoned",
+          fromGroupId: this.lastConsumedGroupId,
+          toGroupId: target,
+          reason: "gap timeout"
+        });
+      }
+      for (const gid of this.endedGroups) {
+        if (gid < target) this.endedGroups.delete(gid);
+      }
+      this.onEvent({
+        type: "skip_forward",
+        fromGroupId: this.lastConsumedGroupId,
+        toGroupId: target
+      });
+      if (this.recovery) {
+        const action = this.recovery.evaluate({ type: "gap", groupId: target });
+        this.onEvent({ type: "recovery", action });
+      }
+      this.minAcceptGroupId = target;
+      this.discardBefore(target);
+      const decision = this.decoderState.notifyGap();
+      this.emitFsmDecision(decision);
+      this.lastConsumedGroupId = target - 1n;
+      this.endedGroups.add(this.lastConsumedGroupId);
+      this.nextExpectedObjectId = 0n;
+      this.activeGroupWaitStartUs = null;
+    }
+    if (this.maxBacklogGroups > 0 && this.bufferedGroupCounts.size > this.maxBacklogGroups) {
+      this.shedBacklog();
+    }
+    if (this._throttled) return;
+    if (this.mediaType === "video" && this.activeGroupWaitStartUs !== null) {
+      const elapsed = this.clock.now() - this.activeGroupWaitStartUs;
+      if (elapsed > this.gapDetector.gapTimeoutUs) {
+        const nextGroupId = this.lastConsumedGroupId + 1n;
+        this.onEvent({
+          type: "partial_group_abandoned",
+          fromGroupId: this.lastConsumedGroupId,
+          toGroupId: nextGroupId,
+          reason: "intra-group timeout"
+        });
+        this.endedGroups.add(this.lastConsumedGroupId);
+        const decision = this.decoderState.notifyGap();
+        this.emitFsmDecision(decision);
+        this.activeGroupWaitStartUs = null;
+      }
+    }
+    let released = 0;
+    const budget = this.maxReleasePerTick;
+    while (this.buffer.size > 0) {
+      if (budget > 0 && released >= budget) break;
+      if (this._throttled) break;
+      const top = this.buffer.peek();
+      if (!top) break;
+      const nextExpectedGroup = this.lastConsumedGroupId + 1n;
+      if (top.groupId > nextExpectedGroup) {
+        break;
+      }
+      if (top.groupId > this.lastConsumedGroupId && this.lastConsumedGroupId >= 0n) {
+        if (this.mediaType === "video" && !this.endedGroups.has(this.lastConsumedGroupId)) {
+          if (this.activeGroupWaitStartUs === null) {
+            this.activeGroupWaitStartUs = this.clock.now();
+          }
+          break;
+        }
+        this.activeGroupWaitStartUs = null;
+        this.endedGroups.delete(this.lastConsumedGroupId);
+      }
+      if (top.groupId > this.lastConsumedGroupId) {
+        this.nextExpectedObjectId = 0n;
+      }
+      if (this.mediaType === "video" && top.objectId > this.nextExpectedObjectId) {
+        const skipGroupId = top.groupId;
+        while (this.buffer.size > 0) {
+          const peek = this.buffer.peek();
+          if (!peek || peek.groupId !== skipGroupId) break;
+          this.buffer.extract();
+          this.decrementGroupCount(skipGroupId);
+        }
+        this.lastConsumedGroupId = skipGroupId;
+        this.nextExpectedObjectId = 0n;
+        const decision = this.decoderState.notifyGap();
+        this.emitFsmDecision(decision);
+        break;
+      }
+      const obj = this.buffer.extract();
+      this.decrementGroupCount(obj.groupId);
+      if (obj.kind === "data") {
+        this.processDataObject(obj);
+      }
+      this.nextExpectedObjectId = obj.objectId + 1n;
+      released++;
+      if (obj.groupId > this.lastConsumedGroupId) {
+        this.lastConsumedGroupId = obj.groupId;
+      }
+    }
+  }
+  // ─── Internal ───────────────────────────────────────────────────
+  /**
+  * Drop oldest whole groups when backlog exceeds maxBacklogGroups.
+  * Keeps the newest maxBacklogGroups groups, discards the rest.
+  * After shedding, notifies decoder that a gap occurred (needs keyframe).
+  */
+  shedBacklog() {
+    const groupIds = [...this.bufferedGroupCounts.keys()].sort(
+      (a, b) => a < b ? -1 : a > b ? 1 : 0
+    );
+    const excess = groupIds.length - this.maxBacklogGroups;
+    if (excess <= 0) return;
+    const groupsToShed = groupIds.slice(0, excess);
+    const cutoff = groupsToShed[groupsToShed.length - 1] + 1n;
+    this.buffer.discardBefore(cutoff);
+    for (const gid of groupsToShed) {
+      this.bufferedGroupCounts.delete(gid);
+    }
+    for (const key of this.headerMap.keys()) {
+      const groupId = BigInt(key.split(":")[0]);
+      if (groupId < cutoff) this.headerMap.delete(key);
+    }
+    const lastShed = groupsToShed[groupsToShed.length - 1];
+    if (lastShed >= this.lastConsumedGroupId) {
+      this.lastConsumedGroupId = lastShed;
+    }
+    this.minAcceptGroupId = lastShed + 1n;
+    const decision = this.decoderState.notifyGap();
+    this.emitFsmDecision(decision);
+    this.onEvent({
+      type: "backlog_shed",
+      droppedGroups: excess,
+      remainingGroups: this.bufferedGroupCounts.size,
+      reason: `backlog exceeded ${this.maxBacklogGroups} groups`
+    });
+  }
+  /**
+  * Whether late encoded VIDEO may be discarded before it reaches the decoder.
+  *
+  * Only explicitly discardable, non-independent frames may be. Everything
+  * else is NOT PROVEN SAFE TO DISCARD and is therefore preserved
+  * conservatively: RFC 9626 §3.1 defines D=1 as the sender asserting the
+  * frame can be removed while the stream stays decodable, so D=0 does not
+  * prove the frame is a reference — it means the receiver has no assurance
+  * that discarding it is safe. Absent marking is treated the same way, and
+  * an independent frame is preserved even if it also claims to be
+  * discardable.
+  *
+  * Lateness of decoded OUTPUT remains the output stage's decision.
+  *
+  * @see draft-ietf-moq-loc-01 §2.3.2.2 (Video Frame Marking)
+  */
+  isPreDecodeDroppable(marking) {
+    if (marking === void 0) return false;
+    if (marking.independent) return false;
+    return marking.discardable === true;
+  }
+  /**
+  * Attempt to evict a lower-importance object to make room.
+  * @returns true if the incoming object was inserted.
+  * @see draft-ietf-moq-transport-16 §7 (Priority-based dropping)
+  */
+  tryEvictAndInsert(obj, headers) {
+    const evicted = this.buffer.evictLowestImportance();
+    if (!evicted) return false;
+    if (evicted.publisherPriority > obj.publisherPriority) {
+      this.decrementGroupCount(evicted.groupId);
+      const evictedKey = `${evicted.groupId}:${evicted.objectId}`;
+      this.headerMap.delete(evictedKey);
+      this.buffer.insert(obj);
+      const key = `${obj.groupId}:${obj.objectId}`;
+      this.headerMap.set(key, headers ?? {});
+      const count = this.bufferedGroupCounts.get(obj.groupId) ?? 0;
+      this.bufferedGroupCounts.set(obj.groupId, count + 1);
+      return true;
+    } else {
+      this.buffer.insert(evicted);
+      return false;
+    }
+  }
+  processDataObject(obj) {
+    const key = `${obj.groupId}:${obj.objectId}`;
+    const headers = this.headerMap.get(key) ?? {};
+    this.headerMap.delete(key);
+    const config = this.mediaType === "video" ? headers.videoConfig : headers.audioConfig;
+    if (config) {
+      const configDecision = this.decoderState.configure(config);
+      if (configDecision.action === "configure") {
+        this.onCommand({
+          type: "configure",
+          mediaType: this.mediaType,
+          config
+        });
+      }
+    }
+    if (headers.captureTimestamp !== void 0 && !this.sync.hasReference) {
+      if (this.mediaType === "audio") {
+        this.sync.setAudioReference(headers.captureTimestamp);
+      } else if (this._videoOnly) {
+        this.sync.setVideoReference(headers.captureTimestamp);
+      }
+    }
+    const videoMarking = this.mediaType === "video" ? headers.videoFrameMarking ?? (obj.objectId === 0n ? {
+      independent: true,
+      startOfFrame: true,
+      endOfFrame: true,
+      discardable: false,
+      baseLayerSync: false,
+      temporalId: 0
+    } : void 0) : void 0;
+    let renderTimeUs;
+    if (headers.captureTimestamp !== void 0) {
+      const timing = this.mediaType === "video" ? this.sync.computeVideoRenderTime(headers.captureTimestamp) : this.sync.computeAudioRenderTime(headers.captureTimestamp);
+      if (timing === null) {
+        renderTimeUs = 0;
+      } else if (timing.shouldDrop) {
+        if (timing.offsetUs < -5e6) {
+          renderTimeUs = this.clock.now();
+        } else if (this.mediaType === "video" && !this.isPreDecodeDroppable(videoMarking)) {
+          renderTimeUs = this.clock.now();
+        } else {
+          return;
+        }
+      } else if (timing.offsetUs > 5e6) {
+        renderTimeUs = this.clock.now();
+      } else {
+        renderTimeUs = timing.renderTimeUs;
+      }
+    } else {
+      renderTimeUs = this.clock.now();
+    }
+    if (headers.captureTimestamp !== void 0) {
+      const catchUp = this.sync.evaluateCatchUp(headers.captureTimestamp, headers.timestampIsWallClock);
+      if (catchUp !== null && catchUp.currentRate !== this._lastEmittedRate) {
+        this._lastEmittedRate = catchUp.currentRate;
+        this.onEvent({ type: "catch_up_changed", state: catchUp });
+        this.onCommand({ type: "set_playback_rate", rate: catchUp.currentRate });
+      }
+    }
+    if (this.mediaType === "video") {
+      const marking = videoMarking;
+      if (marking?.independent && this._videoCodec && obj.payload.length > 5) {
+        const isKeyframe = isKeyframePayload(this._videoCodec, obj.payload);
+        if (isKeyframe === false) {
+          this.onEvent({
+            type: "keyframe_validation_failed",
+            groupId: obj.groupId,
+            objectId: obj.objectId,
+            codec: this._videoCodec
+          });
+        }
+      }
+      const headersWithMarking = marking !== void 0 ? { ...headers, videoFrameMarking: marking } : headers;
+      const chunk = toVideoChunkInit(obj.payload, headersWithMarking);
+      const prevState = this.decoderState.state;
+      const decision = this.decoderState.processVideoChunk(chunk, marking);
+      if (prevState === "needs_keyframe" && this.decoderState.state === "decoding" && headers.captureTimestamp !== void 0) {
+        this.sync.onVideoJoin(headers.captureTimestamp);
+        const recomputed = this.sync.computeVideoRenderTime(headers.captureTimestamp);
+        if (recomputed) {
+          renderTimeUs = recomputed.renderTimeUs;
+        }
+      }
+      if (decision.action === "decode") {
+        this.onCommand({
+          type: "decode_video",
+          chunk: decision.chunk,
+          renderTimeUs,
+          ...headers.captureTimestamp !== void 0 ? { captureTimestampUs: headers.captureTimestamp } : {}
+        });
+      } else if (decision.action === "skip") {
+        if (decision.reason === "waiting for keyframe" && obj.groupId !== this.lastKeyframeWaitingGroupId) {
+          this.lastKeyframeWaitingGroupId = obj.groupId;
+          this.onEvent({ type: "keyframe_waiting", groupId: obj.groupId });
+        }
+      }
+    } else {
+      const chunk = toAudioChunkInit(obj.payload, headers);
+      const decision = this.decoderState.processAudioChunk(chunk);
+      if (decision.action === "decode") {
+        this.onCommand({
+          type: "decode_audio",
+          chunk: decision.chunk,
+          renderTimeUs
+        });
+      }
+    }
+  }
+  emitFsmDecision(decision) {
+    if (decision.action === "reset") {
+      this.onCommand({
+        type: "reset",
+        mediaType: this.mediaType,
+        reason: decision.reason ?? "gap"
+      });
+    } else if (decision.action === "flush") {
+      this.onCommand({
+        type: "flush",
+        mediaType: this.mediaType
+      });
+    }
+  }
+  discardBefore(groupId) {
+    this.buffer.discardBefore(groupId);
+    for (const [gid] of this.bufferedGroupCounts) {
+      if (gid < groupId) {
+        this.bufferedGroupCounts.delete(gid);
+      }
+    }
+    for (const [key] of this.headerMap) {
+      const colonIdx = key.indexOf(":");
+      const gid = BigInt(key.slice(0, colonIdx));
+      if (gid < groupId) {
+        this.headerMap.delete(key);
+      }
+    }
+  }
+  decrementGroupCount(groupId) {
+    const count = this.bufferedGroupCounts.get(groupId);
+    if (count !== void 0) {
+      if (count <= 1) {
+        this.bufferedGroupCounts.delete(groupId);
+      } else {
+        this.bufferedGroupCounts.set(groupId, count - 1);
+      }
+    }
+  }
+};
+
+// src/bandwidth-estimator.ts
+var BandwidthEstimator = class {
+  alpha;
+  minSamples;
+  estimateBps = null;
+  lastTimestampUs = null;
+  lastGroupBytes = null;
+  sampleCount = 0;
+  /**
+   * @param alpha EWMA smoothing factor (0-1). Higher = more responsive
+   *              to recent samples, lower = smoother. Default 0.3.
+   * @param minSamples Minimum group arrivals before reporting a non-zero
+   *                   estimate. Early samples include connection latency
+   *                   and aren't representative. Default 5 (~10s at 2s GOPs).
+   */
+  constructor(alpha = 0.3, minSamples = 5) {
+    this.alpha = alpha;
+    this.minSamples = minSamples;
+  }
+  /**
+   * Record a group arrival. Call once per complete group (GOP).
+   *
+   * @param bytes Total bytes in the group.
+   * @param timestampUs Arrival timestamp in microseconds.
+   */
+  recordGroup(bytes, timestampUs) {
+    if (this.lastTimestampUs !== null && this.lastGroupBytes !== null) {
+      const deltaUs = timestampUs - this.lastTimestampUs;
+      if (deltaUs > 0) {
+        this.sampleCount++;
+        const instantBps = bytes * 8 / (deltaUs / 1e6);
+        if (this.estimateBps === null) {
+          this.estimateBps = instantBps;
+        } else {
+          this.estimateBps = this.alpha * instantBps + (1 - this.alpha) * this.estimateBps;
+        }
+      }
+    }
+    this.lastTimestampUs = timestampUs;
+    this.lastGroupBytes = bytes;
+  }
+  /**
+   * Current smoothed bandwidth estimate in kbps.
+   * Returns 0 if fewer than 2 groups have been recorded.
+   */
+  getEstimateKbps() {
+    if (this.estimateBps === null || this.sampleCount < this.minSamples) return 0;
+    return this.estimateBps / 1e3;
+  }
+  /** Reset all state. */
+  reset() {
+    this.estimateBps = null;
+    this.lastTimestampUs = null;
+    this.lastGroupBytes = null;
+    this.sampleCount = 0;
+  }
+};
+
+// src/buffer-based-controller.ts
+var BufferBasedController = class {
+  ladder;
+  lowThresholdUs;
+  /** Kept for future temporal-buffer mode (playout buffer, not jitter buffer). */
+  highThresholdUs;
+  upshiftMultiple;
+  currentIndex;
+  constructor(config) {
+    this.ladder = config.ladder;
+    this.lowThresholdUs = config.lowThresholdUs;
+    this.highThresholdUs = config.highThresholdUs;
+    this.upshiftMultiple = config.upshiftBandwidthMultiple ?? 2.25;
+    this.currentIndex = config.initialIndex;
+  }
+  /** Current ladder index. */
+  get index() {
+    return this.currentIndex;
+  }
+  /** Current track. */
+  get currentTrack() {
+    return this.ladder[this.currentIndex];
+  }
+  /**
+   * Evaluate buffer depth + bandwidth and return an ABR decision.
+   *
+   * Called periodically (e.g., every tick or every group arrival).
+   */
+  /**
+   * Evaluate buffer depth + bandwidth and return an ABR recommendation.
+   *
+   * Does NOT mutate internal state — the caller must call
+   * {@link commitDownshift} or {@link commitUpshift} after a
+   * confirmed switch. This prevents index drift when async switches
+   * fail or are aborted.
+   */
+  evaluate(signals) {
+    if (signals.bufferDepthUs < this.lowThresholdUs) {
+      if (this.currentIndex < this.ladder.length - 1) {
+        return { action: "downshift", targetIndex: this.currentIndex + 1 };
+      }
+      return { action: "hold" };
+    }
+    if (this.currentIndex > 0 && signals.bufferDepthUs >= this.highThresholdUs) {
+      const higherTrack = this.ladder[this.currentIndex - 1];
+      if (signals.bandwidthEstimateKbps > higherTrack.bitrateKbps * this.upshiftMultiple) {
+        return { action: "upshift", targetIndex: this.currentIndex - 1 };
+      }
+    }
+    return { action: "hold" };
+  }
+  /** Confirm a downshift — advances index to the lower track. */
+  commitDownshift() {
+    if (this.currentIndex < this.ladder.length - 1) this.currentIndex++;
+  }
+  /** Confirm an upshift — moves index to the higher track. */
+  commitUpshift() {
+    if (this.currentIndex > 0) this.currentIndex--;
+  }
+  /** Reset to a specific ladder index (e.g., after manual selection). */
+  setIndex(index) {
+    this.currentIndex = Math.max(0, Math.min(index, this.ladder.length - 1));
+  }
+};
+export {
+  AdaptiveToleranceController,
+  BandwidthEstimator,
+  BufferBasedController,
+  DEFAULT_TOLERANCE_CONFIG,
+  DecoderState,
+  DecoderStateMachine,
+  DefaultRecoveryController,
+  GapAction,
+  GapDetector,
+  JitterBuffer,
+  PlaybackPipeline,
+  RecoveryPhase,
+  RenderScheduler,
+  StartupBuffer,
+  SyncController,
+  classifyNetwork,
+  isKeyframePayload
+};
+//# sourceMappingURL=index.js.map