@videojs/spf 10.0.0-beta.30 → 10.0.0-beta.32

package/dist/default/media/abr/quality-selection.js.map

@@ -1 +1 @@
-{"version":3,"file":"quality-selection.js","names":[],"sources":["../../../../src/media/abr/quality-selection.ts"],"sourcesContent":["/**\n * Quality Selection Algorithm\n *\n * Selects optimal video track based on bandwidth estimate with safety margin.\n * Stateless selection - picks highest quality that fits bandwidth.\n *\n * Key concepts:\n * - **Safety margin** (0.85): Pick track where bandwidth >= track.bandwidth / 0.85\n * - This ensures 15% headroom to avoid buffering\n * - At same bandwidth, prefer higher resolution\n */\n\nimport type { PartiallyResolvedVideoTrack, VideoTrack } from '../types';\n\n/**\n * Quality selection configuration.\n */\nexport interface QualityConfig {\n  /**\n   * Safety margin (0-1).\n   * To select a track, need: currentBandwidth >= track.bandwidth / safetyMargin.\n   * Default 0.85 means track must use ≤85% of available bandwidth (15% headroom).\n   */\n  safetyMargin: number;\n  /**\n   * Upgrade hysteresis ratio (>= 1). When `currentTrack` is supplied, an\n   * upgrade is applied only if `optimal.bandwidth >= currentTrack.bandwidth * upgradeMargin`.\n   * Downgrades are always applied. Default 1.15 means optimal must clear\n   * the current bandwidth by at least 15% to trigger an upgrade.\n   */\n  upgradeMargin: number;\n}\n\n/**\n * Default quality selection configuration.\n * Values match Shaka Player upgrade threshold (0.85 = 15% headroom).\n */\nexport const DEFAULT_QUALITY_CONFIG: QualityConfig = {\n  safetyMargin: 0.85,\n  upgradeMargin: 1.15,\n};\n\n/**\n * Selection context for `selectQuality`. The `bandwidth` field carries the\n * current network estimate; `safetyMargin` / `upgradeMargin` override the\n * defaults; `currentTrack` enables upgrade-vs-downgrade hysteresis.\n *\n * Shape matches the unified `selectOptimal` contract of\n * `setupTrackSwitching` (`playback/behaviors/track-switching.ts`) so the\n * function can be passed directly as a variant's `selectOptimal`.\n */\nexport interface SelectQualityCtx<T extends { bandwidth: number } = PartiallyResolvedVideoTrack | VideoTrack>\n  extends Partial<QualityConfig> {\n  bandwidth: number;\n  /**\n   * Track currently selected. When supplied, `selectQuality` returns\n   * `currentTrack` (no change) for upgrades that don't clear the\n   * `upgradeMargin`. When omitted, no hysteresis is applied — the\n   * computed optimal is returned regardless.\n   */\n  currentTrack?: T;\n}\n\n/**\n * Select the track to apply now, given a context that carries current\n * bandwidth, an optional `currentTrack`, and tuning overrides. Returns:\n *\n * - The bandwidth-fitting optimal when no `currentTrack` is supplied.\n * - The optimal when it's a downgrade vs. `currentTrack` (downgrades\n *   apply immediately — no hysteresis).\n * - The optimal when it clears `currentTrack.bandwidth * upgradeMargin`\n *   (upgrade clears hysteresis).\n * - `currentTrack` itself when an upgrade doesn't clear the margin\n *   (stay put — caller checks identity to no-op).\n *\n * \"Optimal\" is the highest-bandwidth track where the available bandwidth\n * meets the safety requirement (`bandwidth >= track.bandwidth / safetyMargin`).\n * Falls back to the lowest-bandwidth track when nothing fits the safety\n * margin (preserves a definitive pick under under-bandwidth conditions).\n *\n * @example\n * const tracks = [low, mid, high];\n * selectQuality(tracks, { bandwidth: 5_000_000, currentTrack: low });\n * // Returns `high` if 5 Mbps clears safety AND high.bandwidth >= low.bandwidth * upgradeMargin.\n * // Returns `low` (no-op signal) otherwise.\n */\nexport function selectQuality(\n  tracks: readonly (PartiallyResolvedVideoTrack | VideoTrack)[],\n  ctx: SelectQualityCtx\n): PartiallyResolvedVideoTrack | VideoTrack | undefined {\n  if (tracks.length === 0) {\n    return undefined;\n  }\n\n  const safetyMargin = ctx.safetyMargin ?? DEFAULT_QUALITY_CONFIG.safetyMargin;\n  const upgradeMargin = ctx.upgradeMargin ?? DEFAULT_QUALITY_CONFIG.upgradeMargin;\n  const { bandwidth: currentBandwidth, currentTrack } = ctx;\n\n  // Sort tracks by bandwidth (lowest first)\n  const sortedTracks = tracks.slice().sort((a, b) => a.bandwidth - b.bandwidth);\n\n  // Start with no selection\n  let chosen: PartiallyResolvedVideoTrack | VideoTrack | undefined;\n\n  for (const track of sortedTracks) {\n    // Check if we have enough bandwidth for this track with safety margin\n    // Required bandwidth = track.bandwidth / safetyMargin\n    const requiredBandwidth = track.bandwidth / safetyMargin;\n\n    if (currentBandwidth >= requiredBandwidth) {\n      // We can support this track - prefer it if better than current choice\n      if (\n        !chosen ||\n        track.bandwidth > chosen.bandwidth ||\n        (track.bandwidth === chosen.bandwidth && hasHigherResolution(track, chosen))\n      ) {\n        chosen = track;\n      }\n    }\n  }\n\n  // If no track fits with safety margin, fall back to lowest quality\n  const optimal = chosen ?? sortedTracks[0];\n  if (!optimal) return undefined;\n\n  // Apply upgrade hysteresis. No currentTrack → no hysteresis, return\n  // optimal. Downgrade (optimal.bandwidth < current) → always apply.\n  // Upgrade → only when `optimal.bandwidth >= current * upgradeMargin`,\n  // else stay put (return currentTrack so caller's id-compare no-ops).\n  if (!currentTrack) return optimal;\n  if (optimal.bandwidth < currentTrack.bandwidth) return optimal;\n  if (optimal.bandwidth >= currentTrack.bandwidth * upgradeMargin) return optimal;\n  return currentTrack;\n}\n\n/**\n * Select the lowest-bandwidth track from the candidate set.\n *\n * Used as a safety-net fallback by callers that need a definitive pick when\n * a primary selection algorithm declines to choose. Pairs naturally with\n * `selectQuality` — when ABR has no good answer (e.g., all candidates\n * exceed available bandwidth and the algorithm doesn't fall back\n * internally), the lowest bitrate is the safest default.\n *\n * @param tracks - Candidate tracks (can be unsorted)\n * @returns The lowest-bandwidth track, or `undefined` if `tracks` is empty\n *\n * @example\n * const fallback = selectLowestQuality(tracks);\n */\nexport function selectLowestQuality<T extends { bandwidth: number }>(tracks: readonly T[]): T | undefined {\n  if (tracks.length === 0) return undefined;\n  return tracks.reduce((min, t) => (t.bandwidth < min.bandwidth ? t : min));\n}\n\n/**\n * Resolution as a total pixel count (`width × height`), the basis for\n * comparing two tracks at the same bitrate. Missing dimensions count as 0, so\n * tracks without resolution metadata (e.g. audio) area-compare equal.\n */\nexport function resolutionArea(track: { width?: number; height?: number }): number {\n  return (track.width ?? 0) * (track.height ?? 0);\n}\n\n/**\n * Check if track A has higher resolution than track B.\n * Compares by total pixel count (width × height).\n *\n * @param trackA - First track to compare\n * @param trackB - Second track to compare\n * @returns True if trackA has more pixels than trackB\n */\nfunction hasHigherResolution(\n  trackA: PartiallyResolvedVideoTrack | VideoTrack,\n  trackB: PartiallyResolvedVideoTrack | VideoTrack\n): boolean {\n  return resolutionArea(trackA) > resolutionArea(trackB);\n}\n"],"mappings":";;;;;AAqCA,MAAa,yBAAwC;CACnD,cAAc;CACd,eAAe;AACjB;;;;;;AAwHA,SAAgB,eAAe,OAAoD;CACjF,QAAQ,MAAM,SAAS,MAAM,MAAM,UAAU;AAC/C"}
+{"version":3,"file":"quality-selection.js","names":[],"sources":["../../../../src/media/abr/quality-selection.ts"],"sourcesContent":["/**\n * Quality Selection Algorithm\n *\n * Selects optimal video track based on bandwidth estimate with safety margin. Stateless selection - picks highest\n * quality that fits bandwidth.\n *\n * Key concepts:\n *\n * - **Safety margin** (0.85): Pick track where bandwidth >= track.bandwidth / 0.85\n * - This ensures 15% headroom to avoid buffering\n * - At same bandwidth, prefer higher resolution\n */\n\nimport type { PartiallyResolvedVideoTrack, VideoTrack } from '../types';\n\n/** Quality selection configuration. */\nexport interface QualityConfig {\n  /**\n   * Safety margin (0-1). To select a track, need: currentBandwidth >= track.bandwidth / safetyMargin. Default 0.85\n   * means track must use ≤85% of available bandwidth (15% headroom).\n   */\n  safetyMargin: number;\n  /**\n   * Upgrade hysteresis ratio (>= 1). When `currentTrack` is supplied, an upgrade is applied only if `optimal.bandwidth\n   *\n   * > = currentTrack.bandwidth * upgradeMargin`. Downgrades are always applied. Default 1.15 means optimal must clear the\n   * > current bandwidth by at least 15% to trigger an upgrade.\n   */\n  upgradeMargin: number;\n}\n\n/** Default quality selection configuration. Values match Shaka Player upgrade threshold (0.85 = 15% headroom). */\nexport const DEFAULT_QUALITY_CONFIG: QualityConfig = {\n  safetyMargin: 0.85,\n  upgradeMargin: 1.15,\n};\n\n/**\n * Selection context for `selectQuality`. The `bandwidth` field carries the current network estimate; `safetyMargin` /\n * `upgradeMargin` override the defaults; `currentTrack` enables upgrade-vs-downgrade hysteresis.\n *\n * Shape matches the unified `selectOptimal` contract of `setupTrackSwitching` (`playback/behaviors/track-switching.ts`)\n * so the function can be passed directly as a variant's `selectOptimal`.\n */\nexport interface SelectQualityCtx<\n  T extends { bandwidth: number } = PartiallyResolvedVideoTrack | VideoTrack,\n> extends Partial<QualityConfig> {\n  bandwidth: number;\n  /**\n   * Track currently selected. When supplied, `selectQuality` returns `currentTrack` (no change) for upgrades that don't\n   * clear the `upgradeMargin`. When omitted, no hysteresis is applied — the computed optimal is returned regardless.\n   */\n  currentTrack?: T;\n}\n\n/**\n * Select the track to apply now, given a context that carries current bandwidth, an optional `currentTrack`, and tuning\n * overrides. Returns:\n *\n * - The bandwidth-fitting optimal when no `currentTrack` is supplied.\n * - The optimal when it's a downgrade vs. `currentTrack` (downgrades apply immediately — no hysteresis).\n * - The optimal when it clears `currentTrack.bandwidth * upgradeMargin` (upgrade clears hysteresis).\n * - `currentTrack` itself when an upgrade doesn't clear the margin (stay put — caller checks identity to no-op).\n *\n * \"Optimal\" is the highest-bandwidth track where the available bandwidth meets the safety requirement (`bandwidth >=\n * track.bandwidth / safetyMargin`). Falls back to the lowest-bandwidth track when nothing fits the safety margin\n * (preserves a definitive pick under under-bandwidth conditions).\n *\n * @example\n *   const tracks = [low, mid, high];\n *   selectQuality(tracks, { bandwidth: 5_000_000, currentTrack: low });\n *   // Returns `high` if 5 Mbps clears safety AND high.bandwidth >= low.bandwidth * upgradeMargin.\n *   // Returns `low` (no-op signal) otherwise.\n */\nexport function selectQuality(\n  tracks: readonly (PartiallyResolvedVideoTrack | VideoTrack)[],\n  ctx: SelectQualityCtx\n): PartiallyResolvedVideoTrack | VideoTrack | undefined {\n  if (tracks.length === 0) {\n    return undefined;\n  }\n\n  const safetyMargin = ctx.safetyMargin ?? DEFAULT_QUALITY_CONFIG.safetyMargin;\n  const upgradeMargin = ctx.upgradeMargin ?? DEFAULT_QUALITY_CONFIG.upgradeMargin;\n  const { bandwidth: currentBandwidth, currentTrack } = ctx;\n\n  // Sort tracks by bandwidth (lowest first)\n  const sortedTracks = tracks.slice().sort((a, b) => a.bandwidth - b.bandwidth);\n\n  // Start with no selection\n  let chosen: PartiallyResolvedVideoTrack | VideoTrack | undefined;\n\n  for (const track of sortedTracks) {\n    // Check if we have enough bandwidth for this track with safety margin\n    // Required bandwidth = track.bandwidth / safetyMargin\n    const requiredBandwidth = track.bandwidth / safetyMargin;\n\n    if (currentBandwidth >= requiredBandwidth) {\n      // We can support this track - prefer it if better than current choice\n      if (\n        !chosen ||\n        track.bandwidth > chosen.bandwidth ||\n        (track.bandwidth === chosen.bandwidth && hasHigherResolution(track, chosen))\n      ) {\n        chosen = track;\n      }\n    }\n  }\n\n  // If no track fits with safety margin, fall back to lowest quality\n  const optimal = chosen ?? sortedTracks[0];\n  if (!optimal) return undefined;\n\n  // Apply upgrade hysteresis. No currentTrack → no hysteresis, return\n  // optimal. Downgrade (optimal.bandwidth < current) → always apply.\n  // Upgrade → only when `optimal.bandwidth >= current * upgradeMargin`,\n  // else stay put (return currentTrack so caller's id-compare no-ops).\n  if (!currentTrack) return optimal;\n\n  if (optimal.bandwidth < currentTrack.bandwidth) return optimal;\n\n  if (optimal.bandwidth >= currentTrack.bandwidth * upgradeMargin) return optimal;\n\n  return currentTrack;\n}\n\n/**\n * Select the lowest-bandwidth track from the candidate set.\n *\n * Used as a safety-net fallback by callers that need a definitive pick when a primary selection algorithm declines to\n * choose. Pairs naturally with `selectQuality` — when ABR has no good answer (e.g., all candidates exceed available\n * bandwidth and the algorithm doesn't fall back internally), the lowest bitrate is the safest default.\n *\n * @example\n *   const fallback = selectLowestQuality(tracks);\n *\n * @param tracks - Candidate tracks (can be unsorted)\n * @returns The lowest-bandwidth track, or `undefined` if `tracks` is empty\n */\nexport function selectLowestQuality<T extends { bandwidth: number }>(tracks: readonly T[]): T | undefined {\n  if (tracks.length === 0) return undefined;\n\n  return tracks.reduce((min, t) => (t.bandwidth < min.bandwidth ? t : min));\n}\n\n/**\n * Resolution as a total pixel count (`width × height`), the basis for comparing two tracks at the same bitrate. Missing\n * dimensions count as 0, so tracks without resolution metadata (e.g. audio) area-compare equal.\n */\nexport function resolutionArea(track: { width?: number; height?: number }): number {\n  return (track.width ?? 0) * (track.height ?? 0);\n}\n\n/**\n * Check if track A has higher resolution than track B. Compares by total pixel count (width × height).\n *\n * @param trackA - First track to compare\n * @param trackB - Second track to compare\n * @returns True if trackA has more pixels than trackB\n */\nfunction hasHigherResolution(\n  trackA: PartiallyResolvedVideoTrack | VideoTrack,\n  trackB: PartiallyResolvedVideoTrack | VideoTrack\n): boolean {\n  return resolutionArea(trackA) > resolutionArea(trackB);\n}\n"],"mappings":";;AAgCA,MAAa,yBAAwC;CACnD,cAAc;CACd,eAAe;AACjB;;;;;AAkHA,SAAgB,eAAe,OAAoD;CACjF,QAAQ,MAAM,SAAS,MAAM,MAAM,UAAU;AAC/C"}

