@videojs/spf 10.0.0-beta.1 → 10.0.0-beta.11

package/dist/dev/core/actor.d.ts

@@ -0,0 +1,31 @@
+//#region src/core/actor.d.ts
+/**
+ * Generic actor types.
+ *
+ * An actor owns its snapshot (finite status + non-finite context) and
+ * notifies observers when it changes. Mirrors the XState snapshot model:
+ * `snapshot.status` is the bounded operational mode, `snapshot.context`
+ * holds arbitrary non-finite data.
+ */
+/** Complete actor snapshot: finite status + non-finite context. */
+interface ActorSnapshot<Status extends string, Context> {
+  status: Status;
+  context: Context;
+}
+/** Generic actor interface: owns its snapshot and notifies observers. */
+interface Actor<Status extends string, Context> {
+  /** Current snapshot. */
+  readonly snapshot: ActorSnapshot<Status, Context>;
+  /**
+   * Subscribe to snapshot changes. Fires immediately with the current
+   * snapshot, then on every subsequent change.
+   *
+   * @returns Unsubscribe function.
+   */
+  subscribe(listener: (snapshot: ActorSnapshot<Status, Context>) => void): () => void;
+  /** Tear down the actor. */
+  destroy(): void;
+}
+//#endregion
+export { Actor };
+//# sourceMappingURL=actor.d.ts.map

package/dist/dev/core/actor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actor.d.ts","names":[],"sources":["../../../src/core/actor.ts"],"mappings":";;AAUA;;;;;;;;UAAiB,aAAA;EACf,MAAA,EAAQ,MAAA;EACR,OAAA,EAAS,OAAA;AAAA;AAIX;AAAA,UAAiB,KAAA;EAAK;EAAA,SAEX,QAAA,EAAU,aAAA,CAAc,MAAA,EAAQ,OAAA;EAAA;;;;;;EAQzC,SAAA,CAAU,QAAA,GAAW,QAAA,EAAU,aAAA,CAAc,MAAA,EAAQ,OAAA;EAVhC;EAarB,OAAA;AAAA"}

package/dist/dev/core/buffer/back-buffer.js

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

package/dist/dev/core/buffer/back-buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"back-buffer.js","names":[],"sources":["../../../../src/core/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"}

package/dist/dev/core/buffer/forward-buffer.js

@@ -0,0 +1,73 @@
+//#region src/core/buffer/forward-buffer.ts
+/**
+* Default forward buffer configuration.
+*/
+const DEFAULT_FORWARD_BUFFER_CONFIG = { bufferDuration: 30 };
+/**
+* Get segments that need to be loaded for forward buffer.
+*
+* Determines which segments to load to maintain target buffer duration.
+* Handles discontiguous buffering (gaps after seeks).
+*
+* Algorithm:
+* 1. Calculate target time: currentTime + bufferDuration
+* 2. Find all segments in range [currentTime, targetTime)
+* 3. Filter out segments already buffered at that time position
+* 4. Return segments to load (fills gaps + extends to target)
+*
+* @param segments - All available segments from playlist
+* @param bufferedSegments - Segments already buffered (ordered by startTime)
+* @param currentTime - Current playback position in seconds
+* @param config - Optional forward buffer configuration
+* @returns Array of segments to load (empty if buffer is sufficient)
+*
+* @example
+* // After seek: buffered [0-12, 18-30], playing at 7s
+* const toLoad = getSegmentsToLoad(segments, buffered, 7, { bufferDuration: 24 });
+* // Returns [seg-12, seg-30] (fills gap, extends to target 31s)
+*/
+/**
+* Calculate the start time from which to flush forward buffer content.
+*
+* Content that starts at or beyond `currentTime + bufferDuration` is no
+* longer needed for the current playback position and should be removed
+* from the SourceBuffer. This prevents unbounded accumulation of scattered
+* SourceBuffer content after seeks, which can cause QuotaExceededError on
+* long-form content.
+*
+* Returns `Infinity` when nothing needs flushing (no buffered segments
+* exist beyond the threshold).
+*
+* @param bufferedSegments - Segments currently tracked in the buffer model
+* @param currentTime - Current playback position in seconds
+* @param config - Optional forward buffer configuration
+* @returns Start time to flush from (flush range: [flushStart, Infinity)),
+*          or Infinity if no flush is needed
+*
+* @example
+* // Playing at 0s, buffered [0,6,12,18,24,30,36], bufferDuration=30
+* const flushStart = calculateForwardFlushPoint(segments, 0);
+* // Returns 30 — flush [30, Infinity), keep [0, 30)
+*/
+function calculateForwardFlushPoint(bufferedSegments, currentTime, config = DEFAULT_FORWARD_BUFFER_CONFIG) {
+	if (bufferedSegments.length === 0) return Infinity;
+	const threshold = currentTime + config.bufferDuration;
+	const beyond = bufferedSegments.filter((seg) => seg.startTime >= threshold);
+	if (beyond.length === 0) return Infinity;
+	return Math.min(...beyond.map((seg) => seg.startTime));
+}
+function getSegmentsToLoad(segments, bufferedSegments, currentTime, config = DEFAULT_FORWARD_BUFFER_CONFIG) {
+	if (segments.length === 0) return [];
+	const targetTime = currentTime + config.bufferDuration;
+	const bufferedStartTimes = new Set(bufferedSegments.map((seg) => seg.startTime));
+	return segments.filter((seg) => {
+		const segmentEnd = seg.startTime + seg.duration;
+		const isInRange = seg.startTime < targetTime && segmentEnd > currentTime;
+		const isNotBuffered = !bufferedStartTimes.has(seg.startTime);
+		return isInRange && isNotBuffered;
+	});
+}
+
+//#endregion
+export { DEFAULT_FORWARD_BUFFER_CONFIG, calculateForwardFlushPoint, getSegmentsToLoad };
+//# sourceMappingURL=forward-buffer.js.map

