@videojs/spf 10.0.0-beta.24 → 10.0.0-beta.26

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,GACf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BD,SAAgB,8BACd,UACA,aACA,SAA2B,4BACnB;AACR,KAAI,SAAS,WAAW,EACtB,QAAO;CAIT,MAAM,iBAAiB,SAAS,QAAQ,QAAQ,IAAI,YAAY,YAAY;AAG5E,KAAI,eAAe,WAAW,EAC5B,QAAO;CAKT,MAAM,kBAAkB,eAAe,SAAS,OAAO;AAGvD,KAAI,mBAAmB,EACrB,QAAO;AAKT,KAAI,mBAAmB,eAAe,OACpC,QAAO;AAKT,QAAO,eAAe,iBAAkB"}
+{"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"}

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

@@ -1,5 +1,38 @@
+import { SEGMENT_TIME_EPSILON } from "../types/index.js";
 //#region src/media/buffer/forward-buffer.ts
 /**
+* Forward Buffer Strategy (Simple)
+*
+* 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.
+*/
+function mergeTimeRanges(ranges, epsilon = SEGMENT_TIME_EPSILON) {
+	const sorted = ranges.filter((r) => r.end > r.start).sort((a, b) => a.start - b.start);
+	const merged = [];
+	for (const r of sorted) {
+		const last = merged[merged.length - 1];
+		if (last && r.start <= last.end + epsilon) last.end = Math.max(last.end, r.end);
+		else merged.push({
+			start: r.start,
+			end: r.end
+		});
+	}
+	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.
+*/
+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.
 */
 const DEFAULT_FORWARD_BUFFER_CONFIG = { bufferDuration: 30 };
@@ -72,14 +105,15 @@ function getSegmentsToLoad(segments, bufferedSegments, currentTime, config = DEF
 	if (segments.length === 0) return [];
 	const targetTime = currentTime + config.bufferDuration;
 	const bufferedStartTimes = new Set(bufferedSegments.map((seg) => seg.startTime));
-	return segments.filter((seg) => {
+	return segments.filter((seg, i) => {
 		const segmentEnd = seg.startTime + seg.duration;
-		const isInRange = seg.startTime < targetTime && segmentEnd > currentTime;
+		const overlapsPlayhead = i === segments.length - 1 || segmentEnd > currentTime;
+		const isInRange = seg.startTime < targetTime && overlapsPlayhead;
 		const isNotBuffered = !bufferedStartTimes.has(seg.startTime);
 		return isInRange && isNotBuffered;
 	});
 }
 //#endregion
-export { DEFAULT_FORWARD_BUFFER_CONFIG, calculateForwardFlushPoint, getSegmentsToLoad, segmentStartForTime };
+export { DEFAULT_FORWARD_BUFFER_CONFIG, calculateForwardFlushPoint, getSegmentsToLoad, isTimeRangeCovered, mergeTimeRanges, segmentStartForTime };
 
 //# sourceMappingURL=forward-buffer.js.map

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 type { Segment } from '../types';\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) => {\n    // Segment must overlap the buffer window\n    const segmentEnd = seg.startTime + seg.duration;\n    const isInRange = seg.startTime < targetTime && segmentEnd > currentTime;\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":";;;;AAuBA,MAAa,gCAAqD,EAChE,gBAAgB,IACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDD,SAAgB,2BACd,kBACA,aACA,SAA8B,+BACtB;AACR,KAAI,iBAAiB,WAAW,EAAG,QAAO;CAE1C,MAAM,YAAY,cAAc,OAAO;CAGvC,MAAM,SAAS,iBAAiB,QAAQ,QAAQ,IAAI,aAAa,UAAU;AAE3E,KAAI,OAAO,WAAW,EAAG,QAAO;AAGhC,QAAO,KAAK,IAAI,GAAG,OAAO,KAAK,QAAQ,IAAI,UAAU,CAAC;;;;;;;;;;AAWxD,SAAgB,oBACd,aACA,UACoB;AACpB,KAAI,eAAe,KAAM,QAAO,KAAA;AAChC,QAAO,UAAU,MACd,EAAE,WAAW,YAAY,GAAG,QAC3B,eAAe,cAAc,cAAc,YAAY,YAAY,MAAM,IAAI,SAAS,GACzF,EAAE;;AAGL,SAAgB,kBACd,UACA,kBACA,aACA,SAA8B,+BACnB;AACX,KAAI,SAAS,WAAW,EACtB,QAAO,EAAE;CAIX,MAAM,aAAa,cAAc,OAAO;CAKxC,MAAM,qBAAqB,IAAI,IAAI,iBAAiB,KAAK,QAAQ,IAAI,UAAU,CAAC;AAgBhF,QAXe,SAAS,QAAQ,QAAQ;EAEtC,MAAM,aAAa,IAAI,YAAY,IAAI;EACvC,MAAM,YAAY,IAAI,YAAY,cAAc,aAAa;EAG7D,MAAM,gBAAgB,CAAC,mBAAmB,IAAI,IAAI,UAAU;AAE5D,SAAO,aAAa;GACpB"}
+{"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"}

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

@@ -0,0 +1,70 @@
+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.
+*
+* 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.
+*
+* 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.
+*
+* 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.
+*
+* Override via the engine's `canPlayTrack` config when those pipelines land.
+*/
+const canPlayTrack = (track) => {
+	if (track.mimeType && NON_FMP4_CONTAINER_MIMES.has(track.mimeType)) return false;
+	if (!track.mimeType || !track.codecs?.length) return true;
+	const mimeCodec = buildMimeCodec({
+		mimeType: track.mimeType,
+		codecs: track.codecs
+	});
+	const cached = codecSupportCache.get(mimeCodec);
+	if (cached !== void 0) return cached;
+	const supported = isCodecSupported(mimeCodec);
+	codecSupportCache.set(mimeCodec, supported);
+	return supported;
+};
+//#endregion
+export { canPlayTrack };
+
+//# sourceMappingURL=capabilities.js.map

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

@@ -0,0 +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 } 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  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;CAC3E,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"}

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\n/** Data accepted by appendSegment — a full buffer or an async chunk stream. */\nexport type AppendData = ArrayBuffer | AsyncIterable<Uint8Array>;\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":";;;;;;;;;;;AAqBA,eAAsB,cAAc,cAA4B,MAAkB,QAAqC;AACrH,KAAI,gBAAgB,YAClB,OAAM,YAAY,cAAc,KAAK;KAErC,KAAI;AACF,aAAW,MAAM,SAAS,MAAM;AAI9B,OAAI,QAAQ,QAAS,OAAM,OAAO,UAAU,IAAI,aAAa,WAAW,aAAa;AACrF,SAAM,YAAY,cAAc,MAAM;;UAEjC,GAAG;AAcV,MAAI,aAAa,gBAAgB,EAAE,SAAS,gBAAgB,CAAC,aAAa,SACxE,KAAI;AACF,gBAAa,OAAO;UACd;AAIV,QAAM;;;AAKZ,eAAe,YAAY,cAA4B,MAAgE;AACrH,KAAI,aAAa,SACf,OAAM,IAAI,SAAe,YAAY;EACnC,MAAM,oBAAoB;AACxB,gBAAa,oBAAoB,aAAa,YAAY;AAC1D,YAAS;;AAEX,eAAa,iBAAiB,aAAa,YAAY;GACvD;AAGJ,QAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,MAAM,oBAAoB;AACxB,YAAS;AACT,YAAS;;EAGX,MAAM,WAAW,UAAiB;AAChC,YAAS;AACT,0BAAO,IAAI,MAAM,8BAA8B,MAAM,OAAO,CAAC;;EAG/D,MAAM,gBAAgB;AACpB,gBAAa,oBAAoB,aAAa,YAAY;AAC1D,gBAAa,oBAAoB,SAAS,QAAQ;;AAGpD,eAAa,iBAAiB,aAAa,YAAY;AACvD,eAAa,iBAAiB,SAAS,QAAQ;AAE/C,MAAI;AACF,gBAAa,aAAa,KAAoB;WACvC,OAAO;AACd,YAAS;AACT,UAAO,MAAM;;GAEf"}
+{"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"}

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;AAEvG,KAAI,aAAa,SACf,OAAM,IAAI,SAAe,YAAY;EACnC,MAAM,oBAAoB;AACxB,gBAAa,oBAAoB,aAAa,YAAY;AAC1D,YAAS;;AAEX,eAAa,iBAAiB,aAAa,YAAY;GACvD;AAGJ,QAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,MAAM,oBAAoB;AACxB,YAAS;AACT,YAAS;;EAGX,MAAM,WAAW,UAAiB;AAChC,YAAS;AACT,0BAAO,IAAI,MAAM,8BAA8B,MAAM,OAAO,CAAC;;EAG/D,MAAM,gBAAgB;AACpB,gBAAa,oBAAoB,aAAa,YAAY;AAC1D,gBAAa,oBAAoB,SAAS,QAAQ;;AAGpD,eAAa,iBAAiB,aAAa,YAAY;AACvD,eAAa,iBAAiB,SAAS,QAAQ;AAE/C,MAAI;AACF,gBAAa,OAAO,OAAO,IAAI;WACxB,OAAO;AACd,YAAS;AACT,UAAO,MAAM;;GAEf"}
+{"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"}

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

@@ -7,21 +7,38 @@ import { hasPresentationDuration } from "../../types/index.js";
 function canUpdateDuration(presentation, mediaSource) {
 	return !!(mediaSource && presentation && hasPresentationDuration(presentation));
 }
+function getBufferedEnd(buffers, isEndMatch) {
+	return [...buffers].reduce((endMatch, buffer) => {
+		const { buffered } = buffer;
+		if (!buffered.length) return endMatch;
+		const end = buffered.end(buffered.length - 1);
+		if (!endMatch) return end;
+		return isEndMatch(end, endMatch) ? end : endMatch;
+	}, void 0) ?? 0;
+}
+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.
 */
 function getMaxBufferedEnd(buffers) {
-	let maxEnd = 0;
-	for (const buffer of buffers) {
-		const { buffered } = buffer;
-		if (buffered.length > 0) {
-			const end = buffered.end(buffered.length - 1);
-			if (end > maxEnd) maxEnd = end;
-		}
-	}
-	return maxEnd;
+	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.
+*
+* 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`
@@ -73,6 +90,6 @@ function waitForSourceBuffersReady(buffers, signal) {
 	});
 }
 //#endregion
-export { getMaxBufferedEnd, shouldUpdateDuration, waitForSourceBuffersReady };
+export { canUpdateDuration, getBufferedEnd, getMaxBufferedEnd, getMinBufferedEnd, shouldUpdateDuration, waitForSourceBuffersReady };
 
 //# sourceMappingURL=duration.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"duration.js","names":[],"sources":["../../../../../src/media/dom/mse/duration.ts"],"sourcesContent":["/**\n * MediaSource duration helpers.\n *\n * Predicates and async primitives for propagating a presentation's duration\n * to `mediaSource.duration` under the MSE spec's constraints:\n *\n * - `duration` cannot be set while any attached SourceBuffer is `updating`.\n * - `duration` cannot be less than any buffered range's end time.\n *\n * The buffer-set helpers take a `SourceBufferList` (or any iterable of\n * `SourceBuffer`) — they operate uniformly across whatever buffers are\n * attached, so callers in audio-only, video-only, and mixed configurations\n * compose them without per-type plumbing. `mediaSource.sourceBuffers` is the\n * canonical aggregate.\n *\n * Consumed by `updateMediaSourceDuration` (DOM behavior) — kept here so the layering\n * stays clean: the predicates and wait helper are pure DOM/MSE primitives\n * with no `core/` reactivity.\n */\n\nimport type { MaybeResolvedPresentation } from '../../types';\nimport { hasPresentationDuration } from '../../types';\n\ntype SourceBufferIterable = SourceBufferList | Iterable<SourceBuffer>;\n\n/**\n * Check if we have the basics to update MediaSource duration:\n * a `mediaSource` and a `presentation` with a numeric duration.\n */\nexport function canUpdateDuration(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined\n): boolean {\n  return !!(mediaSource && presentation && hasPresentationDuration(presentation));\n}\n\n/**\n * Get the maximum buffered end time across an iterable of SourceBuffers\n * (typically `mediaSource.sourceBuffers`). Returns `0` when the collection is\n * empty or no buffer has any buffered ranges.\n */\nexport function getMaxBufferedEnd(buffers: SourceBufferIterable): number {\n  let maxEnd = 0;\n\n  for (const buffer of buffers) {\n    const { buffered } = buffer;\n    if (buffered.length > 0) {\n      const end = buffered.end(buffered.length - 1);\n      if (end > maxEnd) {\n        maxEnd = end;\n      }\n    }\n  }\n\n  return maxEnd;\n}\n\n/**\n * Check if the preconditions are met to *attempt* a `mediaSource.duration`\n * write: a `mediaSource` is in scope and the presentation has a valid\n * positive duration (or `Infinity` for live).\n *\n * Does **not** check `mediaSource.readyState` or `mediaSource.duration` —\n * those are DOM properties the caller resolves at write time (e.g., by\n * `await`ing `waitForMediaSourceOpen` and re-checking `readyState` after,\n * and guarding on the existing `mediaSource.duration` for idempotency).\n * Keeping these off the signal-driven predicate lets callers use this\n * inside reactor state derivation without smuggling non-reactive DOM\n * reads into `computed(...)`.\n *\n * `Infinity` is allowed — per the MSE spec, `mediaSource.duration = +Infinity`\n * is how live playback signals an indefinite duration.\n */\nexport function shouldUpdateDuration(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined\n): boolean {\n  if (!canUpdateDuration(presentation, mediaSource)) return false;\n\n  const duration = presentation!.duration!;\n\n  if (Number.isNaN(duration) || duration <= 0) return false;\n\n  return true;\n}\n\n/**\n * Wait for all currently-updating SourceBuffers in `buffers` to finish, or\n * until `signal` aborts — whichever fires first.\n *\n * The MSE spec forbids setting `MediaSource.duration` while any attached\n * SourceBuffer has `updating === true`. This defers until all are idle.\n * Listeners are registered with `{ signal }` so an abort tears them down\n * up-front rather than leaving them dangling until the next `updateend`.\n */\nexport function waitForSourceBuffersReady(buffers: SourceBufferIterable, signal: AbortSignal): Promise<void> {\n  if (signal.aborted) return Promise.resolve();\n\n  const updating: SourceBuffer[] = [];\n  for (const buf of buffers) {\n    if (buf.updating) updating.push(buf);\n  }\n\n  if (updating.length === 0) return Promise.resolve();\n\n  return new Promise<void>((resolve) => {\n    let remaining = updating.length;\n    const onUpdateEnd = () => {\n      remaining--;\n      if (remaining === 0) resolve();\n    };\n\n    for (const buf of updating) {\n      buf.addEventListener('updateend', onUpdateEnd, { once: true, signal });\n    }\n\n    signal.addEventListener('abort', () => resolve(), { once: true });\n  });\n}\n"],"mappings":";;;;;;AA6BA,SAAgB,kBACd,cACA,aACS;AACT,QAAO,CAAC,EAAE,eAAe,gBAAgB,wBAAwB,aAAa;;;;;;;AAQhF,SAAgB,kBAAkB,SAAuC;CACvE,IAAI,SAAS;AAEb,MAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,EAAE,aAAa;AACrB,MAAI,SAAS,SAAS,GAAG;GACvB,MAAM,MAAM,SAAS,IAAI,SAAS,SAAS,EAAE;AAC7C,OAAI,MAAM,OACR,UAAS;;;AAKf,QAAO;;;;;;;;;;;;;;;;;;AAmBT,SAAgB,qBACd,cACA,aACS;AACT,KAAI,CAAC,kBAAkB,cAAc,YAAY,CAAE,QAAO;CAE1D,MAAM,WAAW,aAAc;AAE/B,KAAI,OAAO,MAAM,SAAS,IAAI,YAAY,EAAG,QAAO;AAEpD,QAAO;;;;;;;;;;;AAYT,SAAgB,0BAA0B,SAA+B,QAAoC;AAC3G,KAAI,OAAO,QAAS,QAAO,QAAQ,SAAS;CAE5C,MAAM,WAA2B,EAAE;AACnC,MAAK,MAAM,OAAO,QAChB,KAAI,IAAI,SAAU,UAAS,KAAK,IAAI;AAGtC,KAAI,SAAS,WAAW,EAAG,QAAO,QAAQ,SAAS;AAEnD,QAAO,IAAI,SAAe,YAAY;EACpC,IAAI,YAAY,SAAS;EACzB,MAAM,oBAAoB;AACxB;AACA,OAAI,cAAc,EAAG,UAAS;;AAGhC,OAAK,MAAM,OAAO,SAChB,KAAI,iBAAiB,aAAa,aAAa;GAAE,MAAM;GAAM;GAAQ,CAAC;AAGxE,SAAO,iBAAiB,eAAe,SAAS,EAAE,EAAE,MAAM,MAAM,CAAC;GACjE"}
+{"version":3,"file":"duration.js","names":[],"sources":["../../../../../src/media/dom/mse/duration.ts"],"sourcesContent":["/**\n * MediaSource duration helpers.\n *\n * Predicates and async primitives for propagating a presentation's duration\n * to `mediaSource.duration` under the MSE spec's constraints:\n *\n * - `duration` cannot be set while any attached SourceBuffer is `updating`.\n * - `duration` cannot be less than any buffered range's end time.\n *\n * The buffer-set helpers take a `SourceBufferList` (or any iterable of\n * `SourceBuffer`) — they operate uniformly across whatever buffers are\n * attached, so callers in audio-only, video-only, and mixed configurations\n * compose them without per-type plumbing. `mediaSource.sourceBuffers` is the\n * canonical aggregate.\n *\n * Consumed by `updateMediaSourceDuration` (DOM behavior) — kept here so the layering\n * stays clean: the predicates and wait helper are pure DOM/MSE primitives\n * with no `core/` reactivity.\n */\n\nimport type { MaybeResolvedPresentation } from '../../types';\nimport { hasPresentationDuration } from '../../types';\n\ntype SourceBufferIterable = SourceBufferList | Iterable<SourceBuffer>;\n\n/**\n * Check if we have the basics to update MediaSource duration:\n * a `mediaSource` and a `presentation` with a numeric duration.\n */\nexport function canUpdateDuration(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined\n): boolean {\n  return !!(mediaSource && presentation && hasPresentationDuration(presentation));\n}\n\nexport function getBufferedEnd(\n  buffers: SourceBufferIterable,\n  isEndMatch: (next: number, current: number) => boolean\n): number {\n  return (\n    ([...buffers].reduce((endMatch: number | undefined, buffer) => {\n      const { buffered } = buffer;\n      if (!buffered.length) return endMatch;\n      const end = buffered.end(buffered.length - 1);\n      if (!endMatch) return end;\n      return isEndMatch(end, endMatch) ? end : endMatch;\n    }, undefined) as number) ?? 0\n  );\n}\n\nconst isGreaterThan = (x: number, y: number) => x > y;\nconst isLessThan = (x: number, y: number) => x < y;\n\n/**\n * Get the maximum buffered end time across an iterable of SourceBuffers\n * (typically `mediaSource.sourceBuffers`). Returns `0` when the collection is\n * empty or no buffer has any buffered ranges.\n */\nexport function getMaxBufferedEnd(buffers: SourceBufferIterable): number {\n  return getBufferedEnd(buffers, isGreaterThan);\n}\n\n/**\n * Get the reachable buffered end across an iterable of SourceBuffers (typically\n * `mediaSource.sourceBuffers`): the `min` of each buffer's last buffered-range end\n * — the furthest point every track can play to (the intersection end). Buffers with\n * no buffered ranges are skipped. Returns `0` when the collection is empty or no\n * buffer has any buffered ranges.\n *\n * Counterpart to {@link getMaxBufferedEnd}: `max` bounds the overall presentation\n * end (e.g. for setting `duration`), `min` bounds where playback can actually reach\n * when tracks end at slightly different times (e.g. skewed A/V near end-of-stream).\n */\nexport function getMinBufferedEnd(buffers: SourceBufferIterable): number {\n  return getBufferedEnd(buffers, isLessThan);\n}\n\n/**\n * Check if the preconditions are met to *attempt* a `mediaSource.duration`\n * write: a `mediaSource` is in scope and the presentation has a valid\n * positive duration (or `Infinity` for live).\n *\n * Does **not** check `mediaSource.readyState` or `mediaSource.duration` —\n * those are DOM properties the caller resolves at write time (e.g., by\n * `await`ing `waitForMediaSourceOpen` and re-checking `readyState` after,\n * and guarding on the existing `mediaSource.duration` for idempotency).\n * Keeping these off the signal-driven predicate lets callers use this\n * inside reactor state derivation without smuggling non-reactive DOM\n * reads into `computed(...)`.\n *\n * `Infinity` is allowed — per the MSE spec, `mediaSource.duration = +Infinity`\n * is how live playback signals an indefinite duration.\n */\nexport function shouldUpdateDuration(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined\n): boolean {\n  if (!canUpdateDuration(presentation, mediaSource)) return false;\n\n  const duration = presentation!.duration!;\n\n  if (Number.isNaN(duration) || duration <= 0) return false;\n\n  return true;\n}\n\n/**\n * Wait for all currently-updating SourceBuffers in `buffers` to finish, or\n * until `signal` aborts — whichever fires first.\n *\n * The MSE spec forbids setting `MediaSource.duration` while any attached\n * SourceBuffer has `updating === true`. This defers until all are idle.\n * Listeners are registered with `{ signal }` so an abort tears them down\n * up-front rather than leaving them dangling until the next `updateend`.\n */\nexport function waitForSourceBuffersReady(buffers: SourceBufferIterable, signal: AbortSignal): Promise<void> {\n  if (signal.aborted) return Promise.resolve();\n\n  const updating: SourceBuffer[] = [];\n  for (const buf of buffers) {\n    if (buf.updating) updating.push(buf);\n  }\n\n  if (updating.length === 0) return Promise.resolve();\n\n  return new Promise<void>((resolve) => {\n    let remaining = updating.length;\n    const onUpdateEnd = () => {\n      remaining--;\n      if (remaining === 0) resolve();\n    };\n\n    for (const buf of updating) {\n      buf.addEventListener('updateend', onUpdateEnd, { once: true, signal });\n    }\n\n    signal.addEventListener('abort', () => resolve(), { once: true });\n  });\n}\n"],"mappings":";;;;;;AA6BA,SAAgB,kBACd,cACA,aACS;CACT,OAAO,CAAC,EAAE,eAAe,gBAAgB,wBAAwB,YAAY;AAC/E;AAEA,SAAgB,eACd,SACA,YACQ;CACR,OACG,CAAC,GAAG,OAAO,CAAC,CAAC,QAAQ,UAA8B,WAAW;EAC7D,MAAM,EAAE,aAAa;EACrB,IAAI,CAAC,SAAS,QAAQ,OAAO;EAC7B,MAAM,MAAM,SAAS,IAAI,SAAS,SAAS,CAAC;EAC5C,IAAI,CAAC,UAAU,OAAO;EACtB,OAAO,WAAW,KAAK,QAAQ,IAAI,MAAM;CAC3C,GAAG,KAAA,CAAS,KAAgB;AAEhC;AAEA,MAAM,iBAAiB,GAAW,MAAc,IAAI;AACpD,MAAM,cAAc,GAAW,MAAc,IAAI;;;;;;AAOjD,SAAgB,kBAAkB,SAAuC;CACvE,OAAO,eAAe,SAAS,aAAa;AAC9C;;;;;;;;;;;;AAaA,SAAgB,kBAAkB,SAAuC;CACvE,OAAO,eAAe,SAAS,UAAU;AAC3C;;;;;;;;;;;;;;;;;AAkBA,SAAgB,qBACd,cACA,aACS;CACT,IAAI,CAAC,kBAAkB,cAAc,WAAW,GAAG,OAAO;CAE1D,MAAM,WAAW,aAAc;CAE/B,IAAI,OAAO,MAAM,QAAQ,KAAK,YAAY,GAAG,OAAO;CAEpD,OAAO;AACT;;;;;;;;;;AAWA,SAAgB,0BAA0B,SAA+B,QAAoC;CAC3G,IAAI,OAAO,SAAS,OAAO,QAAQ,QAAQ;CAE3C,MAAM,WAA2B,CAAC;CAClC,KAAK,MAAM,OAAO,SAChB,IAAI,IAAI,UAAU,SAAS,KAAK,GAAG;CAGrC,IAAI,SAAS,WAAW,GAAG,OAAO,QAAQ,QAAQ;CAElD,OAAO,IAAI,SAAe,YAAY;EACpC,IAAI,YAAY,SAAS;EACzB,MAAM,oBAAoB;GACxB;GACA,IAAI,cAAc,GAAG,QAAQ;EAC/B;EAEA,KAAK,MAAM,OAAO,UAChB,IAAI,iBAAiB,aAAa,aAAa;GAAE,MAAM;GAAM;EAAO,CAAC;EAGvE,OAAO,iBAAiB,eAAe,QAAQ,GAAG,EAAE,MAAM,KAAK,CAAC;CAClE,CAAC;AACH"}

package/dist/default/media/dom/mse/end-of-stream.js.map

@@ -1 +1 @@
-{"version":3,"file":"end-of-stream.js","names":[],"sources":["../../../../../src/media/dom/mse/end-of-stream.ts"],"sourcesContent":["/**\n * End-of-stream detection helpers.\n *\n * Pure predicate that compares a track's expected segment list against the\n * appended-segment list from an MSE SourceBufferActor's snapshot. Consumed\n * by the `endOfStream` playback behavior to decide when to call\n * `MediaSource.endOfStream()`.\n *\n * Kept here so the layering stays clean: predicate has no `core/`\n * reactivity and operates on plain segment lists extracted by the caller.\n */\n\n/**\n * Minimum information about an appended segment needed to decide whether\n * it counts toward end-of-stream readiness.\n *\n * Matches the shape of `SourceBufferActor`'s context segments — callers\n * typically pass `actor.snapshot.get().context.segments` directly.\n */\nexport interface AppendedSegment {\n  id: string;\n  /**\n   * True while a streaming append is in progress for this segment. A\n   * partial segment is still streaming — it does not count as the last\n   * segment being ready.\n   */\n  partial?: boolean;\n}\n\n/**\n * Check if the temporally last segment of `expectedSegments` is present in\n * `appendedSegments` and not marked partial.\n *\n * Compares by segment ID rather than by a pipeline flag, so the result\n * stays correct across quality switches (different tracks have different\n * segment IDs) and back-buffer flushes (flushed segment IDs are removed\n * from the appended list).\n */\nexport function isLastSegmentAppended(\n  expectedSegments: readonly { id: string }[],\n  appendedSegments: readonly AppendedSegment[] | undefined\n): boolean {\n  if (expectedSegments.length === 0) return true;\n  const lastSeg = expectedSegments[expectedSegments.length - 1];\n  if (!lastSeg) return false;\n  return appendedSegments?.some((s) => s.id === lastSeg.id && !s.partial) ?? false;\n}\n"],"mappings":";;;;;;;;;;AAsCA,SAAgB,sBACd,kBACA,kBACS;AACT,KAAI,iBAAiB,WAAW,EAAG,QAAO;CAC1C,MAAM,UAAU,iBAAiB,iBAAiB,SAAS;AAC3D,KAAI,CAAC,QAAS,QAAO;AACrB,QAAO,kBAAkB,MAAM,MAAM,EAAE,OAAO,QAAQ,MAAM,CAAC,EAAE,QAAQ,IAAI"}
+{"version":3,"file":"end-of-stream.js","names":[],"sources":["../../../../../src/media/dom/mse/end-of-stream.ts"],"sourcesContent":["/**\n * End-of-stream detection helpers.\n *\n * Pure predicate that compares a track's expected segment list against the\n * appended-segment list from an MSE SourceBufferActor's snapshot. Consumed\n * by the `endOfStream` playback behavior to decide when to call\n * `MediaSource.endOfStream()`.\n *\n * Kept here so the layering stays clean: predicate has no `core/`\n * reactivity and operates on plain segment lists extracted by the caller.\n */\n\n/**\n * Minimum information about an appended segment needed to decide whether\n * it counts toward end-of-stream readiness.\n *\n * Matches the shape of `SourceBufferActor`'s context segments — callers\n * typically pass `actor.snapshot.get().context.segments` directly.\n */\nexport interface AppendedSegment {\n  id: string;\n  /**\n   * True while a streaming append is in progress for this segment. A\n   * partial segment is still streaming — it does not count as the last\n   * segment being ready.\n   */\n  partial?: boolean;\n}\n\n/**\n * Check if the temporally last segment of `expectedSegments` is present in\n * `appendedSegments` and not marked partial.\n *\n * Compares by segment ID rather than by a pipeline flag, so the result\n * stays correct across quality switches (different tracks have different\n * segment IDs) and back-buffer flushes (flushed segment IDs are removed\n * from the appended list).\n */\nexport function isLastSegmentAppended(\n  expectedSegments: readonly { id: string }[],\n  appendedSegments: readonly AppendedSegment[] | undefined\n): boolean {\n  if (expectedSegments.length === 0) return true;\n  const lastSeg = expectedSegments[expectedSegments.length - 1];\n  if (!lastSeg) return false;\n  return appendedSegments?.some((s) => s.id === lastSeg.id && !s.partial) ?? false;\n}\n"],"mappings":";;;;;;;;;;AAsCA,SAAgB,sBACd,kBACA,kBACS;CACT,IAAI,iBAAiB,WAAW,GAAG,OAAO;CAC1C,MAAM,UAAU,iBAAiB,iBAAiB,SAAS;CAC3D,IAAI,CAAC,SAAS,OAAO;CACrB,OAAO,kBAAkB,MAAM,MAAM,EAAE,OAAO,QAAQ,MAAM,CAAC,EAAE,OAAO,KAAK;AAC7E"}

package/dist/default/media/dom/mse/mediasource-setup.js

@@ -39,9 +39,11 @@ function createMediaSource(options = {}) {
 	throw new Error("MediaSource API is not supported");
 }
 /**
-* Attach a MediaSource to an HTMLMediaElement.
+* Attach a MediaSource to an HTMLMediaElement via the `src` attribute.
 *
-* Uses srcObject for ManagedMediaSource (Safari), or createObjectURL for regular MediaSource.
+* The object URL on the `src` attribute is the industry-hardened MSE attach
+* across the browser matrix, and works for ManagedMediaSource too (`srcObject`
+* buys nothing over it and forfeits the uniform URL lifecycle).
 *
 * @param mediaSource - The MediaSource to attach
 * @param mediaElement - The media element to attach to
@@ -55,23 +57,12 @@ function createMediaSource(options = {}) {
 * detach();
 */
 function attachMediaSource(mediaSource, mediaElement) {
-	if (supportsManagedMediaSource() && mediaSource instanceof ManagedMediaSource) {
-		mediaElement.disableRemotePlayback = true;
-		mediaElement.srcObject = mediaSource;
-		const detach = () => {
-			mediaElement.srcObject = null;
-			mediaElement.load();
-		};
-		return {
-			url: "",
-			detach
-		};
-	}
+	if (supportsManagedMediaSource() && mediaSource instanceof ManagedMediaSource) mediaElement.disableRemotePlayback = true;
 	const url = URL.createObjectURL(mediaSource);
 	mediaElement.src = url;
-	const detach = () => {
+	const detach = ({ deferReset } = {}) => {
 		mediaElement.removeAttribute("src");
-		mediaElement.load();
+		scheduleReset(mediaSource, mediaElement, url, deferReset);
 		URL.revokeObjectURL(url);
 	};
 	return {
@@ -80,6 +71,66 @@ function attachMediaSource(mediaSource, mediaElement) {
 	};
 }
 /**
+* Attach a MediaSource as a `<source>` child element.
+*
+* The object URL rides a `<source type="video/mp4">` inserted as the
+* element's FIRST child (any bare `src` attribute is dropped; `load()`
+* re-runs resource selection). Unlike `srcObject`/`src` — which commit the
+* element to the MSE resource and ignore every `<source>` child — this
+* keeps sibling `<source>` alternatives part of resource selection, so a
+* composition can offer the element a natively-playable alternative next to
+* MSE. Canonical consumer: `setupAirPlay`'s native-HLS fallback source,
+* wired through `setupMediaSource`'s `attachMediaSource` config
+* (https://webkit.org/blog/15036/how-to-use-media-source-extensions-with-airplay/).
+*/
+function attachMediaSourceAsSourceElement(mediaSource, mediaElement) {
+	if (supportsManagedMediaSource() && mediaSource instanceof ManagedMediaSource) mediaElement.disableRemotePlayback = true;
+	const url = URL.createObjectURL(mediaSource);
+	const sourceEl = document.createElement("source");
+	sourceEl.type = "video/mp4";
+	sourceEl.src = url;
+	mediaElement.removeAttribute("src");
+	mediaElement.prepend(sourceEl);
+	mediaElement.load();
+	const detach = ({ deferReset } = {}) => {
+		sourceEl.remove();
+		scheduleReset(mediaSource, mediaElement, url, deferReset);
+		URL.revokeObjectURL(url);
+	};
+	return {
+		url,
+		detach
+	};
+}
+/**
+* Detach's `load()` reset, applied only when tearing down an **unclosed**
+* attachment the element is still committed to:
+*
+* - **Closed MediaSource**: skip. The attachment is already dead, and the
+*   element deliberately keeps whatever playback state it carries for
+*   whatever attaches next — that attach's own `load()` performs the reset.
+* - **Element moved to another resource**: skip — resetting would rip that
+*   resource out from under its owner.
+*/
+function resetIfOwnedAndNotClosed(mediaSource, mediaElement, url) {
+	if (mediaSource.readyState !== "closed" && mediaElement.currentSrc === url) mediaElement.load();
+}
+/**
+* Run the reset now, or on the next microtask when the caller has sibling
+* `<source>` owners that clear on an effect (see {@link DetachOptions.deferReset}).
+*
+* Deferring is safe because removing this attachment's own source does not by
+* itself re-run resource selection: the element stays committed to the object
+* URL until something calls `load()`, so nothing starts playing in the gap.
+*/
+function scheduleReset(mediaSource, mediaElement, url, deferReset) {
+	if (deferReset) {
+		queueMicrotask(() => resetIfOwnedAndNotClosed(mediaSource, mediaElement, url));
+		return;
+	}
+	resetIfOwnedAndNotClosed(mediaSource, mediaElement, url);
+}
+/**
 * Create a SourceBuffer on a MediaSource.
 *
 * @param mediaSource - The MediaSource (must be in 'open' state)
@@ -186,6 +237,6 @@ function waitForMediaSourceOpen(mediaSource, signal) {
 	});
 }
 //#endregion
-export { attachMediaSource, buildMimeCodec, createMediaSource, createSourceBuffer, onMediaSourceReadyStateChange, waitForMediaSourceOpen };
+export { attachMediaSource, attachMediaSourceAsSourceElement, buildMimeCodec, createMediaSource, createSourceBuffer, isCodecSupported, onMediaSourceReadyStateChange, supportsManagedMediaSource, supportsMediaSource, waitForMediaSourceOpen };
 
 //# sourceMappingURL=mediasource-setup.js.map

package/dist/default/media/dom/mse/mediasource-setup.js.map

@@ -1 +1 @@
-{"version":3,"file":"mediasource-setup.js","names":[],"sources":["../../../../../src/media/dom/mse/mediasource-setup.ts"],"sourcesContent":["/**\n * MediaSource Setup\n *\n * Utilities for creating and configuring MediaSource/ManagedMediaSource\n * for MSE (Media Source Extensions) playback.\n *\n * Global ManagedMediaSource types are defined in ./mediasource.d.ts\n */\n\n/**\n * Check if MediaSource API is supported.\n */\nexport function supportsMediaSource(): boolean {\n  return typeof MediaSource !== 'undefined';\n}\n\n/**\n * Check if ManagedMediaSource API is supported.\n * ManagedMediaSource is a newer Safari API with better lifecycle management.\n */\nexport function supportsManagedMediaSource(): boolean {\n  return typeof ManagedMediaSource !== 'undefined';\n}\n\n/**\n * Options for creating a MediaSource.\n */\nexport interface CreateMediaSourceOptions {\n  /** Prefer ManagedMediaSource when available (default: false for broader compatibility). */\n  preferManaged?: boolean;\n}\n\n/**\n * Create a MediaSource or ManagedMediaSource instance.\n *\n * @param options - Creation options\n * @returns A MediaSource or ManagedMediaSource instance\n * @throws Error if no MediaSource API is available\n *\n * @example\n * const mediaSource = createMediaSource();\n * const mediaElement = document.querySelector('video');\n * attachMediaSource(mediaSource, mediaElement);\n */\nexport function createMediaSource(options: CreateMediaSourceOptions = {}): MediaSource {\n  const { preferManaged = false } = options;\n\n  if (preferManaged && supportsManagedMediaSource()) {\n    return new ManagedMediaSource!();\n  }\n\n  if (supportsMediaSource()) {\n    return new MediaSource();\n  }\n\n  throw new Error('MediaSource API is not supported');\n}\n\n/**\n * Result of attaching a MediaSource to a media element.\n */\nexport interface AttachMediaSourceResult {\n  /** The object URL created for the MediaSource (empty string for ManagedMediaSource). */\n  url: string;\n  /** Detach the MediaSource and clean up resources. */\n  detach: () => void;\n}\n\n/**\n * Attach a MediaSource to an HTMLMediaElement.\n *\n * Uses srcObject for ManagedMediaSource (Safari), or createObjectURL for regular MediaSource.\n *\n * @param mediaSource - The MediaSource to attach\n * @param mediaElement - The media element to attach to\n * @returns Object with URL and detach function\n *\n * @example\n * const mediaSource = createMediaSource();\n * const { detach } = attachMediaSource(mediaSource, videoElement);\n * // Use mediaSource...\n * // Later, to clean up:\n * detach();\n */\nexport function attachMediaSource(mediaSource: MediaSource, mediaElement: HTMLMediaElement): AttachMediaSourceResult {\n  // ManagedMediaSource requires srcObject instead of createObjectURL\n  const isManagedMediaSource = supportsManagedMediaSource() && mediaSource instanceof ManagedMediaSource!;\n\n  if (isManagedMediaSource) {\n    // ManagedMediaSource requires disableRemotePlayback — without it Safari\n    // will not fire sourceopen.\n    (mediaElement as HTMLMediaElement & { disableRemotePlayback: boolean }).disableRemotePlayback = true;\n\n    // Use srcObject for ManagedMediaSource\n    (mediaElement as HTMLMediaElement & { srcObject: MediaSource | null }).srcObject = mediaSource;\n\n    const detach = (): void => {\n      (mediaElement as HTMLMediaElement & { srcObject: MediaSource | null }).srcObject = null;\n      mediaElement.load(); // Reset the element\n    };\n\n    return { url: '', detach };\n  }\n\n  // Use createObjectURL for regular MediaSource\n  const url = URL.createObjectURL(mediaSource);\n  mediaElement.src = url;\n\n  const detach = (): void => {\n    mediaElement.removeAttribute('src');\n    mediaElement.load(); // Reset the element\n    URL.revokeObjectURL(url);\n  };\n\n  return { url, detach };\n}\n\n/**\n * Create a SourceBuffer on a MediaSource.\n *\n * @param mediaSource - The MediaSource (must be in 'open' state)\n * @param mimeCodec - MIME type with codecs (e.g., 'video/mp4; codecs=\"avc1.42E01E\"')\n * @returns The created SourceBuffer\n * @throws Error if MediaSource is not open or codec is unsupported\n *\n * @example\n * const buffer = createSourceBuffer(mediaSource, 'video/mp4; codecs=\"avc1.42E01E\"');\n */\nexport function createSourceBuffer(mediaSource: MediaSource, mimeCodec: string): SourceBuffer {\n  if (mediaSource.readyState !== 'open') {\n    throw new Error('MediaSource is not open');\n  }\n\n  if (!isCodecSupported(mimeCodec)) {\n    throw new Error(`Codec not supported: ${mimeCodec}`);\n  }\n\n  return mediaSource.addSourceBuffer(mimeCodec);\n}\n\n/**\n * Build a MIME codec string from a track's `mimeType` + `codecs`. Works\n * on partially-resolved tracks — both fields come from the multivariant\n * playlist and are available before media-playlist resolution.\n *\n * @param track - Track carrying `mimeType` and `codecs`\n * @returns MIME codec string suitable for `MediaSource.addSourceBuffer`\n *\n * @example\n * buildMimeCodec({ mimeType: 'video/mp4', codecs: ['avc1.42E01E'] })\n * // => 'video/mp4; codecs=\"avc1.42E01E\"'\n */\nexport function buildMimeCodec(track: { mimeType: string; codecs?: string[] }): string {\n  const codecString = track.codecs?.join(',') ?? '';\n  return `${track.mimeType}; codecs=\"${codecString}\"`;\n}\n\n/**\n * Check if a codec is supported.\n *\n * @param mimeCodec - MIME type with codecs string\n * @returns True if the codec is supported\n *\n * @example\n * if (isCodecSupported('video/mp4; codecs=\"avc1.42E01E\"')) {\n *   // Create source buffer\n * }\n */\nexport function isCodecSupported(mimeCodec: string): boolean {\n  if (!supportsMediaSource()) {\n    return false;\n  }\n\n  return MediaSource.isTypeSupported(mimeCodec);\n}\n\n/**\n * Observe `mediaSource.readyState` changes via DOM events.\n *\n * Listens to `sourceopen`, `sourceended`, and `sourceclose` and invokes\n * `onChange` with the current `readyState` after each event. Listeners\n * are automatically removed when `abortSignal` is aborted.\n *\n * @param mediaSource - The MediaSource to observe\n * @param abortSignal - AbortSignal that controls listener lifetime\n * @param onChange - Called with the current readyState after each change\n *\n * @example\n * const controller = new AbortController();\n * onMediaSourceReadyStateChange(mediaSource, controller.signal, (state) => {\n *   if (state === 'open') { ... }\n * });\n * // Later: controller.abort();\n */\nexport function onMediaSourceReadyStateChange(\n  mediaSource: MediaSource,\n  abortSignal: AbortSignal,\n  onChange: (readyState: MediaSource['readyState']) => void\n): void {\n  const update = () => onChange(mediaSource.readyState);\n  const options = { signal: abortSignal };\n  mediaSource.addEventListener('sourceopen', update, options);\n  mediaSource.addEventListener('sourceended', update, options);\n  mediaSource.addEventListener('sourceclose', update, options);\n}\n\n/**\n * Wait until `mediaSource.readyState` transitions away from `'closed'`\n * (the next `sourceopen`/`sourceended`/`sourceclose` event), or until\n * `signal` aborts — whichever fires first.\n *\n * Resolves immediately when `readyState` is already `'open'` or `'ended'`\n * (no further transition is coming, so there's nothing to wait for). The\n * caller is expected to re-check `readyState` after the await to\n * distinguish `'open'` from terminal states.\n *\n * Companion to `onMediaSourceReadyStateChange` for one-shot use in async\n * sequences (e.g., a behavior's reactor entry that needs to wait for the\n * MediaSource to attach before performing a spec-conforming mutation).\n *\n * @example\n * await waitForMediaSourceOpen(mediaSource, signal);\n * if (signal.aborted || mediaSource.readyState !== 'open') return;\n * // safe to perform 'open'-state-only work\n */\nexport function waitForMediaSourceOpen(mediaSource: MediaSource, signal: AbortSignal): Promise<void> {\n  if (signal.aborted) return Promise.resolve();\n  if (mediaSource.readyState !== 'closed') return Promise.resolve();\n\n  return new Promise<void>((resolve) => {\n    const done = () => resolve();\n    const options = { once: true, signal };\n    mediaSource.addEventListener('sourceopen', done, options);\n    mediaSource.addEventListener('sourceended', done, options);\n    mediaSource.addEventListener('sourceclose', done, options);\n    signal.addEventListener('abort', done, { once: true });\n  });\n}\n"],"mappings":";;;;;;;;;;;;AAYA,SAAgB,sBAA+B;AAC7C,QAAO,OAAO,gBAAgB;;;;;;AAOhC,SAAgB,6BAAsC;AACpD,QAAO,OAAO,uBAAuB;;;;;;;;;;;;;;AAuBvC,SAAgB,kBAAkB,UAAoC,EAAE,EAAe;CACrF,MAAM,EAAE,gBAAgB,UAAU;AAElC,KAAI,iBAAiB,4BAA4B,CAC/C,QAAO,IAAI,oBAAqB;AAGlC,KAAI,qBAAqB,CACvB,QAAO,IAAI,aAAa;AAG1B,OAAM,IAAI,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;AA6BrD,SAAgB,kBAAkB,aAA0B,cAAyD;AAInH,KAF6B,4BAA4B,IAAI,uBAAuB,oBAE1D;AAGvB,eAAuE,wBAAwB;AAG/F,eAAsE,YAAY;EAEnF,MAAM,eAAqB;AACxB,gBAAsE,YAAY;AACnF,gBAAa,MAAM;;AAGrB,SAAO;GAAE,KAAK;GAAI;GAAQ;;CAI5B,MAAM,MAAM,IAAI,gBAAgB,YAAY;AAC5C,cAAa,MAAM;CAEnB,MAAM,eAAqB;AACzB,eAAa,gBAAgB,MAAM;AACnC,eAAa,MAAM;AACnB,MAAI,gBAAgB,IAAI;;AAG1B,QAAO;EAAE;EAAK;EAAQ;;;;;;;;;;;;;AAcxB,SAAgB,mBAAmB,aAA0B,WAAiC;AAC5F,KAAI,YAAY,eAAe,OAC7B,OAAM,IAAI,MAAM,0BAA0B;AAG5C,KAAI,CAAC,iBAAiB,UAAU,CAC9B,OAAM,IAAI,MAAM,wBAAwB,YAAY;AAGtD,QAAO,YAAY,gBAAgB,UAAU;;;;;;;;;;;;;;AAe/C,SAAgB,eAAe,OAAwD;CACrF,MAAM,cAAc,MAAM,QAAQ,KAAK,IAAI,IAAI;AAC/C,QAAO,GAAG,MAAM,SAAS,YAAY,YAAY;;;;;;;;;;;;;AAcnD,SAAgB,iBAAiB,WAA4B;AAC3D,KAAI,CAAC,qBAAqB,CACxB,QAAO;AAGT,QAAO,YAAY,gBAAgB,UAAU;;;;;;;;;;;;;;;;;;;;AAqB/C,SAAgB,8BACd,aACA,aACA,UACM;CACN,MAAM,eAAe,SAAS,YAAY,WAAW;CACrD,MAAM,UAAU,EAAE,QAAQ,aAAa;AACvC,aAAY,iBAAiB,cAAc,QAAQ,QAAQ;AAC3D,aAAY,iBAAiB,eAAe,QAAQ,QAAQ;AAC5D,aAAY,iBAAiB,eAAe,QAAQ,QAAQ;;;;;;;;;;;;;;;;;;;;;AAsB9D,SAAgB,uBAAuB,aAA0B,QAAoC;AACnG,KAAI,OAAO,QAAS,QAAO,QAAQ,SAAS;AAC5C,KAAI,YAAY,eAAe,SAAU,QAAO,QAAQ,SAAS;AAEjE,QAAO,IAAI,SAAe,YAAY;EACpC,MAAM,aAAa,SAAS;EAC5B,MAAM,UAAU;GAAE,MAAM;GAAM;GAAQ;AACtC,cAAY,iBAAiB,cAAc,MAAM,QAAQ;AACzD,cAAY,iBAAiB,eAAe,MAAM,QAAQ;AAC1D,cAAY,iBAAiB,eAAe,MAAM,QAAQ;AAC1D,SAAO,iBAAiB,SAAS,MAAM,EAAE,MAAM,MAAM,CAAC;GACtD"}
+{"version":3,"file":"mediasource-setup.js","names":[],"sources":["../../../../../src/media/dom/mse/mediasource-setup.ts"],"sourcesContent":["/**\n * MediaSource Setup\n *\n * Utilities for creating and configuring MediaSource/ManagedMediaSource\n * for MSE (Media Source Extensions) playback.\n *\n * Global ManagedMediaSource types are defined in ./mediasource.d.ts\n */\n\n/**\n * Check if MediaSource API is supported.\n */\nexport function supportsMediaSource(): boolean {\n  return typeof MediaSource !== 'undefined';\n}\n\n/**\n * Check if ManagedMediaSource API is supported.\n * ManagedMediaSource is a newer Safari API with better lifecycle management.\n */\nexport function supportsManagedMediaSource(): boolean {\n  return typeof ManagedMediaSource !== 'undefined';\n}\n\n/**\n * Options for creating a MediaSource.\n */\nexport interface CreateMediaSourceOptions {\n  /** Prefer ManagedMediaSource when available (default: false for broader compatibility). */\n  preferManaged?: boolean;\n}\n\n/**\n * Create a MediaSource or ManagedMediaSource instance.\n *\n * @param options - Creation options\n * @returns A MediaSource or ManagedMediaSource instance\n * @throws Error if no MediaSource API is available\n *\n * @example\n * const mediaSource = createMediaSource();\n * const mediaElement = document.querySelector('video');\n * attachMediaSource(mediaSource, mediaElement);\n */\nexport function createMediaSource(options: CreateMediaSourceOptions = {}): MediaSource {\n  const { preferManaged = false } = options;\n\n  if (preferManaged && supportsManagedMediaSource()) {\n    return new ManagedMediaSource!();\n  }\n\n  if (supportsMediaSource()) {\n    return new MediaSource();\n  }\n\n  throw new Error('MediaSource API is not supported');\n}\n\n/**\n * Options for `detach`.\n */\nexport interface DetachOptions {\n  /**\n   * Run the `load()` reset on the next microtask instead of synchronously.\n   *\n   * Required whenever another owner contributes sibling `<source>` children to\n   * the same element and drops them from a signal effect: effects re-run on a\n   * microtask, so a synchronous reset would run resource selection while those\n   * siblings are still in the DOM and commit the element to one of them.\n   * Canonical caller: `setupMediaSource`, whose compositions may include\n   * `setupAirPlay`'s native-HLS fallback source.\n   *\n   * The ownership guard is evaluated when the reset actually fires, so a\n   * re-attach landing in the interim correctly suppresses it.\n   */\n  deferReset?: boolean;\n}\n\n/**\n * Result of attaching a MediaSource to a media element.\n */\nexport interface AttachMediaSourceResult {\n  /** The object URL created for the MediaSource. */\n  url: string;\n  /** Detach the MediaSource and clean up resources. */\n  detach: (options?: DetachOptions) => void;\n}\n\n/**\n * Attach a MediaSource to an HTMLMediaElement via the `src` attribute.\n *\n * The object URL on the `src` attribute is the industry-hardened MSE attach\n * across the browser matrix, and works for ManagedMediaSource too (`srcObject`\n * buys nothing over it and forfeits the uniform URL lifecycle).\n *\n * @param mediaSource - The MediaSource to attach\n * @param mediaElement - The media element to attach to\n * @returns Object with URL and detach function\n *\n * @example\n * const mediaSource = createMediaSource();\n * const { detach } = attachMediaSource(mediaSource, videoElement);\n * // Use mediaSource...\n * // Later, to clean up:\n * detach();\n */\nexport function attachMediaSource(mediaSource: MediaSource, mediaElement: HTMLMediaElement): AttachMediaSourceResult {\n  // ManagedMediaSource requires disableRemotePlayback — without it Safari\n  // will not fire sourceopen. (MMS-only: on other platforms the flag governs\n  // the standard Remote Playback API and must be left alone.)\n  if (supportsManagedMediaSource() && mediaSource instanceof ManagedMediaSource!) {\n    mediaElement.disableRemotePlayback = true;\n  }\n\n  const url = URL.createObjectURL(mediaSource);\n  mediaElement.src = url;\n\n  const detach = ({ deferReset }: DetachOptions = {}): void => {\n    mediaElement.removeAttribute('src');\n    scheduleReset(mediaSource, mediaElement, url, deferReset);\n    URL.revokeObjectURL(url);\n  };\n\n  return { url, detach };\n}\n\n/**\n * Attach a MediaSource as a `<source>` child element.\n *\n * The object URL rides a `<source type=\"video/mp4\">` inserted as the\n * element's FIRST child (any bare `src` attribute is dropped; `load()`\n * re-runs resource selection). Unlike `srcObject`/`src` — which commit the\n * element to the MSE resource and ignore every `<source>` child — this\n * keeps sibling `<source>` alternatives part of resource selection, so a\n * composition can offer the element a natively-playable alternative next to\n * MSE. Canonical consumer: `setupAirPlay`'s native-HLS fallback source,\n * wired through `setupMediaSource`'s `attachMediaSource` config\n * (https://webkit.org/blog/15036/how-to-use-media-source-extensions-with-airplay/).\n */\nexport function attachMediaSourceAsSourceElement(\n  mediaSource: MediaSource,\n  mediaElement: HTMLMediaElement\n): AttachMediaSourceResult {\n  // ManagedMediaSource requires disableRemotePlayback — without it Safari\n  // will not fire sourceopen. (MMS-only: on other platforms the flag governs\n  // the standard Remote Playback API and must be left alone.) Features that\n  // need it false flip it once the source is open.\n  if (supportsManagedMediaSource() && mediaSource instanceof ManagedMediaSource!) {\n    mediaElement.disableRemotePlayback = true;\n  }\n\n  const url = URL.createObjectURL(mediaSource);\n  const sourceEl = document.createElement('source');\n  sourceEl.type = 'video/mp4';\n  sourceEl.src = url;\n\n  mediaElement.removeAttribute('src');\n  mediaElement.prepend(sourceEl);\n  mediaElement.load();\n\n  const detach = ({ deferReset }: DetachOptions = {}): void => {\n    sourceEl.remove();\n    scheduleReset(mediaSource, mediaElement, url, deferReset);\n    URL.revokeObjectURL(url);\n  };\n\n  return { url, detach };\n}\n\n/**\n * Detach's `load()` reset, applied only when tearing down an **unclosed**\n * attachment the element is still committed to:\n *\n * - **Closed MediaSource**: skip. The attachment is already dead, and the\n *   element deliberately keeps whatever playback state it carries for\n *   whatever attaches next — that attach's own `load()` performs the reset.\n * - **Element moved to another resource**: skip — resetting would rip that\n *   resource out from under its owner.\n */\nfunction resetIfOwnedAndNotClosed(mediaSource: MediaSource, mediaElement: HTMLMediaElement, url: string): void {\n  if (mediaSource.readyState !== 'closed' && mediaElement.currentSrc === url) {\n    mediaElement.load();\n  }\n}\n\n/**\n * Run the reset now, or on the next microtask when the caller has sibling\n * `<source>` owners that clear on an effect (see {@link DetachOptions.deferReset}).\n *\n * Deferring is safe because removing this attachment's own source does not by\n * itself re-run resource selection: the element stays committed to the object\n * URL until something calls `load()`, so nothing starts playing in the gap.\n */\nfunction scheduleReset(\n  mediaSource: MediaSource,\n  mediaElement: HTMLMediaElement,\n  url: string,\n  deferReset: boolean | undefined\n): void {\n  if (deferReset) {\n    queueMicrotask(() => resetIfOwnedAndNotClosed(mediaSource, mediaElement, url));\n    return;\n  }\n  resetIfOwnedAndNotClosed(mediaSource, mediaElement, url);\n}\n\n/**\n * Create a SourceBuffer on a MediaSource.\n *\n * @param mediaSource - The MediaSource (must be in 'open' state)\n * @param mimeCodec - MIME type with codecs (e.g., 'video/mp4; codecs=\"avc1.42E01E\"')\n * @returns The created SourceBuffer\n * @throws Error if MediaSource is not open or codec is unsupported\n *\n * @example\n * const buffer = createSourceBuffer(mediaSource, 'video/mp4; codecs=\"avc1.42E01E\"');\n */\nexport function createSourceBuffer(mediaSource: MediaSource, mimeCodec: string): SourceBuffer {\n  if (mediaSource.readyState !== 'open') {\n    throw new Error('MediaSource is not open');\n  }\n\n  if (!isCodecSupported(mimeCodec)) {\n    throw new Error(`Codec not supported: ${mimeCodec}`);\n  }\n\n  return mediaSource.addSourceBuffer(mimeCodec);\n}\n\n/**\n * Build a MIME codec string from a track's `mimeType` + `codecs`. Works\n * on partially-resolved tracks — both fields come from the multivariant\n * playlist and are available before media-playlist resolution.\n *\n * @param track - Track carrying `mimeType` and `codecs`\n * @returns MIME codec string suitable for `MediaSource.addSourceBuffer`\n *\n * @example\n * buildMimeCodec({ mimeType: 'video/mp4', codecs: ['avc1.42E01E'] })\n * // => 'video/mp4; codecs=\"avc1.42E01E\"'\n */\nexport function buildMimeCodec(track: { mimeType: string; codecs?: string[] }): string {\n  const codecString = track.codecs?.join(',') ?? '';\n  return `${track.mimeType}; codecs=\"${codecString}\"`;\n}\n\n/**\n * Check if a codec is supported.\n *\n * @param mimeCodec - MIME type with codecs string\n * @returns True if the codec is supported\n *\n * @example\n * if (isCodecSupported('video/mp4; codecs=\"avc1.42E01E\"')) {\n *   // Create source buffer\n * }\n */\nexport function isCodecSupported(mimeCodec: string): boolean {\n  if (!supportsMediaSource()) {\n    return false;\n  }\n\n  return MediaSource.isTypeSupported(mimeCodec);\n}\n\n/**\n * Observe `mediaSource.readyState` changes via DOM events.\n *\n * Listens to `sourceopen`, `sourceended`, and `sourceclose` and invokes\n * `onChange` with the current `readyState` after each event. Listeners\n * are automatically removed when `abortSignal` is aborted.\n *\n * @param mediaSource - The MediaSource to observe\n * @param abortSignal - AbortSignal that controls listener lifetime\n * @param onChange - Called with the current readyState after each change\n *\n * @example\n * const controller = new AbortController();\n * onMediaSourceReadyStateChange(mediaSource, controller.signal, (state) => {\n *   if (state === 'open') { ... }\n * });\n * // Later: controller.abort();\n */\nexport function onMediaSourceReadyStateChange(\n  mediaSource: MediaSource,\n  abortSignal: AbortSignal,\n  onChange: (readyState: MediaSource['readyState']) => void\n): void {\n  const update = () => onChange(mediaSource.readyState);\n  const options = { signal: abortSignal };\n  mediaSource.addEventListener('sourceopen', update, options);\n  mediaSource.addEventListener('sourceended', update, options);\n  mediaSource.addEventListener('sourceclose', update, options);\n}\n\n/**\n * Wait until `mediaSource.readyState` transitions away from `'closed'`\n * (the next `sourceopen`/`sourceended`/`sourceclose` event), or until\n * `signal` aborts — whichever fires first.\n *\n * Resolves immediately when `readyState` is already `'open'` or `'ended'`\n * (no further transition is coming, so there's nothing to wait for). The\n * caller is expected to re-check `readyState` after the await to\n * distinguish `'open'` from terminal states.\n *\n * Companion to `onMediaSourceReadyStateChange` for one-shot use in async\n * sequences (e.g., a behavior's reactor entry that needs to wait for the\n * MediaSource to attach before performing a spec-conforming mutation).\n *\n * @example\n * await waitForMediaSourceOpen(mediaSource, signal);\n * if (signal.aborted || mediaSource.readyState !== 'open') return;\n * // safe to perform 'open'-state-only work\n */\nexport function waitForMediaSourceOpen(mediaSource: MediaSource, signal: AbortSignal): Promise<void> {\n  if (signal.aborted) return Promise.resolve();\n  if (mediaSource.readyState !== 'closed') return Promise.resolve();\n\n  return new Promise<void>((resolve) => {\n    const done = () => resolve();\n    const options = { once: true, signal };\n    mediaSource.addEventListener('sourceopen', done, options);\n    mediaSource.addEventListener('sourceended', done, options);\n    mediaSource.addEventListener('sourceclose', done, options);\n    signal.addEventListener('abort', done, { once: true });\n  });\n}\n"],"mappings":";;;;;;;;;;;;AAYA,SAAgB,sBAA+B;CAC7C,OAAO,OAAO,gBAAgB;AAChC;;;;;AAMA,SAAgB,6BAAsC;CACpD,OAAO,OAAO,uBAAuB;AACvC;;;;;;;;;;;;;AAsBA,SAAgB,kBAAkB,UAAoC,CAAC,GAAgB;CACrF,MAAM,EAAE,gBAAgB,UAAU;CAElC,IAAI,iBAAiB,2BAA2B,GAC9C,OAAO,IAAI,mBAAoB;CAGjC,IAAI,oBAAoB,GACtB,OAAO,IAAI,YAAY;CAGzB,MAAM,IAAI,MAAM,kCAAkC;AACpD;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,kBAAkB,aAA0B,cAAyD;CAInH,IAAI,2BAA2B,KAAK,uBAAuB,oBACzD,aAAa,wBAAwB;CAGvC,MAAM,MAAM,IAAI,gBAAgB,WAAW;CAC3C,aAAa,MAAM;CAEnB,MAAM,UAAU,EAAE,eAA8B,CAAC,MAAY;EAC3D,aAAa,gBAAgB,KAAK;EAClC,cAAc,aAAa,cAAc,KAAK,UAAU;EACxD,IAAI,gBAAgB,GAAG;CACzB;CAEA,OAAO;EAAE;EAAK;CAAO;AACvB;;;;;;;;;;;;;;AAeA,SAAgB,iCACd,aACA,cACyB;CAKzB,IAAI,2BAA2B,KAAK,uBAAuB,oBACzD,aAAa,wBAAwB;CAGvC,MAAM,MAAM,IAAI,gBAAgB,WAAW;CAC3C,MAAM,WAAW,SAAS,cAAc,QAAQ;CAChD,SAAS,OAAO;CAChB,SAAS,MAAM;CAEf,aAAa,gBAAgB,KAAK;CAClC,aAAa,QAAQ,QAAQ;CAC7B,aAAa,KAAK;CAElB,MAAM,UAAU,EAAE,eAA8B,CAAC,MAAY;EAC3D,SAAS,OAAO;EAChB,cAAc,aAAa,cAAc,KAAK,UAAU;EACxD,IAAI,gBAAgB,GAAG;CACzB;CAEA,OAAO;EAAE;EAAK;CAAO;AACvB;;;;;;;;;;;AAYA,SAAS,yBAAyB,aAA0B,cAAgC,KAAmB;CAC7G,IAAI,YAAY,eAAe,YAAY,aAAa,eAAe,KACrE,aAAa,KAAK;AAEtB;;;;;;;;;AAUA,SAAS,cACP,aACA,cACA,KACA,YACM;CACN,IAAI,YAAY;EACd,qBAAqB,yBAAyB,aAAa,cAAc,GAAG,CAAC;EAC7E;CACF;CACA,yBAAyB,aAAa,cAAc,GAAG;AACzD;;;;;;;;;;;;AAaA,SAAgB,mBAAmB,aAA0B,WAAiC;CAC5F,IAAI,YAAY,eAAe,QAC7B,MAAM,IAAI,MAAM,yBAAyB;CAG3C,IAAI,CAAC,iBAAiB,SAAS,GAC7B,MAAM,IAAI,MAAM,wBAAwB,WAAW;CAGrD,OAAO,YAAY,gBAAgB,SAAS;AAC9C;;;;;;;;;;;;;AAcA,SAAgB,eAAe,OAAwD;CACrF,MAAM,cAAc,MAAM,QAAQ,KAAK,GAAG,KAAK;CAC/C,OAAO,GAAG,MAAM,SAAS,YAAY,YAAY;AACnD;;;;;;;;;;;;AAaA,SAAgB,iBAAiB,WAA4B;CAC3D,IAAI,CAAC,oBAAoB,GACvB,OAAO;CAGT,OAAO,YAAY,gBAAgB,SAAS;AAC9C;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,8BACd,aACA,aACA,UACM;CACN,MAAM,eAAe,SAAS,YAAY,UAAU;CACpD,MAAM,UAAU,EAAE,QAAQ,YAAY;CACtC,YAAY,iBAAiB,cAAc,QAAQ,OAAO;CAC1D,YAAY,iBAAiB,eAAe,QAAQ,OAAO;CAC3D,YAAY,iBAAiB,eAAe,QAAQ,OAAO;AAC7D;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,uBAAuB,aAA0B,QAAoC;CACnG,IAAI,OAAO,SAAS,OAAO,QAAQ,QAAQ;CAC3C,IAAI,YAAY,eAAe,UAAU,OAAO,QAAQ,QAAQ;CAEhE,OAAO,IAAI,SAAe,YAAY;EACpC,MAAM,aAAa,QAAQ;EAC3B,MAAM,UAAU;GAAE,MAAM;GAAM;EAAO;EACrC,YAAY,iBAAiB,cAAc,MAAM,OAAO;EACxD,YAAY,iBAAiB,eAAe,MAAM,OAAO;EACzD,YAAY,iBAAiB,eAAe,MAAM,OAAO;EACzD,OAAO,iBAAiB,SAAS,MAAM,EAAE,MAAM,KAAK,CAAC;CACvD,CAAC;AACH"}

package/dist/default/media/dom/text/resolve-vtt-segment.js

@@ -1,10 +1,4 @@
 //#region src/media/dom/text/resolve-vtt-segment.ts
-/**
-* Parse a VTT segment using browser's native parser.
-*
-* Creates a dummy video element with a track element to leverage
-* the browser's optimized VTT parsing. Returns parsed VTTCue objects.
-*/
 let dummyVideo = null;
 function ensureDummyVideo() {
 	if (!dummyVideo) {
@@ -20,7 +14,6 @@ function resolveVttSegment(url) {
 	const video = ensureDummyVideo();
 	const track = document.createElement("track");
 	track.kind = "subtitles";
-	track.default = true;
 	return new Promise((resolve, reject) => {
 		const onLoad = () => {
 			const cues = [];
@@ -44,6 +37,7 @@ function resolveVttSegment(url) {
 		track.addEventListener("load", onLoad);
 		track.addEventListener("error", onError);
 		video.appendChild(track);
+		track.track.mode = "hidden";
 		track.src = url;
 	});
 }

package/dist/default/media/dom/text/resolve-vtt-segment.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-vtt-segment.js","names":[],"sources":["../../../../../src/media/dom/text/resolve-vtt-segment.ts"],"sourcesContent":["/**\n * Parse a VTT segment using browser's native parser.\n *\n * Creates a dummy video element with a track element to leverage\n * the browser's optimized VTT parsing. Returns parsed VTTCue objects.\n */\n\n// Singleton dummy video (reused across all parsing)\nlet dummyVideo: HTMLVideoElement | null = null;\n\nfunction ensureDummyVideo(): HTMLVideoElement {\n  if (!dummyVideo) {\n    dummyVideo = document.createElement('video');\n    dummyVideo.muted = true;\n    dummyVideo.preload = 'none';\n    dummyVideo.style.display = 'none';\n    dummyVideo.crossOrigin = 'anonymous';\n  }\n  return dummyVideo;\n}\n\nexport function resolveVttSegment(url: string): Promise<VTTCue[]> {\n  const video = ensureDummyVideo();\n  const track = document.createElement('track');\n  track.kind = 'subtitles';\n  track.default = true;\n\n  return new Promise((resolve, reject) => {\n    const onLoad = (): void => {\n      const cues: VTTCue[] = [];\n      const textTrack = track.track;\n\n      if (textTrack.cues) {\n        for (let i = 0; i < textTrack.cues.length; i++) {\n          const cue = textTrack.cues[i];\n          if (cue) {\n            cues.push(cue as VTTCue);\n          }\n        }\n      }\n\n      cleanup();\n      resolve(cues);\n    };\n\n    const onError = (): void => {\n      cleanup();\n      reject(new Error(`Failed to load VTT segment: ${url}`));\n    };\n\n    const cleanup = (): void => {\n      track.removeEventListener('load', onLoad);\n      track.removeEventListener('error', onError);\n      video.removeChild(track);\n    };\n\n    track.addEventListener('load', onLoad);\n    track.addEventListener('error', onError);\n    video.appendChild(track);\n    track.src = url;\n  });\n}\n\nexport function destroyVttResolver(): void {\n  dummyVideo = null;\n}\n"],"mappings":";;;;;;;AAQA,IAAI,aAAsC;AAE1C,SAAS,mBAAqC;AAC5C,KAAI,CAAC,YAAY;AACf,eAAa,SAAS,cAAc,QAAQ;AAC5C,aAAW,QAAQ;AACnB,aAAW,UAAU;AACrB,aAAW,MAAM,UAAU;AAC3B,aAAW,cAAc;;AAE3B,QAAO;;AAGT,SAAgB,kBAAkB,KAAgC;CAChE,MAAM,QAAQ,kBAAkB;CAChC,MAAM,QAAQ,SAAS,cAAc,QAAQ;AAC7C,OAAM,OAAO;AACb,OAAM,UAAU;AAEhB,QAAO,IAAI,SAAS,SAAS,WAAW;EACtC,MAAM,eAAqB;GACzB,MAAM,OAAiB,EAAE;GACzB,MAAM,YAAY,MAAM;AAExB,OAAI,UAAU,KACZ,MAAK,IAAI,IAAI,GAAG,IAAI,UAAU,KAAK,QAAQ,KAAK;IAC9C,MAAM,MAAM,UAAU,KAAK;AAC3B,QAAI,IACF,MAAK,KAAK,IAAc;;AAK9B,YAAS;AACT,WAAQ,KAAK;;EAGf,MAAM,gBAAsB;AAC1B,YAAS;AACT,0BAAO,IAAI,MAAM,+BAA+B,MAAM,CAAC;;EAGzD,MAAM,gBAAsB;AAC1B,SAAM,oBAAoB,QAAQ,OAAO;AACzC,SAAM,oBAAoB,SAAS,QAAQ;AAC3C,SAAM,YAAY,MAAM;;AAG1B,QAAM,iBAAiB,QAAQ,OAAO;AACtC,QAAM,iBAAiB,SAAS,QAAQ;AACxC,QAAM,YAAY,MAAM;AACxB,QAAM,MAAM;GACZ;;AAGJ,SAAgB,qBAA2B;AACzC,cAAa"}
+{"version":3,"file":"resolve-vtt-segment.js","names":[],"sources":["../../../../../src/media/dom/text/resolve-vtt-segment.ts"],"sourcesContent":["/**\n * Parse a VTT segment using browser's native parser.\n *\n * Creates a dummy video element with a track element to leverage\n * the browser's optimized VTT parsing. Returns parsed VTTCue objects.\n */\n\nimport { resolveVttSegmentMetadata, type TextSegmentMetadata } from '../../text/resolve-vtt-metadata';\n\n// Singleton dummy video (reused across all parsing)\nlet dummyVideo: HTMLVideoElement | null = null;\n\nfunction ensureDummyVideo(): HTMLVideoElement {\n  if (!dummyVideo) {\n    dummyVideo = document.createElement('video');\n    dummyVideo.muted = true;\n    dummyVideo.preload = 'none';\n    dummyVideo.style.display = 'none';\n    dummyVideo.crossOrigin = 'anonymous';\n  }\n  return dummyVideo;\n}\n\nexport function resolveVttSegment(url: string): Promise<VTTCue[]> {\n  const video = ensureDummyVideo();\n  const track = document.createElement('track');\n  track.kind = 'subtitles';\n\n  return new Promise((resolve, reject) => {\n    const onLoad = (): void => {\n      const cues: VTTCue[] = [];\n      const textTrack = track.track;\n\n      if (textTrack.cues) {\n        for (let i = 0; i < textTrack.cues.length; i++) {\n          const cue = textTrack.cues[i];\n          if (cue) {\n            cues.push(cue as VTTCue);\n          }\n        }\n      }\n\n      cleanup();\n      resolve(cues);\n    };\n\n    const onError = (): void => {\n      cleanup();\n      reject(new Error(`Failed to load VTT segment: ${url}`));\n    };\n\n    const cleanup = (): void => {\n      track.removeEventListener('load', onLoad);\n      track.removeEventListener('error', onError);\n      video.removeChild(track);\n    };\n\n    track.addEventListener('load', onLoad);\n    track.addEventListener('error', onError);\n    video.appendChild(track);\n    // Force the browser to load and parse THIS track's resource by activating\n    // it explicitly. Relying on `default = true` only works for the first track\n    // appended to the reused dummy video: the media element's automatic\n    // text-track selection runs once, so on Firefox every subsequent `<track>`\n    // stays inactive, its resource is never fetched, and `load` never fires —\n    // stranding all cues past the first segment. Setting `mode = 'hidden'`\n    // (active but not rendered — this video is never shown) loads each segment\n    // on every browser.\n    track.track.mode = 'hidden';\n    track.src = url;\n  });\n}\n\nexport function destroyVttResolver(): void {\n  dummyVideo = null;\n}\n\n/**\n * A resolved VTT segment paired with its header metadata — the shape used when a\n * caller needs the `X-TIMESTAMP-MAP` correlation (e.g. non-zero-PTS sources),\n * not just the cues.\n */\nexport interface ResolvedVttSegment {\n  cues: VTTCue[];\n  metadata: TextSegmentMetadata;\n}\n\n/**\n * Resolve a VTT segment's cues and header metadata together. Cues still come\n * from the browser's native parser ({@link resolveVttSegment}); the header is\n * scraped in parallel ({@link resolveVttSegmentMetadata}).\n */\nexport function resolveVttSegmentWithMetadata(url: string): Promise<ResolvedVttSegment> {\n  return Promise.all([resolveVttSegment(url), resolveVttSegmentMetadata(url)]).then(([cues, metadata]) => ({\n    cues,\n    metadata,\n  }));\n}\n"],"mappings":";AAUA,IAAI,aAAsC;AAE1C,SAAS,mBAAqC;CAC5C,IAAI,CAAC,YAAY;EACf,aAAa,SAAS,cAAc,OAAO;EAC3C,WAAW,QAAQ;EACnB,WAAW,UAAU;EACrB,WAAW,MAAM,UAAU;EAC3B,WAAW,cAAc;CAC3B;CACA,OAAO;AACT;AAEA,SAAgB,kBAAkB,KAAgC;CAChE,MAAM,QAAQ,iBAAiB;CAC/B,MAAM,QAAQ,SAAS,cAAc,OAAO;CAC5C,MAAM,OAAO;CAEb,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,MAAM,eAAqB;GACzB,MAAM,OAAiB,CAAC;GACxB,MAAM,YAAY,MAAM;GAExB,IAAI,UAAU,MACZ,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,KAAK,QAAQ,KAAK;IAC9C,MAAM,MAAM,UAAU,KAAK;IAC3B,IAAI,KACF,KAAK,KAAK,GAAa;GAE3B;GAGF,QAAQ;GACR,QAAQ,IAAI;EACd;EAEA,MAAM,gBAAsB;GAC1B,QAAQ;GACR,uBAAO,IAAI,MAAM,+BAA+B,KAAK,CAAC;EACxD;EAEA,MAAM,gBAAsB;GAC1B,MAAM,oBAAoB,QAAQ,MAAM;GACxC,MAAM,oBAAoB,SAAS,OAAO;GAC1C,MAAM,YAAY,KAAK;EACzB;EAEA,MAAM,iBAAiB,QAAQ,MAAM;EACrC,MAAM,iBAAiB,SAAS,OAAO;EACvC,MAAM,YAAY,KAAK;EASvB,MAAM,MAAM,OAAO;EACnB,MAAM,MAAM;CACd,CAAC;AACH;AAEA,SAAgB,qBAA2B;CACzC,aAAa;AACf"}

package/dist/default/media/dom/text/text-track-slots.js

@@ -1,3 +1,4 @@
+import { isCaptionOrSubtitleTrack } from "@videojs/utils/dom";
 //#region src/media/dom/text/text-track-slots.ts
 /**
 * SPF-owned `<track>` selector. Each slot created by
@@ -23,7 +24,6 @@ function addSubtitlesTracksToMedia(mediaElement, modelTextTracks) {
 		el.label = modelTrack.label;
 		el.toggleAttribute("data-src-track", true);
 		if (modelTrack.language) el.srclang = modelTrack.language;
-		if (modelTrack.default) el.default = true;
 		mediaElement.appendChild(el);
 	}
 }
@@ -38,7 +38,7 @@ function getShowingSubtitlesTrackFromMedia(mediaElement) {
 	const elements = mediaElement.querySelectorAll(SPF_TRACK_SELECTOR);
 	for (const el of elements) {
 		const track = el.track;
-		if (track.mode === "showing" && (track.kind === "subtitles" || track.kind === "captions")) return track;
+		if (track.mode === "showing" && isCaptionOrSubtitleTrack(track)) return track;
 	}
 }
 /**
@@ -59,7 +59,7 @@ function removeAllSubtitlesTracksFromMedia(mediaElement) {
 function syncTextTrackModes(textTracks, selectedId) {
 	for (let i = 0; i < textTracks.length; i++) {
 		const track = textTracks[i];
-		if (track.kind !== "subtitles" && track.kind !== "captions") continue;
+		if (!isCaptionOrSubtitleTrack(track)) continue;
 		track.mode = track.id === selectedId ? "showing" : "disabled";
 	}
 }