package/dist/default/media/buffer/back-buffer.js

@@ -1,35 +1,31 @@
 //#region src/media/buffer/back-buffer.ts
-/**
-* Default back buffer configuration.
-*/
+/** Default back buffer configuration. */
 const DEFAULT_BACK_BUFFER_CONFIG = { keepSegments: 2 };
 /**
 * Calculate back buffer flush point.
 *
-* Determines where to flush old segments from the back buffer.
-* Keeps a fixed number of segments behind the current playback position.
-*
-* Algorithm:
-* 1. Find segments before currentTime
-* 2. Count back N segments (keepSegments)
-* 3. Return startTime of segment N+1 back (flush everything before this)
+* Determines where to flush old segments from the back buffer. Keeps a fixed number of segments behind the current
+* playback position.
 *
-* @param segments - Available segments (should be sorted by startTime)
-* @param currentTime - Current playback position in seconds
-* @param config - Optional back buffer configuration
-* @returns Time in seconds to flush up to (flush range: [0, flushEnd))
+* Algorithm: 1. Find segments before currentTime 2. Count back N segments (keepSegments) 3. Return startTime of segment
+* N+1 back (flush everything before this)
 *
 * @example
-* const segments = [
+*   const segments = [
 *   { startTime: 0, duration: 6, ... },
 *   { startTime: 6, duration: 6, ... },
 *   { startTime: 12, duration: 6, ... },
 *   { startTime: 18, duration: 6, ... },
-* ];
+*   ];
+*
+*   // Playing at 18s, keep 2 segments
+*   const flushEnd = calculateBackBufferFlushPoint(segments, 18);
+*   // Returns 6 (flush [0, 6), keep [6-18))
 *
-* // Playing at 18s, keep 2 segments
-* const flushEnd = calculateBackBufferFlushPoint(segments, 18);
-* // Returns 6 (flush [0, 6), keep [6-18))
+* @param segments - Available segments (should be sorted by startTime)
+* @param currentTime - Current playback position in seconds
+* @param config - Optional back buffer configuration
+* @returns Time in seconds to flush up to (flush range: [0, flushEnd))
 */
 function calculateBackBufferFlushPoint(segments, currentTime, config = DEFAULT_BACK_BUFFER_CONFIG) {
 	if (segments.length === 0) return 0;

package/dist/default/media/buffer/back-buffer.js.map

@@ -1 +1 @@
-{"version":3,"file":"back-buffer.js","names":[],"sources":["../../../../src/media/buffer/back-buffer.ts"],"sourcesContent":["/**\n * Back Buffer Strategy (Simple)\n *\n * Calculates flush points for back buffer management.\n * V1 uses simple \"keep N segments\" strategy.\n */\n\nimport type { Segment } from '../types';\n\n/**\n * Back buffer configuration.\n */\nexport interface BackBufferConfig {\n  /**\n   * Number of segments to keep behind current playback position.\n   * Default: 2 segments.\n   */\n  keepSegments: number;\n}\n\n/**\n * Default back buffer configuration.\n */\nexport const DEFAULT_BACK_BUFFER_CONFIG: BackBufferConfig = {\n  keepSegments: 2,\n};\n\n/**\n * Calculate back buffer flush point.\n *\n * Determines where to flush old segments from the back buffer.\n * Keeps a fixed number of segments behind the current playback position.\n *\n * Algorithm:\n * 1. Find segments before currentTime\n * 2. Count back N segments (keepSegments)\n * 3. Return startTime of segment N+1 back (flush everything before this)\n *\n * @param segments - Available segments (should be sorted by startTime)\n * @param currentTime - Current playback position in seconds\n * @param config - Optional back buffer configuration\n * @returns Time in seconds to flush up to (flush range: [0, flushEnd))\n *\n * @example\n * const segments = [\n *   { startTime: 0, duration: 6, ... },\n *   { startTime: 6, duration: 6, ... },\n *   { startTime: 12, duration: 6, ... },\n *   { startTime: 18, duration: 6, ... },\n * ];\n *\n * // Playing at 18s, keep 2 segments\n * const flushEnd = calculateBackBufferFlushPoint(segments, 18);\n * // Returns 6 (flush [0, 6), keep [6-18))\n */\nexport function calculateBackBufferFlushPoint(\n  segments: Segment[],\n  currentTime: number,\n  config: BackBufferConfig = DEFAULT_BACK_BUFFER_CONFIG\n): number {\n  if (segments.length === 0) {\n    return 0;\n  }\n\n  // Find all segments before current time (not including current segment)\n  const segmentsBefore = segments.filter((seg) => seg.startTime < currentTime);\n\n  // If no segments before current time, nothing to flush\n  if (segmentsBefore.length === 0) {\n    return 0;\n  }\n\n  // Calculate how many segments to flush\n  // Keep last N segments, flush the rest\n  const segmentsToFlush = segmentsBefore.length - config.keepSegments;\n\n  // If we don't have enough segments to flush, keep everything\n  if (segmentsToFlush <= 0) {\n    return 0;\n  }\n\n  // If we want to flush all segments, return currentTime\n  // (flush everything before current playback position)\n  if (segmentsToFlush >= segmentsBefore.length) {\n    return currentTime;\n  }\n\n  // Return the startTime of the first segment we want to keep\n  // Everything before this will be flushed\n  return segmentsBefore[segmentsToFlush]!.startTime;\n}\n"],"mappings":";;;;AAuBA,MAAa,6BAA+C,EAC1D,cAAc,EAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,8BACd,UACA,aACA,SAA2B,4BACnB;CACR,IAAI,SAAS,WAAW,GACtB,OAAO;CAIT,MAAM,iBAAiB,SAAS,QAAQ,QAAQ,IAAI,YAAY,WAAW;CAG3E,IAAI,eAAe,WAAW,GAC5B,OAAO;CAKT,MAAM,kBAAkB,eAAe,SAAS,OAAO;CAGvD,IAAI,mBAAmB,GACrB,OAAO;CAKT,IAAI,mBAAmB,eAAe,QACpC,OAAO;CAKT,OAAO,eAAe,gBAAgB,CAAE;AAC1C"}
+{"version":3,"file":"back-buffer.js","names":[],"sources":["../../../../src/media/buffer/back-buffer.ts"],"sourcesContent":["/**\n * Back Buffer Strategy (Simple)\n *\n * Calculates flush points for back buffer management. V1 uses simple \"keep N segments\" strategy.\n */\n\nimport type { Segment } from '../types';\n\n/** Back buffer configuration. */\nexport interface BackBufferConfig {\n  /** Number of segments to keep behind current playback position. Default: 2 segments. */\n  keepSegments: number;\n}\n\n/** Default back buffer configuration. */\nexport const DEFAULT_BACK_BUFFER_CONFIG: BackBufferConfig = {\n  keepSegments: 2,\n};\n\n/**\n * Calculate back buffer flush point.\n *\n * Determines where to flush old segments from the back buffer. Keeps a fixed number of segments behind the current\n * playback position.\n *\n * Algorithm: 1. Find segments before currentTime 2. Count back N segments (keepSegments) 3. Return startTime of segment\n * N+1 back (flush everything before this)\n *\n * @example\n *   const segments = [\n *   { startTime: 0, duration: 6, ... },\n *   { startTime: 6, duration: 6, ... },\n *   { startTime: 12, duration: 6, ... },\n *   { startTime: 18, duration: 6, ... },\n *   ];\n *\n *   // Playing at 18s, keep 2 segments\n *   const flushEnd = calculateBackBufferFlushPoint(segments, 18);\n *   // Returns 6 (flush [0, 6), keep [6-18))\n *\n * @param segments - Available segments (should be sorted by startTime)\n * @param currentTime - Current playback position in seconds\n * @param config - Optional back buffer configuration\n * @returns Time in seconds to flush up to (flush range: [0, flushEnd))\n */\nexport function calculateBackBufferFlushPoint(\n  segments: Segment[],\n  currentTime: number,\n  config: BackBufferConfig = DEFAULT_BACK_BUFFER_CONFIG\n): number {\n  if (segments.length === 0) {\n    return 0;\n  }\n\n  // Find all segments before current time (not including current segment)\n  const segmentsBefore = segments.filter((seg) => seg.startTime < currentTime);\n  // If no segments before current time, nothing to flush\n  if (segmentsBefore.length === 0) return 0;\n\n  // Calculate how many segments to flush\n  // Keep last N segments, flush the rest\n  const segmentsToFlush = segmentsBefore.length - config.keepSegments;\n  // If we don't have enough segments to flush, keep everything\n  if (segmentsToFlush <= 0) return 0;\n\n  // If we want to flush all segments, return currentTime\n  // (flush everything before current playback position)\n  if (segmentsToFlush >= segmentsBefore.length) {\n    return currentTime;\n  }\n\n  // Return the startTime of the first segment we want to keep\n  // Everything before this will be flushed\n  return segmentsBefore[segmentsToFlush]!.startTime;\n}\n"],"mappings":";;AAeA,MAAa,6BAA+C,EAC1D,cAAc,EAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,8BACd,UACA,aACA,SAA2B,4BACnB;CACR,IAAI,SAAS,WAAW,GACtB,OAAO;CAIT,MAAM,iBAAiB,SAAS,QAAQ,QAAQ,IAAI,YAAY,WAAW;CAE3E,IAAI,eAAe,WAAW,GAAG,OAAO;CAIxC,MAAM,kBAAkB,eAAe,SAAS,OAAO;CAEvD,IAAI,mBAAmB,GAAG,OAAO;CAIjC,IAAI,mBAAmB,eAAe,QACpC,OAAO;CAKT,OAAO,eAAe,gBAAgB,CAAE;AAC1C"}

package/dist/default/media/buffer/forward-buffer.js

@@ -3,12 +3,12 @@ import { SEGMENT_TIME_EPSILON } from "../types/index.js";
 /**
 * Forward Buffer Strategy (Simple)
 *
-* Determines which segments to load for forward buffer management.
-* V1 uses simple fixed-duration strategy (buffer N seconds ahead).
+* Determines which segments to load for forward buffer management. V1 uses simple fixed-duration strategy (buffer N
+* seconds ahead).
 */
 /**
-* Merge intervals into sorted, disjoint ranges; touching or overlapping ranges
-* (gap ≤ `epsilon`) are joined. Empty/inverted ranges are dropped.
+* Merge intervals into sorted, disjoint ranges; touching or overlapping ranges (gap ≤ `epsilon`) are joined.
+* Empty/inverted ranges are dropped.
 */
 function mergeTimeRanges(ranges, epsilon = SEGMENT_TIME_EPSILON) {
 	const sorted = ranges.filter((r) => r.end > r.start).sort((a, b) => a.start - b.start);
@@ -24,63 +24,55 @@ function mergeTimeRanges(ranges, epsilon = SEGMENT_TIME_EPSILON) {
 	return merged;
 }
 /**
-* Whether `[start, end)` is fully covered by the union of `merged` ranges,
-* tolerating `epsilon` of overhang at each edge. `merged` must be disjoint and
-* sorted (as returned by `mergeTimeRanges`), so full coverage means a single
-* merged range contains the interval.
+* Whether `[start, end)` is fully covered by the union of `merged` ranges, tolerating `epsilon` of overhang at each
+* edge. `merged` must be disjoint and sorted (as returned by `mergeTimeRanges`), so full coverage means a single merged
+* range contains the interval.
 */
 function isTimeRangeCovered(start, end, merged, epsilon = SEGMENT_TIME_EPSILON) {
 	return merged.some((r) => r.start <= start + epsilon && r.end >= end - epsilon);
 }
-/**
-* Default forward buffer configuration.
-*/
+/** Default forward buffer configuration. */
 const DEFAULT_FORWARD_BUFFER_CONFIG = { bufferDuration: 30 };
 /**
 * Get segments that need to be loaded for forward buffer.
 *
-* Determines which segments to load to maintain target buffer duration.
-* Handles discontiguous buffering (gaps after seeks).
+* Determines which segments to load to maintain target buffer duration. Handles discontiguous buffering (gaps after
+* seeks).
 *
-* Algorithm:
-* 1. Calculate target time: currentTime + bufferDuration
-* 2. Find all segments in range [currentTime, targetTime)
-* 3. Filter out segments already buffered at that time position
-* 4. Return segments to load (fills gaps + extends to target)
+* Algorithm: 1. Calculate target time: currentTime + bufferDuration 2. Find all segments in range [currentTime,
+* targetTime) 3. Filter out segments already buffered at that time position 4. Return segments to load (fills gaps +
+* extends to target)
+*
+* @example
+*   // After seek: buffered [0-12, 18-30], playing at 7s
+*   const toLoad = getSegmentsToLoad(segments, buffered, 7, { bufferDuration: 24 });
+*   // Returns [seg-12, seg-30] (fills gap, extends to target 31s)
 *
 * @param segments - All available segments from playlist
 * @param bufferedSegments - Segments already buffered (ordered by startTime)
 * @param currentTime - Current playback position in seconds
 * @param config - Optional forward buffer configuration
 * @returns Array of segments to load (empty if buffer is sufficient)
-*
-* @example
-* // After seek: buffered [0-12, 18-30], playing at 7s
-* const toLoad = getSegmentsToLoad(segments, buffered, 7, { bufferDuration: 24 });
-* // Returns [seg-12, seg-30] (fills gap, extends to target 31s)
 */
 /**
 * Calculate the start time from which to flush forward buffer content.
 *
-* Content that starts at or beyond `currentTime + bufferDuration` is no
-* longer needed for the current playback position and should be removed
-* from the SourceBuffer. This prevents unbounded accumulation of scattered
-* SourceBuffer content after seeks, which can cause QuotaExceededError on
-* long-form content.
+* Content that starts at or beyond `currentTime + bufferDuration` is no longer needed for the current playback position
+* and should be removed from the SourceBuffer. This prevents unbounded accumulation of scattered SourceBuffer content
+* after seeks, which can cause QuotaExceededError on long-form content.
+*
+* Returns `Infinity` when nothing needs flushing (no buffered segments exist beyond the threshold).
 *
-* Returns `Infinity` when nothing needs flushing (no buffered segments
-* exist beyond the threshold).
+* @example
+*   // Playing at 0s, buffered [0,6,12,18,24,30,36], bufferDuration=30
+*   const flushStart = calculateForwardFlushPoint(segments, 0);
+*   // Returns 30 — flush [30, Infinity), keep [0, 30)
 *
 * @param bufferedSegments - Segments currently tracked in the buffer model
 * @param currentTime - Current playback position in seconds
 * @param config - Optional forward buffer configuration
 * @returns Start time to flush from (flush range: [flushStart, Infinity)),
-*          or Infinity if no flush is needed
-*
-* @example
-* // Playing at 0s, buffered [0,6,12,18,24,30,36], bufferDuration=30
-* const flushStart = calculateForwardFlushPoint(segments, 0);
-* // Returns 30 — flush [30, Infinity), keep [0, 30)
+* or Infinity if no flush is needed
 */
 function calculateForwardFlushPoint(bufferedSegments, currentTime, config = DEFAULT_FORWARD_BUFFER_CONFIG) {
 	if (bufferedSegments.length === 0) return Infinity;
@@ -90,12 +82,11 @@ function calculateForwardFlushPoint(bufferedSegments, currentTime, config = DEFA
 	return Math.min(...beyond.map((seg) => seg.startTime));
 }
 /**
-* Find the start time of the segment containing `currentTime` (or the last
-* segment if `currentTime` is past the end). Returns `undefined` when
-* `currentTime` is undefined or when no segment matches.
+* Find the start time of the segment containing `currentTime` (or the last segment if `currentTime` is past the end).
+* Returns `undefined` when `currentTime` is undefined or when no segment matches.
 *
-* Used to detect "meaningful currentTime change" — two times that map to the
-* same segment start aren't a load-trigger; crossing a segment boundary is.
+* Used to detect "meaningful currentTime change" — two times that map to the same segment start aren't a load-trigger;
+* crossing a segment boundary is.
 */
 function segmentStartForTime(currentTime, segments) {
 	if (currentTime == null) return void 0;

package/dist/default/media/buffer/forward-buffer.js.map

@@ -1 +1 @@
-{"version":3,"file":"forward-buffer.js","names":[],"sources":["../../../../src/media/buffer/forward-buffer.ts"],"sourcesContent":["/**\n * Forward Buffer Strategy (Simple)\n *\n * Determines which segments to load for forward buffer management.\n * V1 uses simple fixed-duration strategy (buffer N seconds ahead).\n */\n\nimport { SEGMENT_TIME_EPSILON, type Segment } from '../types';\n\n/** A half-open `[start, end)` interval on the presentation timeline. */\nexport interface TimeRange {\n  start: number;\n  end: number;\n}\n\n/**\n * Merge intervals into sorted, disjoint ranges; touching or overlapping ranges\n * (gap ≤ `epsilon`) are joined. Empty/inverted ranges are dropped.\n */\nexport function mergeTimeRanges(ranges: readonly TimeRange[], epsilon = SEGMENT_TIME_EPSILON): TimeRange[] {\n  const sorted = ranges.filter((r) => r.end > r.start).sort((a, b) => a.start - b.start);\n  const merged: TimeRange[] = [];\n  for (const r of sorted) {\n    const last = merged[merged.length - 1];\n    if (last && r.start <= last.end + epsilon) {\n      last.end = Math.max(last.end, r.end);\n    } else {\n      merged.push({ start: r.start, end: r.end });\n    }\n  }\n  return merged;\n}\n\n/**\n * Whether `[start, end)` is fully covered by the union of `merged` ranges,\n * tolerating `epsilon` of overhang at each edge. `merged` must be disjoint and\n * sorted (as returned by `mergeTimeRanges`), so full coverage means a single\n * merged range contains the interval.\n */\nexport function isTimeRangeCovered(\n  start: number,\n  end: number,\n  merged: readonly TimeRange[],\n  epsilon = SEGMENT_TIME_EPSILON\n): boolean {\n  return merged.some((r) => r.start <= start + epsilon && r.end >= end - epsilon);\n}\n\n/**\n * Forward buffer configuration.\n */\nexport interface ForwardBufferConfig {\n  /**\n   * Duration in seconds to buffer ahead of current playback position.\n   * Default: 30 seconds.\n   */\n  bufferDuration: number;\n}\n\n/**\n * Default forward buffer configuration.\n */\nexport const DEFAULT_FORWARD_BUFFER_CONFIG: ForwardBufferConfig = {\n  bufferDuration: 30,\n};\n\n/**\n * Get segments that need to be loaded for forward buffer.\n *\n * Determines which segments to load to maintain target buffer duration.\n * Handles discontiguous buffering (gaps after seeks).\n *\n * Algorithm:\n * 1. Calculate target time: currentTime + bufferDuration\n * 2. Find all segments in range [currentTime, targetTime)\n * 3. Filter out segments already buffered at that time position\n * 4. Return segments to load (fills gaps + extends to target)\n *\n * @param segments - All available segments from playlist\n * @param bufferedSegments - Segments already buffered (ordered by startTime)\n * @param currentTime - Current playback position in seconds\n * @param config - Optional forward buffer configuration\n * @returns Array of segments to load (empty if buffer is sufficient)\n *\n * @example\n * // After seek: buffered [0-12, 18-30], playing at 7s\n * const toLoad = getSegmentsToLoad(segments, buffered, 7, { bufferDuration: 24 });\n * // Returns [seg-12, seg-30] (fills gap, extends to target 31s)\n */\n/**\n * Calculate the start time from which to flush forward buffer content.\n *\n * Content that starts at or beyond `currentTime + bufferDuration` is no\n * longer needed for the current playback position and should be removed\n * from the SourceBuffer. This prevents unbounded accumulation of scattered\n * SourceBuffer content after seeks, which can cause QuotaExceededError on\n * long-form content.\n *\n * Returns `Infinity` when nothing needs flushing (no buffered segments\n * exist beyond the threshold).\n *\n * @param bufferedSegments - Segments currently tracked in the buffer model\n * @param currentTime - Current playback position in seconds\n * @param config - Optional forward buffer configuration\n * @returns Start time to flush from (flush range: [flushStart, Infinity)),\n *          or Infinity if no flush is needed\n *\n * @example\n * // Playing at 0s, buffered [0,6,12,18,24,30,36], bufferDuration=30\n * const flushStart = calculateForwardFlushPoint(segments, 0);\n * // Returns 30 — flush [30, Infinity), keep [0, 30)\n */\nexport function calculateForwardFlushPoint(\n  bufferedSegments: readonly Segment[],\n  currentTime: number,\n  config: ForwardBufferConfig = DEFAULT_FORWARD_BUFFER_CONFIG\n): number {\n  if (bufferedSegments.length === 0) return Infinity;\n\n  const threshold = currentTime + config.bufferDuration;\n\n  // Find segments that start at or beyond the threshold\n  const beyond = bufferedSegments.filter((seg) => seg.startTime >= threshold);\n\n  if (beyond.length === 0) return Infinity;\n\n  // Flush from the earliest such segment onward\n  return Math.min(...beyond.map((seg) => seg.startTime));\n}\n\n/**\n * Find the start time of the segment containing `currentTime` (or the last\n * segment if `currentTime` is past the end). Returns `undefined` when\n * `currentTime` is undefined or when no segment matches.\n *\n * Used to detect \"meaningful currentTime change\" — two times that map to the\n * same segment start aren't a load-trigger; crossing a segment boundary is.\n */\nexport function segmentStartForTime(\n  currentTime: number | undefined,\n  segments: readonly Pick<Segment, 'startTime' | 'duration'>[] | undefined\n): number | undefined {\n  if (currentTime == null) return undefined;\n  return segments?.find(\n    ({ startTime, duration }, i, all) =>\n      currentTime >= startTime && (currentTime < startTime + duration || i === all.length - 1)\n  )?.startTime;\n}\n\nexport function getSegmentsToLoad(\n  segments: readonly Segment[],\n  bufferedSegments: readonly Pick<Segment, 'startTime' | 'duration'>[],\n  currentTime: number,\n  config: ForwardBufferConfig = DEFAULT_FORWARD_BUFFER_CONFIG\n): Segment[] {\n  if (segments.length === 0) {\n    return [];\n  }\n\n  // Calculate target buffer end time\n  const targetTime = currentTime + config.bufferDuration;\n\n  // Create set of buffered segment start times for fast lookup\n  // V1 simple: if ANY segment is buffered at a given time, don't load for that time\n  // V2 (future): would compare by startTime + bitrate/track for quality switching\n  const bufferedStartTimes = new Set(bufferedSegments.map((seg) => seg.startTime));\n\n  // Find segments to load:\n  // - Overlaps buffer window [currentTime, targetTime)\n  // - Not already buffered at that time position\n  const toLoad = segments.filter((seg, i) => {\n    const segmentEnd = seg.startTime + seg.duration;\n    const isLast = i === segments.length - 1;\n    // Interior segments use strict `>` so a segment the playhead just finished\n    // (endTime === currentTime at a boundary) isn't reloaded. The terminal\n    // segment has no successor and no reachable position past it — the playhead\n    // is clamped to the presentation's range — so it needs no upper bound: it's\n    // loadable whenever the forward window reaches it. That resolves the\n    // exact-end seek (#1828) and the post-loop re-seek — where\n    // `MediaSource.duration`, clamped by `endOfStream()` to the true buffered\n    // end, has grown a hair past the model's EXTINF-derived end — with no\n    // dependency on any duration value.\n    //\n    // LIVE: for an un-ended live/DVR presentation `isLast` is the sliding edge\n    // segment; loading it eagerly here is benign today (forward-window-bounded,\n    // deduped by the buffered check), but the live effort should confirm the\n    // edge / end-of-stream interaction when it lands.\n    const overlapsPlayhead = isLast || segmentEnd > currentTime;\n    const isInRange = seg.startTime < targetTime && overlapsPlayhead;\n\n    // Must not have a segment buffered at this time position\n    const isNotBuffered = !bufferedStartTimes.has(seg.startTime);\n\n    return isInRange && isNotBuffered;\n  });\n\n  return toLoad;\n}\n"],"mappings":";;;;;;;;;;;;AAmBA,SAAgB,gBAAgB,QAA8B,UAAU,sBAAmC;CACzG,MAAM,SAAS,OAAO,QAAQ,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,KAAK;CACrF,MAAM,SAAsB,CAAC;CAC7B,KAAK,MAAM,KAAK,QAAQ;EACtB,MAAM,OAAO,OAAO,OAAO,SAAS;EACpC,IAAI,QAAQ,EAAE,SAAS,KAAK,MAAM,SAChC,KAAK,MAAM,KAAK,IAAI,KAAK,KAAK,EAAE,GAAG;OAEnC,OAAO,KAAK;GAAE,OAAO,EAAE;GAAO,KAAK,EAAE;EAAI,CAAC;CAE9C;CACA,OAAO;AACT;;;;;;;AAQA,SAAgB,mBACd,OACA,KACA,QACA,UAAU,sBACD;CACT,OAAO,OAAO,MAAM,MAAM,EAAE,SAAS,QAAQ,WAAW,EAAE,OAAO,MAAM,OAAO;AAChF;;;;AAgBA,MAAa,gCAAqD,EAChE,gBAAgB,GAClB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,2BACd,kBACA,aACA,SAA8B,+BACtB;CACR,IAAI,iBAAiB,WAAW,GAAG,OAAO;CAE1C,MAAM,YAAY,cAAc,OAAO;CAGvC,MAAM,SAAS,iBAAiB,QAAQ,QAAQ,IAAI,aAAa,SAAS;CAE1E,IAAI,OAAO,WAAW,GAAG,OAAO;CAGhC,OAAO,KAAK,IAAI,GAAG,OAAO,KAAK,QAAQ,IAAI,SAAS,CAAC;AACvD;;;;;;;;;AAUA,SAAgB,oBACd,aACA,UACoB;CACpB,IAAI,eAAe,MAAM,OAAO,KAAA;CAChC,OAAO,UAAU,MACd,EAAE,WAAW,YAAY,GAAG,QAC3B,eAAe,cAAc,cAAc,YAAY,YAAY,MAAM,IAAI,SAAS,EAC1F,CAAC,EAAE;AACL;AAEA,SAAgB,kBACd,UACA,kBACA,aACA,SAA8B,+BACnB;CACX,IAAI,SAAS,WAAW,GACtB,OAAO,CAAC;CAIV,MAAM,aAAa,cAAc,OAAO;CAKxC,MAAM,qBAAqB,IAAI,IAAI,iBAAiB,KAAK,QAAQ,IAAI,SAAS,CAAC;CA+B/E,OA1Be,SAAS,QAAQ,KAAK,MAAM;EACzC,MAAM,aAAa,IAAI,YAAY,IAAI;EAgBvC,MAAM,mBAfS,MAAM,SAAS,SAAS,KAeJ,aAAa;EAChD,MAAM,YAAY,IAAI,YAAY,cAAc;EAGhD,MAAM,gBAAgB,CAAC,mBAAmB,IAAI,IAAI,SAAS;EAE3D,OAAO,aAAa;CACtB,CAEY;AACd"}
+{"version":3,"file":"forward-buffer.js","names":[],"sources":["../../../../src/media/buffer/forward-buffer.ts"],"sourcesContent":["/**\n * Forward Buffer Strategy (Simple)\n *\n * Determines which segments to load for forward buffer management. V1 uses simple fixed-duration strategy (buffer N\n * seconds ahead).\n */\n\nimport { SEGMENT_TIME_EPSILON, type Segment } from '../types';\n\n/** A half-open `[start, end)` interval on the presentation timeline. */\nexport interface TimeRange {\n  start: number;\n  end: number;\n}\n\n/**\n * Merge intervals into sorted, disjoint ranges; touching or overlapping ranges (gap ≤ `epsilon`) are joined.\n * Empty/inverted ranges are dropped.\n */\nexport function mergeTimeRanges(ranges: readonly TimeRange[], epsilon = SEGMENT_TIME_EPSILON): TimeRange[] {\n  const sorted = ranges.filter((r) => r.end > r.start).sort((a, b) => a.start - b.start);\n  const merged: TimeRange[] = [];\n\n  for (const r of sorted) {\n    const last = merged[merged.length - 1];\n\n    if (last && r.start <= last.end + epsilon) {\n      last.end = Math.max(last.end, r.end);\n    } else {\n      merged.push({ start: r.start, end: r.end });\n    }\n  }\n\n  return merged;\n}\n\n/**\n * Whether `[start, end)` is fully covered by the union of `merged` ranges, tolerating `epsilon` of overhang at each\n * edge. `merged` must be disjoint and sorted (as returned by `mergeTimeRanges`), so full coverage means a single merged\n * range contains the interval.\n */\nexport function isTimeRangeCovered(\n  start: number,\n  end: number,\n  merged: readonly TimeRange[],\n  epsilon = SEGMENT_TIME_EPSILON\n): boolean {\n  return merged.some((r) => r.start <= start + epsilon && r.end >= end - epsilon);\n}\n\n/** Forward buffer configuration. */\nexport interface ForwardBufferConfig {\n  /** Duration in seconds to buffer ahead of current playback position. Default: 30 seconds. */\n  bufferDuration: number;\n}\n\n/** Default forward buffer configuration. */\nexport const DEFAULT_FORWARD_BUFFER_CONFIG: ForwardBufferConfig = {\n  bufferDuration: 30,\n};\n\n/**\n * Get segments that need to be loaded for forward buffer.\n *\n * Determines which segments to load to maintain target buffer duration. Handles discontiguous buffering (gaps after\n * seeks).\n *\n * Algorithm: 1. Calculate target time: currentTime + bufferDuration 2. Find all segments in range [currentTime,\n * targetTime) 3. Filter out segments already buffered at that time position 4. Return segments to load (fills gaps +\n * extends to target)\n *\n * @example\n *   // After seek: buffered [0-12, 18-30], playing at 7s\n *   const toLoad = getSegmentsToLoad(segments, buffered, 7, { bufferDuration: 24 });\n *   // Returns [seg-12, seg-30] (fills gap, extends to target 31s)\n *\n * @param segments - All available segments from playlist\n * @param bufferedSegments - Segments already buffered (ordered by startTime)\n * @param currentTime - Current playback position in seconds\n * @param config - Optional forward buffer configuration\n * @returns Array of segments to load (empty if buffer is sufficient)\n */\n/**\n * Calculate the start time from which to flush forward buffer content.\n *\n * Content that starts at or beyond `currentTime + bufferDuration` is no longer needed for the current playback position\n * and should be removed from the SourceBuffer. This prevents unbounded accumulation of scattered SourceBuffer content\n * after seeks, which can cause QuotaExceededError on long-form content.\n *\n * Returns `Infinity` when nothing needs flushing (no buffered segments exist beyond the threshold).\n *\n * @example\n *   // Playing at 0s, buffered [0,6,12,18,24,30,36], bufferDuration=30\n *   const flushStart = calculateForwardFlushPoint(segments, 0);\n *   // Returns 30 — flush [30, Infinity), keep [0, 30)\n *\n * @param bufferedSegments - Segments currently tracked in the buffer model\n * @param currentTime - Current playback position in seconds\n * @param config - Optional forward buffer configuration\n * @returns Start time to flush from (flush range: [flushStart, Infinity)),\n * or Infinity if no flush is needed\n */\nexport function calculateForwardFlushPoint(\n  bufferedSegments: readonly Segment[],\n  currentTime: number,\n  config: ForwardBufferConfig = DEFAULT_FORWARD_BUFFER_CONFIG\n): number {\n  if (bufferedSegments.length === 0) return Infinity;\n\n  const threshold = currentTime + config.bufferDuration;\n\n  // Find segments that start at or beyond the threshold\n  const beyond = bufferedSegments.filter((seg) => seg.startTime >= threshold);\n  if (beyond.length === 0) return Infinity;\n\n  // Flush from the earliest such segment onward\n  return Math.min(...beyond.map((seg) => seg.startTime));\n}\n\n/**\n * Find the start time of the segment containing `currentTime` (or the last segment if `currentTime` is past the end).\n * Returns `undefined` when `currentTime` is undefined or when no segment matches.\n *\n * Used to detect \"meaningful currentTime change\" — two times that map to the same segment start aren't a load-trigger;\n * crossing a segment boundary is.\n */\nexport function segmentStartForTime(\n  currentTime: number | undefined,\n  segments: readonly Pick<Segment, 'startTime' | 'duration'>[] | undefined\n): number | undefined {\n  if (currentTime == null) return undefined;\n\n  return segments?.find(\n    ({ startTime, duration }, i, all) =>\n      currentTime >= startTime && (currentTime < startTime + duration || i === all.length - 1)\n  )?.startTime;\n}\n\nexport function getSegmentsToLoad(\n  segments: readonly Segment[],\n  bufferedSegments: readonly Pick<Segment, 'startTime' | 'duration'>[],\n  currentTime: number,\n  config: ForwardBufferConfig = DEFAULT_FORWARD_BUFFER_CONFIG\n): Segment[] {\n  if (segments.length === 0) {\n    return [];\n  }\n\n  // Calculate target buffer end time\n  const targetTime = currentTime + config.bufferDuration;\n\n  // Create set of buffered segment start times for fast lookup\n  // V1 simple: if ANY segment is buffered at a given time, don't load for that time\n  // V2 (future): would compare by startTime + bitrate/track for quality switching\n  const bufferedStartTimes = new Set(bufferedSegments.map((seg) => seg.startTime));\n\n  // Find segments to load:\n  // - Overlaps buffer window [currentTime, targetTime)\n  // - Not already buffered at that time position\n  const toLoad = segments.filter((seg, i) => {\n    const segmentEnd = seg.startTime + seg.duration;\n    const isLast = i === segments.length - 1;\n    // Interior segments use strict `>` so a segment the playhead just finished\n    // (endTime === currentTime at a boundary) isn't reloaded. The terminal\n    // segment has no successor and no reachable position past it — the playhead\n    // is clamped to the presentation's range — so it needs no upper bound: it's\n    // loadable whenever the forward window reaches it. That resolves the\n    // exact-end seek (#1828) and the post-loop re-seek — where\n    // `MediaSource.duration`, clamped by `endOfStream()` to the true buffered\n    // end, has grown a hair past the model's EXTINF-derived end — with no\n    // dependency on any duration value.\n    //\n    // LIVE: for an un-ended live/DVR presentation `isLast` is the sliding edge\n    // segment; loading it eagerly here is benign today (forward-window-bounded,\n    // deduped by the buffered check), but the live effort should confirm the\n    // edge / end-of-stream interaction when it lands.\n    const overlapsPlayhead = isLast || segmentEnd > currentTime;\n    const isInRange = seg.startTime < targetTime && overlapsPlayhead;\n\n    // Must not have a segment buffered at this time position\n    const isNotBuffered = !bufferedStartTimes.has(seg.startTime);\n\n    return isInRange && isNotBuffered;\n  });\n\n  return toLoad;\n}\n"],"mappings":";;;;;;;;;;;;AAmBA,SAAgB,gBAAgB,QAA8B,UAAU,sBAAmC;CACzG,MAAM,SAAS,OAAO,QAAQ,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,KAAK;CACrF,MAAM,SAAsB,CAAC;CAE7B,KAAK,MAAM,KAAK,QAAQ;EACtB,MAAM,OAAO,OAAO,OAAO,SAAS;EAEpC,IAAI,QAAQ,EAAE,SAAS,KAAK,MAAM,SAChC,KAAK,MAAM,KAAK,IAAI,KAAK,KAAK,EAAE,GAAG;OAEnC,OAAO,KAAK;GAAE,OAAO,EAAE;GAAO,KAAK,EAAE;EAAI,CAAC;CAE9C;CAEA,OAAO;AACT;;;;;;AAOA,SAAgB,mBACd,OACA,KACA,QACA,UAAU,sBACD;CACT,OAAO,OAAO,MAAM,MAAM,EAAE,SAAS,QAAQ,WAAW,EAAE,OAAO,MAAM,OAAO;AAChF;;AASA,MAAa,gCAAqD,EAChE,gBAAgB,GAClB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,SAAgB,2BACd,kBACA,aACA,SAA8B,+BACtB;CACR,IAAI,iBAAiB,WAAW,GAAG,OAAO;CAE1C,MAAM,YAAY,cAAc,OAAO;CAGvC,MAAM,SAAS,iBAAiB,QAAQ,QAAQ,IAAI,aAAa,SAAS;CAC1E,IAAI,OAAO,WAAW,GAAG,OAAO;CAGhC,OAAO,KAAK,IAAI,GAAG,OAAO,KAAK,QAAQ,IAAI,SAAS,CAAC;AACvD;;;;;;;;AASA,SAAgB,oBACd,aACA,UACoB;CACpB,IAAI,eAAe,MAAM,OAAO,KAAA;CAEhC,OAAO,UAAU,MACd,EAAE,WAAW,YAAY,GAAG,QAC3B,eAAe,cAAc,cAAc,YAAY,YAAY,MAAM,IAAI,SAAS,EAC1F,CAAC,EAAE;AACL;AAEA,SAAgB,kBACd,UACA,kBACA,aACA,SAA8B,+BACnB;CACX,IAAI,SAAS,WAAW,GACtB,OAAO,CAAC;CAIV,MAAM,aAAa,cAAc,OAAO;CAKxC,MAAM,qBAAqB,IAAI,IAAI,iBAAiB,KAAK,QAAQ,IAAI,SAAS,CAAC;CA+B/E,OA1Be,SAAS,QAAQ,KAAK,MAAM;EACzC,MAAM,aAAa,IAAI,YAAY,IAAI;EAgBvC,MAAM,mBAfS,MAAM,SAAS,SAAS,KAeJ,aAAa;EAChD,MAAM,YAAY,IAAI,YAAY,cAAc;EAGhD,MAAM,gBAAgB,CAAC,mBAAmB,IAAI,IAAI,SAAS;EAE3D,OAAO,aAAa;CACtB,CAEY;AACd"}

package/dist/default/media/dom/capabilities.js

@@ -3,52 +3,41 @@ import { NON_FMP4_CONTAINER_MIMES } from "../hls/parse-media-playlist.js";
 import { buildMimeCodec, isCodecSupported } from "./mse/mediasource-setup.js";
 //#region src/media/dom/capabilities.ts
 /**
-* Capability probing — the engine's foundation for asking the browser what it
-* can actually decode before committing a rendition to the pipeline.
+* Capability probing — the engine's foundation for asking the browser what it can actually decode before committing a
+* rendition to the pipeline.
 *
-* Today this is the synchronous codec half: `canPlayTrack` answers "can this
-* environment play this track?" by building the track's MIME codec string and
-* passing it to `MediaSource.isTypeSupported` (via `isCodecSupported`). It's the
-* DOM implementation of the DOM-free `CanPlayTrack` predicate the
-* track-switching hard-constraint pre-pass consumes — injected through engine
-* config so the (DOM-free) behavior never imports a DOM API directly.
+* Today this is the synchronous codec half: `canPlayTrack` answers "can this environment play this track?" by building
+* the track's MIME codec string and passing it to `MediaSource.isTypeSupported` (via `isCodecSupported`). It's the DOM
+* implementation of the DOM-free `CanPlayTrack` predicate the track-switching hard-constraint pre-pass consumes —
+* injected through engine config so the (DOM-free) behavior never imports a DOM API directly.
 *
-* Results are memoized by built MIME string: codec support is a pure function
-* of (codec, environment) and never changes after load, so probing is lazy
-* (per candidate, at constraint-apply time) but each unique MIME is asked once.
+* Results are memoized by built MIME string: codec support is a pure function of (codec, environment) and never changes
+* after load, so probing is lazy (per candidate, at constraint-apply time) but each unique MIME is asked once.
 *
-* Future cluster-D phases (async `requestMediaKeySystemAccess` key-system
-* probing, `SourceBuffer.changeType()` availability) extend this surface; the
-* async ones land as a state-slot writer behavior rather than a config
+* Future cluster-D phases (async `requestMediaKeySystemAccess` key-system probing, `SourceBuffer.changeType()`
+* availability) extend this surface; the async ones land as a state-slot writer behavior rather than a config
 * predicate, since their verdict resolves asynchronously.
 */
 const codecSupportCache = /* @__PURE__ */ new Map();
 /**
-* Whether the environment can decode `track`, by codec. Builds the track's
-* MIME codec string and checks `MediaSource.isTypeSupported`, memoized by MIME.
-* A track without enough to probe — no `mimeType`, or no declared `codecs`
-* (CODECS is optional per the HLS spec) — is unprobeable and passes through as
-* playable (`true`) rather than being dropped; the late `createSourceBuffer`
-* check stays as the backstop for those.
+* Whether the environment can decode `track`, by codec. Builds the track's MIME codec string and checks
+* `MediaSource.isTypeSupported`, memoized by MIME. A track without enough to probe — no `mimeType`, or no declared
+* `codecs` (CODECS is optional per the HLS spec) — is unprobeable and passes through as playable (`true`) rather than
+* being dropped; the late `createSourceBuffer` check stays as the backstop for those.
 *
-* Detected non-fMP4 containers (`video/mp2t`, `audio/aac`) are asserted
-* unsupported regardless of the probe, so they're pruned before selection
-* (the type makes no pick) instead of failing/stalling deep in the pipeline.
-* Two different reasons, neither UA-based:
+* Detected non-fMP4 containers (`video/mp2t`, `audio/aac`) are asserted unsupported regardless of the probe, so they're
+* pruned before selection (the type makes no pick) instead of failing/stalling deep in the pipeline. Two different
+* reasons, neither UA-based:
 *
-* - **MPEG-TS** can't be played at all here: `isTypeSupported('video/mp2t…')` is
-*   a genuine false positive on Chromium (reports `true` but appends produce no
-*   buffered range), and this engine has no TS transmux pipeline.
-* - **Raw ADTS AAC** is a *temporary* limitation. The browser genuinely
-*   supports it (Chrome/Safari decode `audio/aac`; Firefox doesn't), so it could
-*   be made playable — but our segment actors / loading behaviors / append
-*   pipeline assume every rendition has an `EXT-X-MAP` init segment (e.g. an
-*   `append-init` task with an empty URL, fMP4-shaped append handling). Until
-*   that init-segment assumption is removed, ADTS would fetch but never buffer
-*   (a silent stall), so we assert it unplayable for now. FOLLOW-UP: drop the
-*   init-required assumption in the pipeline and switch this to a bare-MIME
-*   probe (`buildMimeCodec` would project `audio/aac` with no codecs) so it
-*   plays where the browser supports it.
+* - **MPEG-TS** can't be played at all here: `isTypeSupported('video/mp2t…')` is a genuine false positive on Chromium
+*   (reports `true` but appends produce no buffered range), and this engine has no TS transmux pipeline.
+* - **Raw ADTS AAC** is a _temporary_ limitation. The browser genuinely supports it (Chrome/Safari decode `audio/aac`;
+*   Firefox doesn't), so it could be made playable — but our segment actors / loading behaviors / append pipeline
+*   assume every rendition has an `EXT-X-MAP` init segment (e.g. an `append-init` task with an empty URL, fMP4-shaped
+*   append handling). Until that init-segment assumption is removed, ADTS would fetch but never buffer (a silent
+*   stall), so we assert it unplayable for now. FOLLOW-UP: drop the init-required assumption in the pipeline and switch
+*   this to a bare-MIME probe (`buildMimeCodec` would project `audio/aac` with no codecs) so it plays where the browser
+*   supports it.
 *
 * Override via the engine's `canPlayTrack` config when those pipelines land.
 */

package/dist/default/media/dom/capabilities.js.map

@@ -1 +1 @@
-{"version":3,"file":"capabilities.js","names":[],"sources":["../../../../src/media/dom/capabilities.ts"],"sourcesContent":["/**\n * Capability probing — the engine's foundation for asking the browser what it\n * can actually decode before committing a rendition to the pipeline.\n *\n * Today this is the synchronous codec half: `canPlayTrack` answers \"can this\n * environment play this track?\" by building the track's MIME codec string and\n * passing it to `MediaSource.isTypeSupported` (via `isCodecSupported`). It's the\n * DOM implementation of the DOM-free `CanPlayTrack` predicate the\n * track-switching hard-constraint pre-pass consumes — injected through engine\n * config so the (DOM-free) behavior never imports a DOM API directly.\n *\n * Results are memoized by built MIME string: codec support is a pure function\n * of (codec, environment) and never changes after load, so probing is lazy\n * (per candidate, at constraint-apply time) but each unique MIME is asked once.\n *\n * Future cluster-D phases (async `requestMediaKeySystemAccess` key-system\n * probing, `SourceBuffer.changeType()` availability) extend this surface; the\n * async ones land as a state-slot writer behavior rather than a config\n * predicate, since their verdict resolves asynchronously.\n */\n\nimport { NON_FMP4_CONTAINER_MIMES } from '../hls/parse-media-playlist';\nimport { type CanPlayTrack, getMediaPlaylistMetadata } from '../types';\nimport { buildMimeCodec, isCodecSupported } from './mse/mediasource-setup';\n\nconst codecSupportCache = new Map<string, boolean>();\n\n/**\n * Whether the environment can decode `track`, by codec. Builds the track's\n * MIME codec string and checks `MediaSource.isTypeSupported`, memoized by MIME.\n * A track without enough to probe — no `mimeType`, or no declared `codecs`\n * (CODECS is optional per the HLS spec) — is unprobeable and passes through as\n * playable (`true`) rather than being dropped; the late `createSourceBuffer`\n * check stays as the backstop for those.\n *\n * Detected non-fMP4 containers (`video/mp2t`, `audio/aac`) are asserted\n * unsupported regardless of the probe, so they're pruned before selection\n * (the type makes no pick) instead of failing/stalling deep in the pipeline.\n * Two different reasons, neither UA-based:\n *\n * - **MPEG-TS** can't be played at all here: `isTypeSupported('video/mp2t…')` is\n *   a genuine false positive on Chromium (reports `true` but appends produce no\n *   buffered range), and this engine has no TS transmux pipeline.\n * - **Raw ADTS AAC** is a *temporary* limitation. The browser genuinely\n *   supports it (Chrome/Safari decode `audio/aac`; Firefox doesn't), so it could\n *   be made playable — but our segment actors / loading behaviors / append\n *   pipeline assume every rendition has an `EXT-X-MAP` init segment (e.g. an\n *   `append-init` task with an empty URL, fMP4-shaped append handling). Until\n *   that init-segment assumption is removed, ADTS would fetch but never buffer\n *   (a silent stall), so we assert it unplayable for now. FOLLOW-UP: drop the\n *   init-required assumption in the pipeline and switch this to a bare-MIME\n *   probe (`buildMimeCodec` would project `audio/aac` with no codecs) so it\n *   plays where the browser supports it.\n *\n * Override via the engine's `canPlayTrack` config when those pipelines land.\n */\nexport const canPlayTrack: CanPlayTrack = (track) => {\n  if (track.mimeType && NON_FMP4_CONTAINER_MIMES.has(track.mimeType)) return false;\n  // Encrypted renditions are unplayable *for now* — this engine has no EME /\n  // license pipeline, so appending them would fail to decode with nothing to\n  // explain it. Pruning them here means a partially-encrypted source still plays\n  // its clear renditions, and a fully-encrypted one empties the candidate set\n  // (which `track-switching` reports). Remove this when DRM support lands.\n  if (getMediaPlaylistMetadata(track)?.encrypted) return false;\n  if (!track.mimeType || !track.codecs?.length) return true;\n  const mimeCodec = buildMimeCodec({ mimeType: track.mimeType, codecs: track.codecs });\n  const cached = codecSupportCache.get(mimeCodec);\n  if (cached !== undefined) return cached;\n  const supported = isCodecSupported(mimeCodec);\n  codecSupportCache.set(mimeCodec, supported);\n  return supported;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAM,oCAAoB,IAAI,IAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BnD,MAAa,gBAA8B,UAAU;CACnD,IAAI,MAAM,YAAY,yBAAyB,IAAI,MAAM,QAAQ,GAAG,OAAO;CAM3E,IAAI,yBAAyB,KAAK,CAAC,EAAE,WAAW,OAAO;CACvD,IAAI,CAAC,MAAM,YAAY,CAAC,MAAM,QAAQ,QAAQ,OAAO;CACrD,MAAM,YAAY,eAAe;EAAE,UAAU,MAAM;EAAU,QAAQ,MAAM;CAAO,CAAC;CACnF,MAAM,SAAS,kBAAkB,IAAI,SAAS;CAC9C,IAAI,WAAW,KAAA,GAAW,OAAO;CACjC,MAAM,YAAY,iBAAiB,SAAS;CAC5C,kBAAkB,IAAI,WAAW,SAAS;CAC1C,OAAO;AACT"}
+{"version":3,"file":"capabilities.js","names":[],"sources":["../../../../src/media/dom/capabilities.ts"],"sourcesContent":["/**\n * Capability probing — the engine's foundation for asking the browser what it can actually decode before committing a\n * rendition to the pipeline.\n *\n * Today this is the synchronous codec half: `canPlayTrack` answers \"can this environment play this track?\" by building\n * the track's MIME codec string and passing it to `MediaSource.isTypeSupported` (via `isCodecSupported`). It's the DOM\n * implementation of the DOM-free `CanPlayTrack` predicate the track-switching hard-constraint pre-pass consumes —\n * injected through engine config so the (DOM-free) behavior never imports a DOM API directly.\n *\n * Results are memoized by built MIME string: codec support is a pure function of (codec, environment) and never changes\n * after load, so probing is lazy (per candidate, at constraint-apply time) but each unique MIME is asked once.\n *\n * Future cluster-D phases (async `requestMediaKeySystemAccess` key-system probing, `SourceBuffer.changeType()`\n * availability) extend this surface; the async ones land as a state-slot writer behavior rather than a config\n * predicate, since their verdict resolves asynchronously.\n */\n\nimport { NON_FMP4_CONTAINER_MIMES } from '../hls/parse-media-playlist';\nimport { type CanPlayTrack, getMediaPlaylistMetadata } from '../types';\nimport { buildMimeCodec, isCodecSupported } from './mse/mediasource-setup';\n\nconst codecSupportCache = new Map<string, boolean>();\n\n/**\n * Whether the environment can decode `track`, by codec. Builds the track's MIME codec string and checks\n * `MediaSource.isTypeSupported`, memoized by MIME. A track without enough to probe — no `mimeType`, or no declared\n * `codecs` (CODECS is optional per the HLS spec) — is unprobeable and passes through as playable (`true`) rather than\n * being dropped; the late `createSourceBuffer` check stays as the backstop for those.\n *\n * Detected non-fMP4 containers (`video/mp2t`, `audio/aac`) are asserted unsupported regardless of the probe, so they're\n * pruned before selection (the type makes no pick) instead of failing/stalling deep in the pipeline. Two different\n * reasons, neither UA-based:\n *\n * - **MPEG-TS** can't be played at all here: `isTypeSupported('video/mp2t…')` is a genuine false positive on Chromium\n *   (reports `true` but appends produce no buffered range), and this engine has no TS transmux pipeline.\n * - **Raw ADTS AAC** is a _temporary_ limitation. The browser genuinely supports it (Chrome/Safari decode `audio/aac`;\n *   Firefox doesn't), so it could be made playable — but our segment actors / loading behaviors / append pipeline\n *   assume every rendition has an `EXT-X-MAP` init segment (e.g. an `append-init` task with an empty URL, fMP4-shaped\n *   append handling). Until that init-segment assumption is removed, ADTS would fetch but never buffer (a silent\n *   stall), so we assert it unplayable for now. FOLLOW-UP: drop the init-required assumption in the pipeline and switch\n *   this to a bare-MIME probe (`buildMimeCodec` would project `audio/aac` with no codecs) so it plays where the browser\n *   supports it.\n *\n * Override via the engine's `canPlayTrack` config when those pipelines land.\n */\nexport const canPlayTrack: CanPlayTrack = (track) => {\n  if (track.mimeType && NON_FMP4_CONTAINER_MIMES.has(track.mimeType)) return false;\n\n  // Encrypted renditions are unplayable *for now* — this engine has no EME /\n  // license pipeline, so appending them would fail to decode with nothing to\n  // explain it. Pruning them here means a partially-encrypted source still plays\n  // its clear renditions, and a fully-encrypted one empties the candidate set\n  // (which `track-switching` reports). Remove this when DRM support lands.\n  if (getMediaPlaylistMetadata(track)?.encrypted) return false;\n\n  if (!track.mimeType || !track.codecs?.length) return true;\n\n  const mimeCodec = buildMimeCodec({ mimeType: track.mimeType, codecs: track.codecs });\n  const cached = codecSupportCache.get(mimeCodec);\n  if (cached !== undefined) return cached;\n\n  const supported = isCodecSupported(mimeCodec);\n\n  codecSupportCache.set(mimeCodec, supported);\n  return supported;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBA,MAAM,oCAAoB,IAAI,IAAqB;;;;;;;;;;;;;;;;;;;;;;;AAwBnD,MAAa,gBAA8B,UAAU;CACnD,IAAI,MAAM,YAAY,yBAAyB,IAAI,MAAM,QAAQ,GAAG,OAAO;CAO3E,IAAI,yBAAyB,KAAK,CAAC,EAAE,WAAW,OAAO;CAEvD,IAAI,CAAC,MAAM,YAAY,CAAC,MAAM,QAAQ,QAAQ,OAAO;CAErD,MAAM,YAAY,eAAe;EAAE,UAAU,MAAM;EAAU,QAAQ,MAAM;CAAO,CAAC;CACnF,MAAM,SAAS,kBAAkB,IAAI,SAAS;CAC9C,IAAI,WAAW,KAAA,GAAW,OAAO;CAEjC,MAAM,YAAY,iBAAiB,SAAS;CAE5C,kBAAkB,IAAI,WAAW,SAAS;CAC1C,OAAO;AACT"}

package/dist/default/media/dom/mse/append-segment.js

@@ -2,12 +2,10 @@
 /**
 * Append media data to a SourceBuffer.
 *
-* Accepts either a full ArrayBuffer (single append) or an AsyncIterable of
-* Uint8Array chunks (one append per chunk, in order). Waits for `updateend`
-* between each call so appends are serialized correctly.
+* Accepts either a full ArrayBuffer (single append) or an AsyncIterable of Uint8Array chunks (one append per chunk, in
+* order). Waits for `updateend` between each call so appends are serialized correctly.
 *
-* Errors from the SourceBuffer (`error` event) or from the iterable are
-* propagated as rejections.
+* Errors from the SourceBuffer (`error` event) or from the iterable are propagated as rejections.
 */
 async function appendSegment(sourceBuffer, data, signal) {
 	if (data instanceof ArrayBuffer) await appendChunk(sourceBuffer, data);

package/dist/default/media/dom/mse/append-segment.js.map

@@ -1 +1 @@
-{"version":3,"file":"append-segment.js","names":[],"sources":["../../../../../src/media/dom/mse/append-segment.ts"],"sourcesContent":["/**\n * Segment appender helper.\n *\n * Appends media data (ArrayBuffer or AsyncIterable<Uint8Array> stream) to a\n * SourceBuffer, waiting for `updateend` between calls so the browser can\n * process each append before the next one arrives.\n */\n\nimport type { SegmentData } from '../../types';\n\n/** Data accepted by appendSegment — the MSE-boundary alias of {@link SegmentData}. */\nexport type AppendData = SegmentData;\n\n/**\n * Append media data to a SourceBuffer.\n *\n * Accepts either a full ArrayBuffer (single append) or an AsyncIterable of\n * Uint8Array chunks (one append per chunk, in order). Waits for `updateend`\n * between each call so appends are serialized correctly.\n *\n * Errors from the SourceBuffer (`error` event) or from the iterable are\n * propagated as rejections.\n */\nexport async function appendSegment(sourceBuffer: SourceBuffer, data: AppendData, signal?: AbortSignal): Promise<void> {\n  if (data instanceof ArrayBuffer) {\n    await appendChunk(sourceBuffer, data);\n  } else {\n    try {\n      for await (const chunk of data) {\n        // Check between chunks so an abort can stop streaming before the next\n        // appendBuffer call. The current chunk (if any) has already landed in the\n        // SourceBuffer; the partial: true flag in the actor model reflects this.\n        if (signal?.aborted) throw signal.reason ?? new DOMException('Aborted', 'AbortError');\n        await appendChunk(sourceBuffer, chunk);\n      }\n    } catch (e) {\n      // Reset the MSE segment parser on any abort to discard partial fMP4 box\n      // data from the SourceBuffer's internal byte buffer. Two paths reach here:\n      //\n      // 1. Explicit abort check above (signal.aborted between chunks) — the\n      //    last appended chunk may have left the parser mid-fragment.\n      //\n      // 2. The fetch was cancelled (signal fired), causing the underlying\n      //    ReadableStream to error and the for-await loop to throw directly\n      //    without ever passing through the signal check above. Same cleanup\n      //    is needed: partial box data must be cleared before the next append.\n      //\n      // Without this, the next appendBuffer call sees stale partial data and\n      // Chrome throws CHUNK_DEMUXER_ERROR_APPEND_FAILED.\n      if (e instanceof DOMException && e.name === 'AbortError' && !sourceBuffer.updating) {\n        try {\n          sourceBuffer.abort();\n        } catch {\n          // Thrown if the MediaSource is not \"open\" (e.g. during teardown).\n        }\n      }\n      throw e;\n    }\n  }\n}\n\nasync function appendChunk(sourceBuffer: SourceBuffer, data: ArrayBuffer | Uint8Array<ArrayBufferLike>): Promise<void> {\n  if (sourceBuffer.updating) {\n    await new Promise<void>((resolve) => {\n      const onUpdateEnd = () => {\n        sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n        resolve();\n      };\n      sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    });\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    const onUpdateEnd = () => {\n      cleanup();\n      resolve();\n    };\n\n    const onError = (event: Event) => {\n      cleanup();\n      reject(new Error(`SourceBuffer append error: ${event.type}`));\n    };\n\n    const cleanup = () => {\n      sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n      sourceBuffer.removeEventListener('error', onError);\n    };\n\n    sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    sourceBuffer.addEventListener('error', onError);\n\n    try {\n      sourceBuffer.appendBuffer(data as ArrayBuffer);\n    } catch (error) {\n      cleanup();\n      reject(error);\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;AAuBA,eAAsB,cAAc,cAA4B,MAAkB,QAAqC;CACrH,IAAI,gBAAgB,aAClB,MAAM,YAAY,cAAc,IAAI;MAEpC,IAAI;EACF,WAAW,MAAM,SAAS,MAAM;GAI9B,IAAI,QAAQ,SAAS,MAAM,OAAO,UAAU,IAAI,aAAa,WAAW,YAAY;GACpF,MAAM,YAAY,cAAc,KAAK;EACvC;CACF,SAAS,GAAG;EAcV,IAAI,aAAa,gBAAgB,EAAE,SAAS,gBAAgB,CAAC,aAAa,UACxE,IAAI;GACF,aAAa,MAAM;EACrB,QAAQ,CAER;EAEF,MAAM;CACR;AAEJ;AAEA,eAAe,YAAY,cAA4B,MAAgE;CACrH,IAAI,aAAa,UACf,MAAM,IAAI,SAAe,YAAY;EACnC,MAAM,oBAAoB;GACxB,aAAa,oBAAoB,aAAa,WAAW;GACzD,QAAQ;EACV;EACA,aAAa,iBAAiB,aAAa,WAAW;CACxD,CAAC;CAGH,OAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,MAAM,oBAAoB;GACxB,QAAQ;GACR,QAAQ;EACV;EAEA,MAAM,WAAW,UAAiB;GAChC,QAAQ;GACR,uBAAO,IAAI,MAAM,8BAA8B,MAAM,MAAM,CAAC;EAC9D;EAEA,MAAM,gBAAgB;GACpB,aAAa,oBAAoB,aAAa,WAAW;GACzD,aAAa,oBAAoB,SAAS,OAAO;EACnD;EAEA,aAAa,iBAAiB,aAAa,WAAW;EACtD,aAAa,iBAAiB,SAAS,OAAO;EAE9C,IAAI;GACF,aAAa,aAAa,IAAmB;EAC/C,SAAS,OAAO;GACd,QAAQ;GACR,OAAO,KAAK;EACd;CACF,CAAC;AACH"}
+{"version":3,"file":"append-segment.js","names":[],"sources":["../../../../../src/media/dom/mse/append-segment.ts"],"sourcesContent":["/**\n * Segment appender helper.\n *\n * Appends media data (ArrayBuffer or AsyncIterable<Uint8Array> stream) to a SourceBuffer, waiting for `updateend`\n * between calls so the browser can process each append before the next one arrives.\n */\n\nimport type { SegmentData } from '../../types';\n\n/** Data accepted by appendSegment — the MSE-boundary alias of {@link SegmentData}. */\nexport type AppendData = SegmentData;\n\n/**\n * Append media data to a SourceBuffer.\n *\n * Accepts either a full ArrayBuffer (single append) or an AsyncIterable of Uint8Array chunks (one append per chunk, in\n * order). Waits for `updateend` between each call so appends are serialized correctly.\n *\n * Errors from the SourceBuffer (`error` event) or from the iterable are propagated as rejections.\n */\nexport async function appendSegment(sourceBuffer: SourceBuffer, data: AppendData, signal?: AbortSignal): Promise<void> {\n  if (data instanceof ArrayBuffer) {\n    await appendChunk(sourceBuffer, data);\n  } else {\n    try {\n      for await (const chunk of data) {\n        // Check between chunks so an abort can stop streaming before the next\n        // appendBuffer call. The current chunk (if any) has already landed in the\n        // SourceBuffer; the partial: true flag in the actor model reflects this.\n        if (signal?.aborted) throw signal.reason ?? new DOMException('Aborted', 'AbortError');\n\n        await appendChunk(sourceBuffer, chunk);\n      }\n    } catch (e) {\n      // Reset the MSE segment parser on any abort to discard partial fMP4 box\n      // data from the SourceBuffer's internal byte buffer. Two paths reach here:\n      //\n      // 1. Explicit abort check above (signal.aborted between chunks) — the\n      //    last appended chunk may have left the parser mid-fragment.\n      //\n      // 2. The fetch was cancelled (signal fired), causing the underlying\n      //    ReadableStream to error and the for-await loop to throw directly\n      //    without ever passing through the signal check above. Same cleanup\n      //    is needed: partial box data must be cleared before the next append.\n      //\n      // Without this, the next appendBuffer call sees stale partial data and\n      // Chrome throws CHUNK_DEMUXER_ERROR_APPEND_FAILED.\n      if (e instanceof DOMException && e.name === 'AbortError' && !sourceBuffer.updating) {\n        try {\n          sourceBuffer.abort();\n        } catch {\n          // Thrown if the MediaSource is not \"open\" (e.g. during teardown).\n        }\n      }\n\n      throw e;\n    }\n  }\n}\n\nasync function appendChunk(sourceBuffer: SourceBuffer, data: ArrayBuffer | Uint8Array<ArrayBufferLike>): Promise<void> {\n  if (sourceBuffer.updating) {\n    await new Promise<void>((resolve) => {\n      const onUpdateEnd = () => {\n        sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n        resolve();\n      };\n\n      sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    });\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    const onUpdateEnd = () => {\n      cleanup();\n      resolve();\n    };\n\n    const onError = (event: Event) => {\n      cleanup();\n      reject(new Error(`SourceBuffer append error: ${event.type}`));\n    };\n\n    const cleanup = () => {\n      sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n      sourceBuffer.removeEventListener('error', onError);\n    };\n\n    sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    sourceBuffer.addEventListener('error', onError);\n\n    try {\n      sourceBuffer.appendBuffer(data as ArrayBuffer);\n    } catch (error) {\n      cleanup();\n      reject(error);\n    }\n  });\n}\n"],"mappings":";;;;;;;;;AAoBA,eAAsB,cAAc,cAA4B,MAAkB,QAAqC;CACrH,IAAI,gBAAgB,aAClB,MAAM,YAAY,cAAc,IAAI;MAEpC,IAAI;EACF,WAAW,MAAM,SAAS,MAAM;GAI9B,IAAI,QAAQ,SAAS,MAAM,OAAO,UAAU,IAAI,aAAa,WAAW,YAAY;GAEpF,MAAM,YAAY,cAAc,KAAK;EACvC;CACF,SAAS,GAAG;EAcV,IAAI,aAAa,gBAAgB,EAAE,SAAS,gBAAgB,CAAC,aAAa,UACxE,IAAI;GACF,aAAa,MAAM;EACrB,QAAQ,CAER;EAGF,MAAM;CACR;AAEJ;AAEA,eAAe,YAAY,cAA4B,MAAgE;CACrH,IAAI,aAAa,UACf,MAAM,IAAI,SAAe,YAAY;EACnC,MAAM,oBAAoB;GACxB,aAAa,oBAAoB,aAAa,WAAW;GACzD,QAAQ;EACV;EAEA,aAAa,iBAAiB,aAAa,WAAW;CACxD,CAAC;CAGH,OAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,MAAM,oBAAoB;GACxB,QAAQ;GACR,QAAQ;EACV;EAEA,MAAM,WAAW,UAAiB;GAChC,QAAQ;GACR,uBAAO,IAAI,MAAM,8BAA8B,MAAM,MAAM,CAAC;EAC9D;EAEA,MAAM,gBAAgB;GACpB,aAAa,oBAAoB,aAAa,WAAW;GACzD,aAAa,oBAAoB,SAAS,OAAO;EACnD;EAEA,aAAa,iBAAiB,aAAa,WAAW;EACtD,aAAa,iBAAiB,SAAS,OAAO;EAE9C,IAAI;GACF,aAAa,aAAa,IAAmB;EAC/C,SAAS,OAAO;GACd,QAAQ;GACR,OAAO,KAAK;EACd;CACF,CAAC;AACH"}

package/dist/default/media/dom/mse/buffer-flusher.js

@@ -7,16 +7,16 @@
 /**
 * Remove a time range from a SourceBuffer.
 *
-* Waits for the SourceBuffer to be ready (not updating), then removes
-* the specified range. Returns a promise that resolves when removal completes.
+* Waits for the SourceBuffer to be ready (not updating), then removes the specified range. Returns a promise that
+* resolves when removal completes.
+*
+* @example
+*   await flushBuffer(videoSourceBuffer, 0, 30);
 *
 * @param sourceBuffer - The SourceBuffer to remove data from
 * @param start - Start of the time range to remove (seconds)
 * @param end - End of the time range to remove (seconds)
 * @returns Promise that resolves when removal completes
-*
-* @example
-* await flushBuffer(videoSourceBuffer, 0, 30);
 */
 async function flushBuffer(sourceBuffer, start, end) {
 	if (sourceBuffer.updating) await new Promise((resolve) => {

package/dist/default/media/dom/mse/buffer-flusher.js.map

@@ -1 +1 @@
-{"version":3,"file":"buffer-flusher.js","names":[],"sources":["../../../../../src/media/dom/mse/buffer-flusher.ts"],"sourcesContent":["/**\n * Buffer flusher helper (P12)\n *\n * Removes a time range from a SourceBuffer to manage memory.\n */\n\n/**\n * Remove a time range from a SourceBuffer.\n *\n * Waits for the SourceBuffer to be ready (not updating), then removes\n * the specified range. Returns a promise that resolves when removal completes.\n *\n * @param sourceBuffer - The SourceBuffer to remove data from\n * @param start - Start of the time range to remove (seconds)\n * @param end - End of the time range to remove (seconds)\n * @returns Promise that resolves when removal completes\n *\n * @example\n * await flushBuffer(videoSourceBuffer, 0, 30);\n */\nexport async function flushBuffer(sourceBuffer: SourceBuffer, start: number, end: number): Promise<void> {\n  // Wait for SourceBuffer to be ready (not currently updating)\n  if (sourceBuffer.updating) {\n    await new Promise<void>((resolve) => {\n      const onUpdateEnd = () => {\n        sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n        resolve();\n      };\n      sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    });\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    const onUpdateEnd = () => {\n      cleanup();\n      resolve();\n    };\n\n    const onError = (event: Event) => {\n      cleanup();\n      reject(new Error(`SourceBuffer remove error: ${event.type}`));\n    };\n\n    const cleanup = () => {\n      sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n      sourceBuffer.removeEventListener('error', onError);\n    };\n\n    sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    sourceBuffer.addEventListener('error', onError);\n\n    try {\n      sourceBuffer.remove(start, end);\n    } catch (error) {\n      cleanup();\n      reject(error);\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,eAAsB,YAAY,cAA4B,OAAe,KAA4B;CAEvG,IAAI,aAAa,UACf,MAAM,IAAI,SAAe,YAAY;EACnC,MAAM,oBAAoB;GACxB,aAAa,oBAAoB,aAAa,WAAW;GACzD,QAAQ;EACV;EACA,aAAa,iBAAiB,aAAa,WAAW;CACxD,CAAC;CAGH,OAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,MAAM,oBAAoB;GACxB,QAAQ;GACR,QAAQ;EACV;EAEA,MAAM,WAAW,UAAiB;GAChC,QAAQ;GACR,uBAAO,IAAI,MAAM,8BAA8B,MAAM,MAAM,CAAC;EAC9D;EAEA,MAAM,gBAAgB;GACpB,aAAa,oBAAoB,aAAa,WAAW;GACzD,aAAa,oBAAoB,SAAS,OAAO;EACnD;EAEA,aAAa,iBAAiB,aAAa,WAAW;EACtD,aAAa,iBAAiB,SAAS,OAAO;EAE9C,IAAI;GACF,aAAa,OAAO,OAAO,GAAG;EAChC,SAAS,OAAO;GACd,QAAQ;GACR,OAAO,KAAK;EACd;CACF,CAAC;AACH"}
+{"version":3,"file":"buffer-flusher.js","names":[],"sources":["../../../../../src/media/dom/mse/buffer-flusher.ts"],"sourcesContent":["/**\n * Buffer flusher helper (P12)\n *\n * Removes a time range from a SourceBuffer to manage memory.\n */\n\n/**\n * Remove a time range from a SourceBuffer.\n *\n * Waits for the SourceBuffer to be ready (not updating), then removes the specified range. Returns a promise that\n * resolves when removal completes.\n *\n * @example\n *   await flushBuffer(videoSourceBuffer, 0, 30);\n *\n * @param sourceBuffer - The SourceBuffer to remove data from\n * @param start - Start of the time range to remove (seconds)\n * @param end - End of the time range to remove (seconds)\n * @returns Promise that resolves when removal completes\n */\nexport async function flushBuffer(sourceBuffer: SourceBuffer, start: number, end: number): Promise<void> {\n  // Wait for SourceBuffer to be ready (not currently updating)\n  if (sourceBuffer.updating) {\n    await new Promise<void>((resolve) => {\n      const onUpdateEnd = () => {\n        sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n        resolve();\n      };\n\n      sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    });\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    const onUpdateEnd = () => {\n      cleanup();\n      resolve();\n    };\n\n    const onError = (event: Event) => {\n      cleanup();\n      reject(new Error(`SourceBuffer remove error: ${event.type}`));\n    };\n\n    const cleanup = () => {\n      sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n      sourceBuffer.removeEventListener('error', onError);\n    };\n\n    sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    sourceBuffer.addEventListener('error', onError);\n\n    try {\n      sourceBuffer.remove(start, end);\n    } catch (error) {\n      cleanup();\n      reject(error);\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,eAAsB,YAAY,cAA4B,OAAe,KAA4B;CAEvG,IAAI,aAAa,UACf,MAAM,IAAI,SAAe,YAAY;EACnC,MAAM,oBAAoB;GACxB,aAAa,oBAAoB,aAAa,WAAW;GACzD,QAAQ;EACV;EAEA,aAAa,iBAAiB,aAAa,WAAW;CACxD,CAAC;CAGH,OAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,MAAM,oBAAoB;GACxB,QAAQ;GACR,QAAQ;EACV;EAEA,MAAM,WAAW,UAAiB;GAChC,QAAQ;GACR,uBAAO,IAAI,MAAM,8BAA8B,MAAM,MAAM,CAAC;EAC9D;EAEA,MAAM,gBAAgB;GACpB,aAAa,oBAAoB,aAAa,WAAW;GACzD,aAAa,oBAAoB,SAAS,OAAO;EACnD;EAEA,aAAa,iBAAiB,aAAa,WAAW;EACtD,aAAa,iBAAiB,SAAS,OAAO;EAE9C,IAAI;GACF,aAAa,OAAO,OAAO,GAAG;EAChC,SAAS,OAAO;GACd,QAAQ;GACR,OAAO,KAAK;EACd;CACF,CAAC;AACH"}

package/dist/default/media/dom/mse/duration.js

@@ -1,8 +1,8 @@
 import { hasPresentationDuration } from "../../types/index.js";
 //#region src/media/dom/mse/duration.ts
 /**
-* Check if we have the basics to update MediaSource duration:
-* a `mediaSource` and a `presentation` with a numeric duration.
+* Check if we have the basics to update MediaSource duration: a `mediaSource` and a `presentation` with a numeric
+* duration.
 */
 function canUpdateDuration(presentation, mediaSource) {
 	return !!(mediaSource && presentation && hasPresentationDuration(presentation));
@@ -19,42 +19,35 @@ function getBufferedEnd(buffers, isEndMatch) {
 const isGreaterThan = (x, y) => x > y;
 const isLessThan = (x, y) => x < y;
 /**
-* Get the maximum buffered end time across an iterable of SourceBuffers
-* (typically `mediaSource.sourceBuffers`). Returns `0` when the collection is
-* empty or no buffer has any buffered ranges.
+* Get the maximum buffered end time across an iterable of SourceBuffers (typically `mediaSource.sourceBuffers`).
+* Returns `0` when the collection is empty or no buffer has any buffered ranges.
 */
 function getMaxBufferedEnd(buffers) {
 	return getBufferedEnd(buffers, isGreaterThan);
 }
 /**
-* Get the reachable buffered end across an iterable of SourceBuffers (typically
-* `mediaSource.sourceBuffers`): the `min` of each buffer's last buffered-range end
-* — the furthest point every track can play to (the intersection end). Buffers with
-* no buffered ranges are skipped. Returns `0` when the collection is empty or no
-* buffer has any buffered ranges.
+* Get the reachable buffered end across an iterable of SourceBuffers (typically `mediaSource.sourceBuffers`): the `min`
+* of each buffer's last buffered-range end — the furthest point every track can play to (the intersection end). Buffers
+* with no buffered ranges are skipped. Returns `0` when the collection is empty or no buffer has any buffered ranges.
 *
-* Counterpart to {@link getMaxBufferedEnd}: `max` bounds the overall presentation
-* end (e.g. for setting `duration`), `min` bounds where playback can actually reach
-* when tracks end at slightly different times (e.g. skewed A/V near end-of-stream).
+* Counterpart to {@link getMaxBufferedEnd}: `max` bounds the overall presentation end (e.g. for setting `duration`),
+* `min` bounds where playback can actually reach when tracks end at slightly different times (e.g. skewed A/V near
+* end-of-stream).
 */
 function getMinBufferedEnd(buffers) {
 	return getBufferedEnd(buffers, isLessThan);
 }
 /**
-* Check if the preconditions are met to *attempt* a `mediaSource.duration`
-* write: a `mediaSource` is in scope and the presentation has a valid
-* positive duration (or `Infinity` for live).
+* Check if the preconditions are met to _attempt_ a `mediaSource.duration` write: a `mediaSource` is in scope and the
+* presentation has a valid positive duration (or `Infinity` for live).
 *
-* Does **not** check `mediaSource.readyState` or `mediaSource.duration` —
-* those are DOM properties the caller resolves at write time (e.g., by
-* `await`ing `waitForMediaSourceOpen` and re-checking `readyState` after,
-* and guarding on the existing `mediaSource.duration` for idempotency).
-* Keeping these off the signal-driven predicate lets callers use this
-* inside reactor state derivation without smuggling non-reactive DOM
-* reads into `computed(...)`.
+* Does **not** check `mediaSource.readyState` or `mediaSource.duration` — those are DOM properties the caller resolves
+* at write time (e.g., by `await`ing `waitForMediaSourceOpen` and re-checking `readyState` after, and guarding on the
+* existing `mediaSource.duration` for idempotency). Keeping these off the signal-driven predicate lets callers use this
+* inside reactor state derivation without smuggling non-reactive DOM reads into `computed(...)`.
 *
-* `Infinity` is allowed — per the MSE spec, `mediaSource.duration = +Infinity`
-* is how live playback signals an indefinite duration.
+* `Infinity` is allowed — per the MSE spec, `mediaSource.duration = +Infinity` is how live playback signals an
+* indefinite duration.
 */
 function shouldUpdateDuration(presentation, mediaSource) {
 	if (!canUpdateDuration(presentation, mediaSource)) return false;
@@ -63,13 +56,12 @@ function shouldUpdateDuration(presentation, mediaSource) {
 	return true;
 }
 /**
-* Wait for all currently-updating SourceBuffers in `buffers` to finish, or
-* until `signal` aborts — whichever fires first.
+* Wait for all currently-updating SourceBuffers in `buffers` to finish, or until `signal` aborts — whichever fires
+* first.
 *
-* The MSE spec forbids setting `MediaSource.duration` while any attached
-* SourceBuffer has `updating === true`. This defers until all are idle.
-* Listeners are registered with `{ signal }` so an abort tears them down
-* up-front rather than leaving them dangling until the next `updateend`.
+* The MSE spec forbids setting `MediaSource.duration` while any attached SourceBuffer has `updating === true`. This
+* defers until all are idle. Listeners are registered with `{ signal }` so an abort tears them down up-front rather
+* than leaving them dangling until the next `updateend`.
 */
 function waitForSourceBuffersReady(buffers, signal) {
 	if (signal.aborted) return Promise.resolve();