package/dist/dev/core/buffer/forward-buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forward-buffer.js","names":[],"sources":["../../../../src/core/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\nexport function getSegmentsToLoad(\n  segments: readonly Segment[],\n  bufferedSegments: readonly Segment[],\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;;AAGxD,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"}

package/dist/dev/core/events/create-event-stream.d.ts

@@ -0,0 +1,48 @@
+//#region src/core/events/create-event-stream.d.ts
+/**
+ * Minimal event stream with Observable-like shape.
+ *
+ * Simple Subject/Observable-like implementation for dispatching discrete events.
+ * Events are dispatched synchronously to all subscribers.
+ */
+declare const EVENT_STREAM_SYMBOL: unique symbol;
+/**
+ * Event listener function.
+ */
+type EventListener<T extends Pick<Event, 'type'>> = (event: T) => void;
+/**
+ * Event stream interface.
+ */
+interface EventStream<T extends Pick<Event, 'type'> = {
+  type: string;
+}> {
+  [EVENT_STREAM_SYMBOL]: true;
+  dispatch(event: T): void;
+  subscribe(listener: EventListener<T>): () => void;
+}
+/**
+ * Creates a minimal event stream for dispatching discrete events.
+ *
+ * Events are dispatched synchronously to all subscribers.
+ * Conforms to Observable-like shape for future compatibility.
+ *
+ * Events must have a 'type' property for discriminated union type narrowing.
+ *
+ * @example
+ * ```ts
+ * type Action = { type: 'PLAY' } | { type: 'PAUSE' };
+ * const events = createEventStream<Action>();
+ *
+ * events.subscribe((action) => {
+ *   if (action.type === 'PLAY') {
+ *     // Type narrowed to { type: 'PLAY' }
+ *   }
+ * });
+ *
+ * events.dispatch({ type: 'PLAY' });
+ * ```
+ */
+declare function createEventStream<T extends Pick<Event, 'type'>>(): EventStream<T>;
+//#endregion
+export { EventStream, createEventStream };
+//# sourceMappingURL=create-event-stream.d.ts.map

package/dist/dev/core/events/create-event-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-event-stream.d.ts","names":[],"sources":["../../../../src/core/events/create-event-stream.ts"],"mappings":";;;;;;;cAOM,mBAAA;;;;KAKM,aAAA,WAAwB,IAAA,CAAK,KAAA,cAAmB,KAAA,EAAO,CAAA;;;;UAKlD,WAAA,WAAsB,IAAA,CAAK,KAAA;EAAmB,IAAA;AAAA;EAAA,CAC5D,mBAAA;EACD,QAAA,CAAS,KAAA,EAAO,CAAA;EAChB,SAAA,CAAU,QAAA,EAAU,aAAA,CAAc,CAAA;AAAA;AAHpC;;;;;;;;;;;;;;;;;;;;;;AAAA,iBA4BgB,iBAAA,WAA4B,IAAA,CAAK,KAAA,UAAA,CAAA,GAAmB,WAAA,CAAY,CAAA"}

package/dist/dev/core/events/create-event-stream.js

@@ -0,0 +1,48 @@
+//#region src/core/events/create-event-stream.ts
+/**
+* Minimal event stream with Observable-like shape.
+*
+* Simple Subject/Observable-like implementation for dispatching discrete events.
+* Events are dispatched synchronously to all subscribers.
+*/
+const EVENT_STREAM_SYMBOL = Symbol("@videojs/event-stream");
+/**
+* Creates a minimal event stream for dispatching discrete events.
+*
+* Events are dispatched synchronously to all subscribers.
+* Conforms to Observable-like shape for future compatibility.
+*
+* Events must have a 'type' property for discriminated union type narrowing.
+*
+* @example
+* ```ts
+* type Action = { type: 'PLAY' } | { type: 'PAUSE' };
+* const events = createEventStream<Action>();
+*
+* events.subscribe((action) => {
+*   if (action.type === 'PLAY') {
+*     // Type narrowed to { type: 'PLAY' }
+*   }
+* });
+*
+* events.dispatch({ type: 'PLAY' });
+* ```
+*/
+function createEventStream() {
+	const subscribers = /* @__PURE__ */ new Set();
+	return {
+		[EVENT_STREAM_SYMBOL]: true,
+		dispatch(event) {
+			const current = Array.from(subscribers);
+			for (const listener of current) listener(event);
+		},
+		subscribe(listener) {
+			subscribers.add(listener);
+			return () => subscribers.delete(listener);
+		}
+	};
+}
+
+//#endregion
+export { createEventStream };
+//# sourceMappingURL=create-event-stream.js.map

package/dist/dev/core/events/create-event-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-event-stream.js","names":[],"sources":["../../../../src/core/events/create-event-stream.ts"],"sourcesContent":["/**\n * Minimal event stream with Observable-like shape.\n *\n * Simple Subject/Observable-like implementation for dispatching discrete events.\n * Events are dispatched synchronously to all subscribers.\n */\n\nconst EVENT_STREAM_SYMBOL = Symbol('@videojs/event-stream');\n\n/**\n * Event listener function.\n */\nexport type EventListener<T extends Pick<Event, 'type'>> = (event: T) => void;\n\n/**\n * Event stream interface.\n */\nexport interface EventStream<T extends Pick<Event, 'type'> = { type: string }> {\n  [EVENT_STREAM_SYMBOL]: true;\n  dispatch(event: T): void;\n  subscribe(listener: EventListener<T>): () => void;\n}\n\n/**\n * Creates a minimal event stream for dispatching discrete events.\n *\n * Events are dispatched synchronously to all subscribers.\n * Conforms to Observable-like shape for future compatibility.\n *\n * Events must have a 'type' property for discriminated union type narrowing.\n *\n * @example\n * ```ts\n * type Action = { type: 'PLAY' } | { type: 'PAUSE' };\n * const events = createEventStream<Action>();\n *\n * events.subscribe((action) => {\n *   if (action.type === 'PLAY') {\n *     // Type narrowed to { type: 'PLAY' }\n *   }\n * });\n *\n * events.dispatch({ type: 'PLAY' });\n * ```\n */\nexport function createEventStream<T extends Pick<Event, 'type'>>(): EventStream<T> {\n  const subscribers = new Set<EventListener<T>>();\n\n  return {\n    [EVENT_STREAM_SYMBOL]: true,\n\n    dispatch(event: T): void {\n      // Snapshot subscribers to avoid notifying those added during dispatch\n      const current = Array.from(subscribers);\n      for (const listener of current) {\n        listener(event);\n      }\n    },\n\n    subscribe(listener: EventListener<T>): () => void {\n      subscribers.add(listener);\n      return () => subscribers.delete(listener);\n    },\n  };\n}\n\n/**\n * Type guard to check if value is an EventStream.\n */\nexport function isEventStream(value: unknown): value is EventStream {\n  return typeof value === 'object' && value !== null && EVENT_STREAM_SYMBOL in value;\n}\n"],"mappings":";;;;;;;AAOA,MAAM,sBAAsB,OAAO,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;AAsC3D,SAAgB,oBAAmE;CACjF,MAAM,8BAAc,IAAI,KAAuB;AAE/C,QAAO;GACJ,sBAAsB;EAEvB,SAAS,OAAgB;GAEvB,MAAM,UAAU,MAAM,KAAK,YAAY;AACvC,QAAK,MAAM,YAAY,QACrB,UAAS,MAAM;;EAInB,UAAU,UAAwC;AAChD,eAAY,IAAI,SAAS;AACzB,gBAAa,YAAY,OAAO,SAAS;;EAE5C"}

package/dist/dev/core/features/calculate-presentation-duration.js

@@ -0,0 +1,51 @@
+import { isResolvedTrack } from "../types/index.js";
+import { combineLatest } from "../reactive/combine-latest.js";
+import { getSelectedTrack } from "../utils/track-selection.js";
+
+//#region src/core/features/calculate-presentation-duration.ts
+/**
+* Check if we can calculate presentation duration (have required data).
+*/
+function canCalculateDuration(state) {
+	if (!state.presentation) return false;
+	return !!(state.selectedVideoTrackId || state.selectedAudioTrackId);
+}
+/**
+* Check if we should calculate presentation duration (conditions met).
+*/
+function shouldCalculateDuration(state) {
+	if (!canCalculateDuration(state)) return false;
+	const { presentation } = state;
+	if (presentation.duration !== void 0) return false;
+	const videoTrack = state.selectedVideoTrackId ? getSelectedTrack(state, "video") : void 0;
+	const audioTrack = state.selectedAudioTrackId ? getSelectedTrack(state, "audio") : void 0;
+	return !!(videoTrack && isResolvedTrack(videoTrack) || audioTrack && isResolvedTrack(audioTrack));
+}
+/**
+* Get duration from the first resolved track (prefer video, fallback to audio).
+*/
+function getDurationFromResolvedTracks(state) {
+	const videoTrack = state.selectedVideoTrackId ? getSelectedTrack(state, "video") : void 0;
+	if (videoTrack && isResolvedTrack(videoTrack)) return videoTrack.duration;
+	const audioTrack = state.selectedAudioTrackId ? getSelectedTrack(state, "audio") : void 0;
+	if (audioTrack && isResolvedTrack(audioTrack)) return audioTrack.duration;
+}
+/**
+* Calculate and set presentation duration from resolved tracks.
+*/
+function calculatePresentationDuration({ state }) {
+	return combineLatest([state]).subscribe(([currentState]) => {
+		if (!shouldCalculateDuration(currentState)) return;
+		const duration = getDurationFromResolvedTracks(currentState);
+		if (duration === void 0 || !Number.isFinite(duration)) return;
+		const { presentation } = currentState;
+		state.patch({ presentation: {
+			...presentation,
+			duration
+		} });
+	});
+}
+
+//#endregion
+export { calculatePresentationDuration };
+//# sourceMappingURL=calculate-presentation-duration.js.map

package/dist/dev/core/features/calculate-presentation-duration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculate-presentation-duration.js","names":[],"sources":["../../../../src/core/features/calculate-presentation-duration.ts"],"sourcesContent":["import { combineLatest } from '../reactive/combine-latest';\nimport type { WritableState } from '../state/create-state';\nimport type { AudioTrack, Presentation, VideoTrack } from '../types';\nimport { isResolvedTrack } from '../types';\nimport { getSelectedTrack } from '../utils/track-selection';\n\nexport interface PresentationDurationState {\n  presentation?: Presentation;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n}\n\n/**\n * Check if we can calculate presentation duration (have required data).\n */\nexport function canCalculateDuration(state: PresentationDurationState): boolean {\n  if (!state.presentation) return false;\n  // Need at least one selected track\n  return !!(state.selectedVideoTrackId || state.selectedAudioTrackId);\n}\n\n/**\n * Check if we should calculate presentation duration (conditions met).\n */\nexport function shouldCalculateDuration(state: PresentationDurationState): boolean {\n  if (!canCalculateDuration(state)) return false;\n\n  const { presentation } = state;\n\n  // Don't recalculate if already set\n  if (presentation!.duration !== undefined) return false;\n\n  // Check if any selected track is resolved\n  const videoTrack = state.selectedVideoTrackId ? getSelectedTrack(state, 'video') : undefined;\n  const audioTrack = state.selectedAudioTrackId ? getSelectedTrack(state, 'audio') : undefined;\n\n  // At least one track must be resolved (has segments and duration)\n  return !!((videoTrack && isResolvedTrack(videoTrack)) || (audioTrack && isResolvedTrack(audioTrack)));\n}\n\n/**\n * Get duration from the first resolved track (prefer video, fallback to audio).\n */\nexport function getDurationFromResolvedTracks(state: PresentationDurationState): number | undefined {\n  // Try video track first\n  const videoTrack = state.selectedVideoTrackId\n    ? (getSelectedTrack(state, 'video') as VideoTrack | undefined)\n    : undefined;\n  if (videoTrack && isResolvedTrack(videoTrack)) {\n    return videoTrack.duration;\n  }\n\n  // Fallback to audio track\n  const audioTrack = state.selectedAudioTrackId\n    ? (getSelectedTrack(state, 'audio') as AudioTrack | undefined)\n    : undefined;\n  if (audioTrack && isResolvedTrack(audioTrack)) {\n    return audioTrack.duration;\n  }\n\n  return undefined;\n}\n\n/**\n * Calculate and set presentation duration from resolved tracks.\n */\nexport function calculatePresentationDuration({\n  state,\n}: {\n  state: WritableState<PresentationDurationState>;\n}): () => void {\n  return combineLatest([state]).subscribe(([currentState]: [PresentationDurationState]) => {\n    if (!shouldCalculateDuration(currentState)) return;\n\n    const duration = getDurationFromResolvedTracks(currentState);\n    if (duration === undefined || !Number.isFinite(duration)) return;\n\n    const { presentation } = currentState;\n\n    // Patch presentation with duration\n    state.patch({\n      presentation: {\n        ...presentation!,\n        duration,\n      },\n    });\n  });\n}\n"],"mappings":";;;;;;;;AAeA,SAAgB,qBAAqB,OAA2C;AAC9E,KAAI,CAAC,MAAM,aAAc,QAAO;AAEhC,QAAO,CAAC,EAAE,MAAM,wBAAwB,MAAM;;;;;AAMhD,SAAgB,wBAAwB,OAA2C;AACjF,KAAI,CAAC,qBAAqB,MAAM,CAAE,QAAO;CAEzC,MAAM,EAAE,iBAAiB;AAGzB,KAAI,aAAc,aAAa,OAAW,QAAO;CAGjD,MAAM,aAAa,MAAM,uBAAuB,iBAAiB,OAAO,QAAQ,GAAG;CACnF,MAAM,aAAa,MAAM,uBAAuB,iBAAiB,OAAO,QAAQ,GAAG;AAGnF,QAAO,CAAC,EAAG,cAAc,gBAAgB,WAAW,IAAM,cAAc,gBAAgB,WAAW;;;;;AAMrG,SAAgB,8BAA8B,OAAsD;CAElG,MAAM,aAAa,MAAM,uBACpB,iBAAiB,OAAO,QAAQ,GACjC;AACJ,KAAI,cAAc,gBAAgB,WAAW,CAC3C,QAAO,WAAW;CAIpB,MAAM,aAAa,MAAM,uBACpB,iBAAiB,OAAO,QAAQ,GACjC;AACJ,KAAI,cAAc,gBAAgB,WAAW,CAC3C,QAAO,WAAW;;;;;AAStB,SAAgB,8BAA8B,EAC5C,SAGa;AACb,QAAO,cAAc,CAAC,MAAM,CAAC,CAAC,WAAW,CAAC,kBAA+C;AACvF,MAAI,CAAC,wBAAwB,aAAa,CAAE;EAE5C,MAAM,WAAW,8BAA8B,aAAa;AAC5D,MAAI,aAAa,UAAa,CAAC,OAAO,SAAS,SAAS,CAAE;EAE1D,MAAM,EAAE,iBAAiB;AAGzB,QAAM,MAAM,EACV,cAAc;GACZ,GAAG;GACH;GACD,EACF,CAAC;GACF"}

package/dist/dev/core/features/quality-switching.js

@@ -0,0 +1,68 @@
+import { getBandwidthEstimate } from "../abr/bandwidth-estimator.js";
+import { selectQuality } from "../abr/quality-selection.js";
+
+//#region src/core/features/quality-switching.ts
+/**
+* Default quality switching configuration.
+*/
+const DEFAULT_SWITCHING_CONFIG = {
+	safetyMargin: .85,
+	minUpgradeInterval: 8e3,
+	defaultBandwidth: 5e6
+};
+/**
+* Get all video tracks from a presentation's first switching set.
+* Returns [] when the presentation is still unresolved (no selectionSets yet).
+*/
+function getVideoTracks(presentation) {
+	return (presentation.selectionSets?.find((s) => s.type === "video"))?.switchingSets[0]?.tracks ?? [];
+}
+/**
+* Quality switching orchestration (F9).
+*
+* Reacts to bandwidth estimate changes and updates `selectedVideoTrackId`
+* when a different quality is optimal:
+*
+* - **Downgrades** happen immediately to avoid buffering stalls.
+* - **Upgrades** are gated by `minUpgradeInterval` to prevent oscillation.
+* - The first switch (from any track, or no track) is always immediate.
+*
+* Smooth switching is handled downstream: when `selectedVideoTrackId` changes,
+* `resolveTrack` fetches the new playlist and `loadSegments` reloads the init
+* segment, then appends media segments from the current position in the new
+* quality. The browser's SourceBuffer replaces the overlapping buffered range.
+*
+* @example
+* const cleanup = switchQuality({ state });
+* // Later, when done:
+* cleanup();
+*/
+function switchQuality({ state }, config = {}) {
+	const safetyMargin = config.safetyMargin ?? DEFAULT_SWITCHING_CONFIG.safetyMargin;
+	const minUpgradeInterval = config.minUpgradeInterval ?? DEFAULT_SWITCHING_CONFIG.minUpgradeInterval;
+	const defaultBandwidth = config.defaultBandwidth ?? DEFAULT_SWITCHING_CONFIG.defaultBandwidth;
+	let lastUpgradeTime = Date.now();
+	let firstMeaningfulFire = true;
+	return state.subscribe((currentState) => {
+		const { presentation, bandwidthState, selectedVideoTrackId, abrDisabled } = currentState;
+		if (abrDisabled === true) return;
+		if (!presentation || !bandwidthState) return;
+		const videoTracks = getVideoTracks(presentation);
+		if (videoTracks.length === 0) return;
+		const isFirst = firstMeaningfulFire;
+		firstMeaningfulFire = false;
+		const optimal = selectQuality(videoTracks, getBandwidthEstimate(bandwidthState, defaultBandwidth), { safetyMargin });
+		if (!optimal || optimal.id === selectedVideoTrackId) return;
+		const currentTrack = videoTracks.find((t) => t.id === selectedVideoTrackId);
+		if (!currentTrack || optimal.bandwidth > currentTrack.bandwidth) {
+			const now = Date.now();
+			if (!isFirst && now - lastUpgradeTime < minUpgradeInterval) return;
+			lastUpgradeTime = now;
+		}
+		state.patch({ selectedVideoTrackId: optimal.id });
+	});
+}
+
+//#endregion
+export { DEFAULT_SWITCHING_CONFIG, switchQuality };
+//# sourceMappingURL=quality-switching.js.map

package/dist/dev/core/features/quality-switching.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality-switching.js","names":[],"sources":["../../../../src/core/features/quality-switching.ts"],"sourcesContent":["import type { BandwidthState } from '../abr/bandwidth-estimator';\nimport { getBandwidthEstimate } from '../abr/bandwidth-estimator';\nimport { selectQuality } from '../abr/quality-selection';\nimport type { WritableState } from '../state/create-state';\nimport type { Presentation, VideoSelectionSet } from '../types';\n\n/**\n * State shape for quality switching.\n */\nexport interface QualitySwitchingState {\n  presentation?: Presentation;\n  bandwidthState?: BandwidthState;\n  selectedVideoTrackId?: string;\n  // TODO: abrDisabled is a blunt instrument — it requires callers to know they're\n  // competing with ABR and explicitly opt out. A better long-term design would\n  // separate ABR selection (abrVideoTrackId) from manual selection (manualVideoTrackId)\n  // and derive the effective selectedVideoTrackId as manualVideoTrackId ?? abrVideoTrackId.\n  // That way the two concerns never write to the same field and consumers are unchanged.\n  /** When true, ABR quality switching is suppressed. Use for manual quality selection. */\n  abrDisabled?: boolean;\n}\n\n/**\n * Configuration for quality switching behavior.\n */\nexport interface QualitySwitchingConfig {\n  /**\n   * Safety margin for quality selection (0–1).\n   * Track is selected only when bandwidth >= track.bandwidth / safetyMargin.\n   * Default: 0.85 (15% headroom).\n   */\n  safetyMargin?: number;\n\n  /**\n   * Minimum milliseconds between upgrades.\n   * Prevents oscillation when bandwidth fluctuates around a quality threshold.\n   * Downgrades are always immediate regardless of this setting.\n   * Default: 8000 (8 seconds).\n   */\n  minUpgradeInterval?: number;\n\n  /**\n   * Bandwidth estimate in bps to use before enough samples have been collected.\n   * Default: 5_000_000 (5 Mbps).\n   */\n  defaultBandwidth?: number;\n}\n\n/**\n * Default quality switching configuration.\n */\nexport const DEFAULT_SWITCHING_CONFIG: Required<QualitySwitchingConfig> = {\n  safetyMargin: 0.85,\n  minUpgradeInterval: 8000,\n  defaultBandwidth: 5_000_000,\n};\n\n/**\n * Get all video tracks from a presentation's first switching set.\n * Returns [] when the presentation is still unresolved (no selectionSets yet).\n */\nfunction getVideoTracks(presentation: Presentation) {\n  const videoSet = presentation.selectionSets?.find((s) => s.type === 'video') as VideoSelectionSet | undefined;\n  return videoSet?.switchingSets[0]?.tracks ?? [];\n}\n\n/**\n * Quality switching orchestration (F9).\n *\n * Reacts to bandwidth estimate changes and updates `selectedVideoTrackId`\n * when a different quality is optimal:\n *\n * - **Downgrades** happen immediately to avoid buffering stalls.\n * - **Upgrades** are gated by `minUpgradeInterval` to prevent oscillation.\n * - The first switch (from any track, or no track) is always immediate.\n *\n * Smooth switching is handled downstream: when `selectedVideoTrackId` changes,\n * `resolveTrack` fetches the new playlist and `loadSegments` reloads the init\n * segment, then appends media segments from the current position in the new\n * quality. The browser's SourceBuffer replaces the overlapping buffered range.\n *\n * @example\n * const cleanup = switchQuality({ state });\n * // Later, when done:\n * cleanup();\n */\nexport function switchQuality(\n  { state }: { state: WritableState<QualitySwitchingState> },\n  config: QualitySwitchingConfig = {}\n): () => void {\n  const safetyMargin = config.safetyMargin ?? DEFAULT_SWITCHING_CONFIG.safetyMargin;\n  const minUpgradeInterval = config.minUpgradeInterval ?? DEFAULT_SWITCHING_CONFIG.minUpgradeInterval;\n  const defaultBandwidth = config.defaultBandwidth ?? DEFAULT_SWITCHING_CONFIG.defaultBandwidth;\n\n  // Initialize to creation time so the interval starts counting immediately.\n  // The first time we have enough data to make a meaningful quality decision\n  // (presentation resolved + bandwidth available), the upgrade gate is skipped\n  // so the initial ABR correction does not wait for minUpgradeInterval.\n  let lastUpgradeTime = Date.now();\n  let firstMeaningfulFire = true;\n\n  return state.subscribe((currentState: QualitySwitchingState) => {\n    const { presentation, bandwidthState, selectedVideoTrackId, abrDisabled } = currentState;\n\n    if (abrDisabled === true) return;\n    if (!presentation || !bandwidthState) return;\n\n    const videoTracks = getVideoTracks(presentation);\n    if (videoTracks.length === 0) return;\n\n    // Consume the first-meaningful-fire flag now that we have all required data.\n    const isFirst = firstMeaningfulFire;\n    firstMeaningfulFire = false;\n\n    const bandwidth = getBandwidthEstimate(bandwidthState, defaultBandwidth);\n    const optimal = selectQuality(videoTracks as any, bandwidth, { safetyMargin });\n    if (!optimal || optimal.id === selectedVideoTrackId) return;\n\n    // Determine whether this is an upgrade or downgrade.\n    const currentTrack = videoTracks.find((t) => t.id === selectedVideoTrackId);\n    const isUpgrade = !currentTrack || optimal.bandwidth > currentTrack.bandwidth;\n\n    if (isUpgrade) {\n      const now = Date.now();\n      // Gate upgrades with minUpgradeInterval to prevent oscillation.\n      // Downgrades are always immediate; the first meaningful evaluation is always allowed.\n      if (!isFirst && now - lastUpgradeTime < minUpgradeInterval) return;\n      lastUpgradeTime = now;\n    }\n\n    state.patch({ selectedVideoTrackId: optimal.id });\n  });\n}\n"],"mappings":";;;;;;;AAmDA,MAAa,2BAA6D;CACxE,cAAc;CACd,oBAAoB;CACpB,kBAAkB;CACnB;;;;;AAMD,SAAS,eAAe,cAA4B;AAElD,SADiB,aAAa,eAAe,MAAM,MAAM,EAAE,SAAS,QAAQ,GAC3D,cAAc,IAAI,UAAU,EAAE;;;;;;;;;;;;;;;;;;;;;;AAuBjD,SAAgB,cACd,EAAE,SACF,SAAiC,EAAE,EACvB;CACZ,MAAM,eAAe,OAAO,gBAAgB,yBAAyB;CACrE,MAAM,qBAAqB,OAAO,sBAAsB,yBAAyB;CACjF,MAAM,mBAAmB,OAAO,oBAAoB,yBAAyB;CAM7E,IAAI,kBAAkB,KAAK,KAAK;CAChC,IAAI,sBAAsB;AAE1B,QAAO,MAAM,WAAW,iBAAwC;EAC9D,MAAM,EAAE,cAAc,gBAAgB,sBAAsB,gBAAgB;AAE5E,MAAI,gBAAgB,KAAM;AAC1B,MAAI,CAAC,gBAAgB,CAAC,eAAgB;EAEtC,MAAM,cAAc,eAAe,aAAa;AAChD,MAAI,YAAY,WAAW,EAAG;EAG9B,MAAM,UAAU;AAChB,wBAAsB;EAGtB,MAAM,UAAU,cAAc,aADZ,qBAAqB,gBAAgB,iBAAiB,EACX,EAAE,cAAc,CAAC;AAC9E,MAAI,CAAC,WAAW,QAAQ,OAAO,qBAAsB;EAGrD,MAAM,eAAe,YAAY,MAAM,MAAM,EAAE,OAAO,qBAAqB;AAG3E,MAFkB,CAAC,gBAAgB,QAAQ,YAAY,aAAa,WAErD;GACb,MAAM,MAAM,KAAK,KAAK;AAGtB,OAAI,CAAC,WAAW,MAAM,kBAAkB,mBAAoB;AAC5D,qBAAkB;;AAGpB,QAAM,MAAM,EAAE,sBAAsB,QAAQ,IAAI,CAAC;GACjD"}

package/dist/dev/core/features/resolve-presentation.d.ts

@@ -0,0 +1,16 @@
+//#region src/core/features/resolve-presentation.d.ts
+/**
+ * Action types for presentation resolution.
+ * Event names match HTMLMediaElement events (lowercase).
+ */
+type PresentationAction = {
+  type: 'play';
+} | {
+  type: 'pause';
+} | {
+  type: 'load';
+  url: string;
+};
+//#endregion
+export { PresentationAction };
+//# sourceMappingURL=resolve-presentation.d.ts.map

package/dist/dev/core/features/resolve-presentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-presentation.d.ts","names":[],"sources":["../../../../src/core/features/resolve-presentation.ts"],"mappings":";;;;;KA2FY,kBAAA;EAAuB,IAAA;AAAA;EAAmB,IAAA;AAAA;EAAoB,IAAA;EAAc,GAAA;AAAA"}

package/dist/dev/core/features/resolve-presentation.js

@@ -0,0 +1,99 @@
+import { parseMultivariantPlaylist } from "../hls/parse-multivariant.js";
+import { fetchResolvable, getResponseText } from "../../dom/network/fetch.js";
+import { combineLatest } from "../reactive/combine-latest.js";
+
+//#region src/core/features/resolve-presentation.ts
+/**
+* Type guard to check if presentation is unresolved.
+*/
+function isUnresolved(presentation) {
+	return presentation !== void 0 && "url" in presentation && !("id" in presentation);
+}
+function canResolve(state) {
+	return isUnresolved(state.presentation);
+}
+/**
+* Determines if resolution conditions are met based on preload policy and event.
+*
+* Resolution conditions:
+* - State-driven: preload is 'auto' or 'metadata'
+* - Event-driven: play event
+*
+* @param state - Current presentation state
+* @param event - Current action/event
+* @returns true if resolution conditions are met
+*/
+function shouldResolve(state, event) {
+	const { preload } = state;
+	return ["auto", "metadata"].includes(preload) || event.type === "play";
+}
+/**
+* Syncs preload attribute from mediaElement to state.
+*
+* Watches the owners state for mediaElement changes and copies the
+* preload attribute to the immutable state.
+*
+* @param state - Immutable state container
+* @param owners - Mutable platform objects container
+* @returns Cleanup function to stop syncing
+*/
+function syncPreloadAttribute(state, owners) {
+	return owners.subscribe((current) => {
+		if (state.current.preload !== void 0) return;
+		const preload = current.mediaElement?.preload || void 0;
+		state.patch({ preload });
+	});
+}
+/**
+* Resolves unresolved presentations using reactive composition.
+*
+* Uses combineLatest to compose state + events, enabling both state-driven
+* and event-driven resolution triggers.
+*
+* Triggers resolution when:
+* - State-driven: Unresolved presentation + preload allows (auto/metadata)
+* - Event-driven: PLAY event when preload="none"
+*
+* @example
+* ```ts
+* const state = createState({ presentation: undefined, preload: 'auto' });
+* const events = createEventStream<PresentationAction>();
+*
+* const cleanup = resolvePresentation({ state, events });
+*
+* // State-driven: resolves immediately when preload allows
+* state.patch({ presentation: { url: 'http://example.com/playlist.m3u8' } });
+*
+* // Event-driven: resolves on PLAY when preload="none"
+* state.patch({ preload: 'none', presentation: { url: '...' } });
+* events.dispatch({ type: 'PLAY' });
+* ```
+*/
+function resolvePresentation({ state, events }) {
+	let resolving = false;
+	let abortController = null;
+	const cleanup = combineLatest([state, events]).subscribe(async ([currentState, event]) => {
+		if (!canResolve(currentState) || !shouldResolve(currentState, event) || resolving) return;
+		try {
+			resolving = true;
+			abortController = new AbortController();
+			const { presentation } = currentState;
+			const parsed = parseMultivariantPlaylist(await getResponseText(await fetchResolvable(presentation, { signal: abortController.signal })), presentation);
+			state.patch({ presentation: parsed });
+		} catch (error) {
+			if (error instanceof Error && error.name === "AbortError") return;
+			throw error;
+		} finally {
+			resolving = false;
+			abortController = null;
+		}
+	});
+	return () => {
+		abortController?.abort();
+		cleanup();
+	};
+}
+
+//#endregion
+export { canResolve, isUnresolved, resolvePresentation, shouldResolve, syncPreloadAttribute };
+//# sourceMappingURL=resolve-presentation.js.map

package/dist/dev/core/features/resolve-presentation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-presentation.js","names":[],"sources":["../../../../src/core/features/resolve-presentation.ts"],"sourcesContent":["import { fetchResolvable, getResponseText } from '../../dom/network/fetch';\nimport type { EventStream } from '../events/create-event-stream';\nimport { parseMultivariantPlaylist } from '../hls/parse-multivariant';\nimport { combineLatest } from '../reactive/combine-latest';\nimport type { WritableState } from '../state/create-state';\nimport type { AddressableObject, MediaElementLike, Presentation } from '../types';\n\n/**\n * Unresolved presentation - has a URL but no data yet.\n * Identical to AddressableObject per user requirement.\n */\nexport type UnresolvedPresentation = AddressableObject;\n\n/**\n * State shape for presentation resolution.\n */\nexport interface PresentationState {\n  presentation?: UnresolvedPresentation | Presentation | undefined;\n  preload?: 'auto' | 'metadata' | 'none' | undefined;\n}\n\n/**\n * Mutable platform objects.\n */\nexport interface PlatformOwners {\n  mediaElement?: MediaElementLike | undefined;\n}\n\n/**\n * Type guard to check if presentation is unresolved.\n */\nexport function isUnresolved(\n  presentation: UnresolvedPresentation | Presentation | undefined\n): presentation is UnresolvedPresentation {\n  return presentation !== undefined && 'url' in presentation && !('id' in presentation);\n}\n\nexport function canResolve(\n  state: PresentationState\n): state is PresentationState & { presentation: UnresolvedPresentation } {\n  return isUnresolved(state.presentation);\n}\n\n/**\n * Determines if resolution conditions are met based on preload policy and event.\n *\n * Resolution conditions:\n * - State-driven: preload is 'auto' or 'metadata'\n * - Event-driven: play event\n *\n * @param state - Current presentation state\n * @param event - Current action/event\n * @returns true if resolution conditions are met\n */\nexport function shouldResolve(state: PresentationState, event: PresentationAction): boolean {\n  const { preload } = state;\n  return (\n    // State-driven: preload allows (auto/metadata)\n    ['auto', 'metadata'].includes(preload as any) ||\n    // Event-driven: play event\n    event.type === 'play'\n  );\n}\n\n/**\n * Syncs preload attribute from mediaElement to state.\n *\n * Watches the owners state for mediaElement changes and copies the\n * preload attribute to the immutable state.\n *\n * @param state - Immutable state container\n * @param owners - Mutable platform objects container\n * @returns Cleanup function to stop syncing\n */\nexport function syncPreloadAttribute(\n  state: WritableState<PresentationState>,\n  owners: WritableState<PlatformOwners>\n): () => void {\n  return owners.subscribe((current) => {\n    // Only infer preload from the element when no explicit value has been set.\n    // An explicit value (set via SpfMedia.preload) always wins.\n    if (state.current.preload !== undefined) return;\n    const preload = current.mediaElement?.preload || undefined;\n    state.patch({ preload: preload as 'auto' | 'metadata' | 'none' | undefined });\n  });\n}\n\n/**\n * Action types for presentation resolution.\n * Event names match HTMLMediaElement events (lowercase).\n */\nexport type PresentationAction = { type: 'play' } | { type: 'pause' } | { type: 'load'; url: string };\n\n/**\n * Resolves unresolved presentations using reactive composition.\n *\n * Uses combineLatest to compose state + events, enabling both state-driven\n * and event-driven resolution triggers.\n *\n * Triggers resolution when:\n * - State-driven: Unresolved presentation + preload allows (auto/metadata)\n * - Event-driven: PLAY event when preload=\"none\"\n *\n * @example\n * ```ts\n * const state = createState({ presentation: undefined, preload: 'auto' });\n * const events = createEventStream<PresentationAction>();\n *\n * const cleanup = resolvePresentation({ state, events });\n *\n * // State-driven: resolves immediately when preload allows\n * state.patch({ presentation: { url: 'http://example.com/playlist.m3u8' } });\n *\n * // Event-driven: resolves on PLAY when preload=\"none\"\n * state.patch({ preload: 'none', presentation: { url: '...' } });\n * events.dispatch({ type: 'PLAY' });\n * ```\n */\nexport function resolvePresentation({\n  state,\n  events,\n}: {\n  state: WritableState<PresentationState>;\n  events: EventStream<PresentationAction>;\n}): () => void {\n  // This is effectively a very simple finite state model. We can formalize this if needed.\n  let resolving = false;\n  let abortController: AbortController | null = null;\n\n  const cleanup = combineLatest([state, events]).subscribe(async ([currentState, event]) => {\n    if (!canResolve(currentState) || !shouldResolve(currentState, event) || resolving) return;\n\n    try {\n      // This along with the resolving finite state (or more complex) could be pulled into its own abstraction.\n      // Set flag before async work\n      resolving = true;\n      abortController = new AbortController();\n\n      const { presentation } = currentState;\n      // Fetch and parse playlist\n      const response = await fetchResolvable(presentation, { signal: abortController.signal });\n      const text = await getResponseText(response);\n      const parsed = parseMultivariantPlaylist(text, presentation);\n\n      // Update state with resolved presentation\n      state.patch({\n        presentation: parsed,\n      });\n    } catch (error) {\n      // Ignore AbortError - this is expected when cleanup happens\n      if (error instanceof Error && error.name === 'AbortError') {\n        return;\n      }\n      throw error;\n    } finally {\n      // Always clear flag\n      resolving = false;\n      abortController = null;\n    }\n  });\n\n  // Return cleanup function that aborts pending fetches\n  return () => {\n    abortController?.abort();\n    cleanup();\n  };\n}\n"],"mappings":";;;;;;;;AA+BA,SAAgB,aACd,cACwC;AACxC,QAAO,iBAAiB,UAAa,SAAS,gBAAgB,EAAE,QAAQ;;AAG1E,SAAgB,WACd,OACuE;AACvE,QAAO,aAAa,MAAM,aAAa;;;;;;;;;;;;;AAczC,SAAgB,cAAc,OAA0B,OAAoC;CAC1F,MAAM,EAAE,YAAY;AACpB,QAEE,CAAC,QAAQ,WAAW,CAAC,SAAS,QAAe,IAE7C,MAAM,SAAS;;;;;;;;;;;;AAcnB,SAAgB,qBACd,OACA,QACY;AACZ,QAAO,OAAO,WAAW,YAAY;AAGnC,MAAI,MAAM,QAAQ,YAAY,OAAW;EACzC,MAAM,UAAU,QAAQ,cAAc,WAAW;AACjD,QAAM,MAAM,EAAW,SAAqD,CAAC;GAC7E;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCJ,SAAgB,oBAAoB,EAClC,OACA,UAIa;CAEb,IAAI,YAAY;CAChB,IAAI,kBAA0C;CAE9C,MAAM,UAAU,cAAc,CAAC,OAAO,OAAO,CAAC,CAAC,UAAU,OAAO,CAAC,cAAc,WAAW;AACxF,MAAI,CAAC,WAAW,aAAa,IAAI,CAAC,cAAc,cAAc,MAAM,IAAI,UAAW;AAEnF,MAAI;AAGF,eAAY;AACZ,qBAAkB,IAAI,iBAAiB;GAEvC,MAAM,EAAE,iBAAiB;GAIzB,MAAM,SAAS,0BADF,MAAM,gBADF,MAAM,gBAAgB,cAAc,EAAE,QAAQ,gBAAgB,QAAQ,CAAC,CAC5C,EACG,aAAa;AAG5D,SAAM,MAAM,EACV,cAAc,QACf,CAAC;WACK,OAAO;AAEd,OAAI,iBAAiB,SAAS,MAAM,SAAS,aAC3C;AAEF,SAAM;YACE;AAER,eAAY;AACZ,qBAAkB;;GAEpB;AAGF,cAAa;AACX,mBAAiB,OAAO;AACxB,WAAS"}

package/dist/dev/core/features/resolve-track.d.ts

@@ -0,0 +1,13 @@
+//#region src/core/features/resolve-track.d.ts
+/**
+ * Action types for track resolution.
+ * Event names match HTMLMediaElement events (lowercase).
+ */
+type TrackResolutionAction = {
+  type: 'play';
+} | {
+  type: 'pause';
+};
+//#endregion
+export { TrackResolutionAction };
+//# sourceMappingURL=resolve-track.d.ts.map

package/dist/dev/core/features/resolve-track.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-track.d.ts","names":[],"sources":["../../../../src/core/features/resolve-track.ts"],"mappings":";;;;;KAyEY,qBAAA;EAA0B,IAAA;AAAA;EAAmB,IAAA;AAAA"}