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

package/dist/dev/dom/playback-engine/adapter.js

@@ -0,0 +1,95 @@
+import { createPlaybackEngine } from "./engine.js";
+
+//#region src/dom/playback-engine/adapter.ts
+/**
+* HTMLMediaElement-compatible adapter for the SPF playback engine.
+*
+* Implements the src/play() contract per the WHATWG HTML spec so that SPF can
+* be used anywhere a media element API is expected.
+*
+* A new engine is created on every src assignment — this fully tears down all
+* state, SourceBuffers, and in-flight requests from the previous source before
+* the next one begins. The media element reference is preserved across src
+* changes and re-applied to the new engine automatically.
+*
+* @example
+* const media = new SpfMedia({ preferredAudioLanguage: 'en' });
+* media.attach(document.querySelector('video'));
+* media.src = 'https://stream.mux.com/abc123.m3u8';
+*
+* // Change source — old engine is destroyed, new one starts clean:
+* media.src = 'https://stream.mux.com/xyz456.m3u8';
+*
+* // Explicit teardown:
+* media.destroy();
+*/
+var SpfMedia = class {
+	#engine;
+	#config;
+	#preload = "";
+	/** Pending loadstart listener from a deferred play() retry, if any. */
+	#loadstartListener = null;
+	constructor(config = {}) {
+		this.#config = config;
+		this.#engine = createPlaybackEngine(config);
+	}
+	get engine() {
+		return this.#engine;
+	}
+	attach(mediaElement) {
+		this.#engine.owners.patch({ mediaElement });
+	}
+	detach() {
+		this.#cancelPendingPlay();
+		this.#engine.owners.patch({ mediaElement: void 0 });
+	}
+	destroy() {
+		this.#cancelPendingPlay();
+		this.#engine.destroy();
+	}
+	get preload() {
+		return this.#preload;
+	}
+	set preload(value) {
+		this.#preload = value;
+		if (value) this.#engine.state.patch({ preload: value });
+	}
+	get src() {
+		return this.#engine.state.current.presentation?.url ?? "";
+	}
+	set src(value) {
+		const prevMediaElement = this.#engine.owners.current.mediaElement;
+		this.#cancelPendingPlay();
+		this.#engine.destroy();
+		this.#engine = createPlaybackEngine(this.#config);
+		if (this.#preload) this.#engine.state.patch({ preload: this.#preload });
+		if (prevMediaElement) this.#engine.owners.patch({ mediaElement: prevMediaElement });
+		if (value) this.#engine.state.patch({ presentation: { url: value } });
+	}
+	play() {
+		const { mediaElement } = this.#engine.owners.current;
+		if (!mediaElement) return Promise.reject(/* @__PURE__ */ new Error("SpfMedia: no media element attached"));
+		this.#engine.state.patch({ playbackInitiated: true });
+		return mediaElement.play().catch((err) => {
+			if (this.src) return new Promise((resolve, reject) => {
+				const listener = () => {
+					this.#loadstartListener = null;
+					mediaElement.play().then(resolve, reject);
+				};
+				this.#loadstartListener = listener;
+				mediaElement.addEventListener("loadstart", listener, { once: true });
+			});
+			throw err;
+		});
+	}
+	#cancelPendingPlay() {
+		if (!this.#loadstartListener) return;
+		const { mediaElement } = this.#engine.owners.current;
+		mediaElement?.removeEventListener("loadstart", this.#loadstartListener);
+		this.#loadstartListener = null;
+	}
+};
+
+//#endregion
+export { SpfMedia };
+//# sourceMappingURL=adapter.js.map

package/dist/dev/dom/playback-engine/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","names":["#config","#engine","#cancelPendingPlay","#preload","#loadstartListener"],"sources":["../../../../src/dom/playback-engine/adapter.ts"],"sourcesContent":["import type { PlaybackEngineConfig } from './engine';\nimport { createPlaybackEngine, type PlaybackEngine } from './engine';\n\n/**\n * HTMLMediaElement-compatible adapter for the SPF playback engine.\n *\n * Implements the src/play() contract per the WHATWG HTML spec so that SPF can\n * be used anywhere a media element API is expected.\n *\n * A new engine is created on every src assignment — this fully tears down all\n * state, SourceBuffers, and in-flight requests from the previous source before\n * the next one begins. The media element reference is preserved across src\n * changes and re-applied to the new engine automatically.\n *\n * @example\n * const media = new SpfMedia({ preferredAudioLanguage: 'en' });\n * media.attach(document.querySelector('video'));\n * media.src = 'https://stream.mux.com/abc123.m3u8';\n *\n * // Change source — old engine is destroyed, new one starts clean:\n * media.src = 'https://stream.mux.com/xyz456.m3u8';\n *\n * // Explicit teardown:\n * media.destroy();\n */\nexport class SpfMedia {\n  #engine: PlaybackEngine;\n  #config: PlaybackEngineConfig;\n  #preload: '' | 'none' | 'metadata' | 'auto' = '';\n\n  /** Pending loadstart listener from a deferred play() retry, if any. */\n  #loadstartListener: (() => void) | null = null;\n\n  constructor(config: PlaybackEngineConfig = {}) {\n    this.#config = config;\n    this.#engine = createPlaybackEngine(config);\n  }\n\n  get engine(): PlaybackEngine {\n    return this.#engine;\n  }\n\n  // ---------------------------------------------------------------------------\n  // Media element lifecycle\n  // ---------------------------------------------------------------------------\n\n  attach(mediaElement: HTMLMediaElement): void {\n    this.#engine.owners.patch({ mediaElement });\n  }\n\n  detach(): void {\n    this.#cancelPendingPlay();\n    this.#engine.owners.patch({ mediaElement: undefined });\n  }\n\n  destroy(): void {\n    this.#cancelPendingPlay();\n    this.#engine.destroy();\n  }\n\n  // ---------------------------------------------------------------------------\n  // preload — synchronous IDL attribute (WHATWG §4.8.11.2)\n  // ---------------------------------------------------------------------------\n\n  get preload(): '' | 'none' | 'metadata' | 'auto' {\n    return this.#preload;\n  }\n\n  set preload(value: '' | 'none' | 'metadata' | 'auto') {\n    this.#preload = value;\n    if (value) {\n      this.#engine.state.patch({ preload: value });\n    }\n    // value = '' clears #preload (so the next engine recreation won't re-apply\n    // an explicit value) but does not patch current state — the existing preload\n    // stays in effect until the next src change creates a fresh engine.\n  }\n\n  // ---------------------------------------------------------------------------\n  // src — synchronous IDL attribute (WHATWG §4.8.11.2)\n  // Each assignment destroys the current engine and starts a fresh one, exactly\n  // as the browser's load algorithm resets all media element state on src change.\n  // ---------------------------------------------------------------------------\n\n  get src(): string {\n    return this.#engine.state.current.presentation?.url ?? '';\n  }\n\n  set src(value: string) {\n    const prevMediaElement = this.#engine.owners.current.mediaElement;\n\n    this.#cancelPendingPlay();\n    this.#engine.destroy();\n    this.#engine = createPlaybackEngine(this.#config);\n\n    // Apply explicit preload before owners.patch so syncPreloadAttribute skips\n    // element inference and the explicit value is preserved across src changes.\n    if (this.#preload) {\n      this.#engine.state.patch({ preload: this.#preload });\n    }\n\n    if (prevMediaElement) {\n      this.#engine.owners.patch({ mediaElement: prevMediaElement });\n    }\n\n    if (value) {\n      this.#engine.state.patch({ presentation: { url: value } });\n    }\n  }\n\n  // ---------------------------------------------------------------------------\n  // play() — WHATWG §4.8.11.8\n  // Delegates to the attached media element's native play().\n  // ---------------------------------------------------------------------------\n\n  play(): Promise<void> {\n    const { mediaElement } = this.#engine.owners.current;\n    if (!mediaElement) {\n      return Promise.reject(new Error('SpfMedia: no media element attached'));\n    }\n\n    // Signal play intent — enables loading even with preload=\"none\"\n    this.#engine.state.patch({ playbackInitiated: true });\n\n    return mediaElement.play().catch((err: unknown) => {\n      // If we have a pending HLS source, the rejection may be because MSE\n      // hasn't attached a blob URL yet. Wait for loadstart (src assigned\n      // by MSE setup) and retry once.\n      if (this.src) {\n        return new Promise<void>((resolve, reject) => {\n          const listener = () => {\n            this.#loadstartListener = null;\n            mediaElement.play().then(resolve, reject);\n          };\n          this.#loadstartListener = listener;\n          mediaElement.addEventListener('loadstart', listener, { once: true });\n        });\n      }\n      throw err;\n    });\n  }\n\n  // ---------------------------------------------------------------------------\n  // Private\n  // ---------------------------------------------------------------------------\n\n  #cancelPendingPlay(): void {\n    if (!this.#loadstartListener) return;\n    const { mediaElement } = this.#engine.owners.current;\n    mediaElement?.removeEventListener('loadstart', this.#loadstartListener);\n    this.#loadstartListener = null;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,IAAa,WAAb,MAAsB;CACpB;CACA;CACA,WAA8C;;CAG9C,qBAA0C;CAE1C,YAAY,SAA+B,EAAE,EAAE;AAC7C,QAAKA,SAAU;AACf,QAAKC,SAAU,qBAAqB,OAAO;;CAG7C,IAAI,SAAyB;AAC3B,SAAO,MAAKA;;CAOd,OAAO,cAAsC;AAC3C,QAAKA,OAAQ,OAAO,MAAM,EAAE,cAAc,CAAC;;CAG7C,SAAe;AACb,QAAKC,mBAAoB;AACzB,QAAKD,OAAQ,OAAO,MAAM,EAAE,cAAc,QAAW,CAAC;;CAGxD,UAAgB;AACd,QAAKC,mBAAoB;AACzB,QAAKD,OAAQ,SAAS;;CAOxB,IAAI,UAA6C;AAC/C,SAAO,MAAKE;;CAGd,IAAI,QAAQ,OAA0C;AACpD,QAAKA,UAAW;AAChB,MAAI,MACF,OAAKF,OAAQ,MAAM,MAAM,EAAE,SAAS,OAAO,CAAC;;CAahD,IAAI,MAAc;AAChB,SAAO,MAAKA,OAAQ,MAAM,QAAQ,cAAc,OAAO;;CAGzD,IAAI,IAAI,OAAe;EACrB,MAAM,mBAAmB,MAAKA,OAAQ,OAAO,QAAQ;AAErD,QAAKC,mBAAoB;AACzB,QAAKD,OAAQ,SAAS;AACtB,QAAKA,SAAU,qBAAqB,MAAKD,OAAQ;AAIjD,MAAI,MAAKG,QACP,OAAKF,OAAQ,MAAM,MAAM,EAAE,SAAS,MAAKE,SAAU,CAAC;AAGtD,MAAI,iBACF,OAAKF,OAAQ,OAAO,MAAM,EAAE,cAAc,kBAAkB,CAAC;AAG/D,MAAI,MACF,OAAKA,OAAQ,MAAM,MAAM,EAAE,cAAc,EAAE,KAAK,OAAO,EAAE,CAAC;;CAS9D,OAAsB;EACpB,MAAM,EAAE,iBAAiB,MAAKA,OAAQ,OAAO;AAC7C,MAAI,CAAC,aACH,QAAO,QAAQ,uBAAO,IAAI,MAAM,sCAAsC,CAAC;AAIzE,QAAKA,OAAQ,MAAM,MAAM,EAAE,mBAAmB,MAAM,CAAC;AAErD,SAAO,aAAa,MAAM,CAAC,OAAO,QAAiB;AAIjD,OAAI,KAAK,IACP,QAAO,IAAI,SAAe,SAAS,WAAW;IAC5C,MAAM,iBAAiB;AACrB,WAAKG,oBAAqB;AAC1B,kBAAa,MAAM,CAAC,KAAK,SAAS,OAAO;;AAE3C,UAAKA,oBAAqB;AAC1B,iBAAa,iBAAiB,aAAa,UAAU,EAAE,MAAM,MAAM,CAAC;KACpE;AAEJ,SAAM;IACN;;CAOJ,qBAA2B;AACzB,MAAI,CAAC,MAAKA,kBAAoB;EAC9B,MAAM,EAAE,iBAAiB,MAAKH,OAAQ,OAAO;AAC7C,gBAAc,oBAAoB,aAAa,MAAKG,kBAAmB;AACvE,QAAKA,oBAAqB"}

package/dist/dev/dom/playback-engine/engine.d.ts

@@ -0,0 +1,135 @@
+import { BandwidthState } from "../../core/abr/bandwidth-estimator.js";
+import { createState } from "../../core/state/create-state.js";
+import { SourceBufferActor } from "../media/source-buffer-actor.js";
+import { TextTrackBufferState } from "../features/load-text-track-cues.js";
+import { createEventStream } from "../../core/events/create-event-stream.js";
+import { PresentationAction } from "../../core/features/resolve-presentation.js";
+import { TrackResolutionAction } from "../../core/features/resolve-track.js";
+import { TrackSelectionAction } from "../../core/features/select-tracks.js";
+
+//#region src/dom/playback-engine/engine.d.ts
+/**
+ * Union of all action types used by playback engine orchestrations.
+ * Includes synthetic @@INITIALIZE@@ event for combineLatest bootstrapping.
+ */
+type PlaybackEngineAction = PresentationAction | TrackResolutionAction | TrackSelectionAction | {
+  type: '@@INITIALIZE@@';
+};
+/**
+ * Configuration for the playback engine.
+ */
+interface PlaybackEngineConfig {
+  /**
+   * Initial bandwidth estimate for cold start (bits per second).
+   * Default: 1 Mbps (conservative).
+   */
+  initialBandwidth?: number;
+  /**
+   * Preferred audio language (ISO 639 code, e.g., "en", "es").
+   * If not specified, selects first audio track.
+   */
+  preferredAudioLanguage?: string;
+  /**
+   * Preferred subtitle language (ISO 639 code, e.g., "en", "es").
+   * If specified, selects matching text track if available.
+   */
+  preferredSubtitleLanguage?: string;
+  /**
+   * Include FORCED subtitle tracks in selection.
+   * Default: false (follows hls.js/http-streaming pattern)
+   */
+  includeForcedTracks?: boolean;
+  /**
+   * Auto-select DEFAULT track (requires DEFAULT=YES + AUTOSELECT=YES in HLS).
+   * Default: false (user opt-in, matches hls.js/http-streaming)
+   */
+  enableDefaultTrack?: boolean;
+}
+/**
+ * Combined state shape for the playback engine.
+ * Includes all state needed by orchestrations.
+ */
+interface PlaybackEngineState {
+  presentation?: any;
+  preload?: string;
+  selectedVideoTrackId?: string;
+  selectedAudioTrackId?: string;
+  selectedTextTrackId?: string;
+  bandwidthState?: BandwidthState;
+  abrDisabled?: boolean;
+  textBufferState?: TextTrackBufferState;
+  currentTime?: number;
+  playbackInitiated?: boolean;
+}
+/**
+ * Combined owners shape for the playback engine.
+ * Includes all mutable platform objects.
+ */
+interface PlaybackEngineOwners {
+  mediaElement?: HTMLMediaElement | undefined;
+  mediaSource?: MediaSource;
+  videoBuffer?: SourceBuffer;
+  audioBuffer?: SourceBuffer;
+  videoBufferActor?: SourceBufferActor;
+  audioBufferActor?: SourceBufferActor;
+  textTracks?: Map<string, HTMLTrackElement>;
+}
+/**
+ * Playback engine instance.
+ */
+interface PlaybackEngine {
+  /**
+   * Reactive state (for inspection/testing).
+   */
+  state: ReturnType<typeof createState<PlaybackEngineState>>;
+  /**
+   * Mutable owners (for inspection/testing).
+   */
+  owners: ReturnType<typeof createState<PlaybackEngineOwners>>;
+  /**
+   * Shared event stream (for inspection/testing/triggering events).
+   */
+  events: ReturnType<typeof createEventStream<PlaybackEngineAction>>;
+  /**
+   * Cleanup function to destroy all orchestrations.
+   */
+  destroy: () => void;
+}
+/**
+ * Create a POC playback engine.
+ *
+ * Wires together all orchestrations to create a reactive playback pipeline:
+ * 1. Resolve presentation (multivariant playlist)
+ * 2. Select initial video and audio tracks
+ * 3. Resolve selected tracks (media playlists)
+ * 4. Setup MediaSource
+ * 5. Setup SourceBuffers for video and audio
+ *
+ * Note: This is a POC - does not yet load/append segments.
+ *
+ * @param config - Playback engine configuration
+ * @returns Playback engine instance with state, owners, and destroy function
+ *
+ * @example
+ * const engine = createPlaybackEngine({
+ *   initialBandwidth: 2_000_000,
+ *   preferredAudioLanguage: 'en',
+ * });
+ *
+ * // Initialize by patching state and owners
+ * engine.owners.patch({ mediaElement: document.querySelector('video') });
+ * engine.state.patch({
+ *   presentation: { url: 'https://example.com/playlist.m3u8' },
+ *   preload: 'auto',
+ * });
+ *
+ * // Inspect state
+ * console.log(engine.state.current);
+ *
+ * // Cleanup
+ * engine.destroy();
+ */
+declare function createPlaybackEngine(config?: PlaybackEngineConfig): PlaybackEngine;
+//#endregion
+export { PlaybackEngine, PlaybackEngineConfig, createPlaybackEngine };
+//# sourceMappingURL=engine.d.ts.map

package/dist/dev/dom/playback-engine/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","names":[],"sources":["../../../../src/dom/playback-engine/engine.ts"],"mappings":";;;;;;;;;;;;AAoCA;;KAAY,oBAAA,GACR,kBAAA,GACA,qBAAA,GACA,oBAAA;EACE,IAAA;AAAA;;;;UAKW,oBAAA;EAPb;;;;EAYF,gBAAA;EALe;;;;EAWf,sBAAA;EAAA;;;;EAMA,yBAAA;EAYkB;AAOpB;;;EAbE,mBAAA;EAeA;;;;EATA,kBAAA;AAAA;;;;;UAOe,mBAAA;EAEf,YAAA;EACA,OAAA;EAGA,oBAAA;EACA,oBAAA;EAEA,mBAAA;EAGA,cAAA,GAAiB,cAAA;EAKjB,WAAA;EAGA,eAAA,GAAkB,oBAAA;EAGlB,WAAA;EAGA,iBAAA;AAAA;;;;;UAOe,oBAAA;EAEf,YAAA,GAAe,gBAAA;EAGf,WAAA,GAAc,WAAA;EAGd,WAAA,GAAc,YAAA;EACd,WAAA,GAAc,YAAA;EACd,gBAAA,GAAmB,iBAAA;EACnB,gBAAA,GAAmB,iBAAA;EAGnB,UAAA,GAAa,GAAA,SAAY,gBAAA;AAAA;;;;UAMV,cAAA;EANf;;;EAUA,KAAA,EAAO,UAAA,QAAkB,WAAA,CAAY,mBAAA;EAVI;AAM3C;;EASE,MAAA,EAAQ,UAAA,QAAkB,WAAA,CAAY,oBAAA;EALD;;;EAUrC,MAAA,EAAQ,UAAA,QAAkB,iBAAA,CAAkB,oBAAA;EALlB;;;EAU1B,OAAA;AAAA;;;;;;;;;;;;;;;;;;AAqCF;;;;;;;;;;;;;;;;;iBAAgB,oBAAA,CAAqB,MAAA,GAAQ,oBAAA,GAA4B,cAAA"}

package/dist/dev/dom/playback-engine/engine.js

@@ -0,0 +1,176 @@
+import { createState } from "../../core/state/create-state.js";
+import { createEventStream } from "../../core/events/create-event-stream.js";
+import { resolvePresentation, syncPreloadAttribute } from "../../core/features/resolve-presentation.js";
+import { switchQuality } from "../../core/features/quality-switching.js";
+import { loadSegments } from "../features/load-segments.js";
+import { destroyVttParser } from "../text/parse-vtt-segment.js";
+import { loadTextTrackCues } from "../features/load-text-track-cues.js";
+import { trackCurrentTime } from "../features/track-current-time.js";
+import { trackPlaybackInitiated } from "../features/track-playback-initiated.js";
+import { calculatePresentationDuration } from "../../core/features/calculate-presentation-duration.js";
+import { resolveTrack } from "../../core/features/resolve-track.js";
+import { selectAudioTrack, selectTextTrack, selectVideoTrack } from "../../core/features/select-tracks.js";
+import { endOfStream } from "../features/end-of-stream.js";
+import { setupMediaSource } from "../features/setup-mediasource.js";
+import { setupSourceBuffers } from "../features/setup-sourcebuffer.js";
+import { setupTextTracks } from "../features/setup-text-tracks.js";
+import { syncSelectedTextTrackFromDom } from "../features/sync-selected-text-track-from-dom.js";
+import { syncTextTrackModes } from "../features/sync-text-track-modes.js";
+import { updateDuration } from "../features/update-duration.js";
+
+//#region src/dom/playback-engine/engine.ts
+/**
+* Create a POC playback engine.
+*
+* Wires together all orchestrations to create a reactive playback pipeline:
+* 1. Resolve presentation (multivariant playlist)
+* 2. Select initial video and audio tracks
+* 3. Resolve selected tracks (media playlists)
+* 4. Setup MediaSource
+* 5. Setup SourceBuffers for video and audio
+*
+* Note: This is a POC - does not yet load/append segments.
+*
+* @param config - Playback engine configuration
+* @returns Playback engine instance with state, owners, and destroy function
+*
+* @example
+* const engine = createPlaybackEngine({
+*   initialBandwidth: 2_000_000,
+*   preferredAudioLanguage: 'en',
+* });
+*
+* // Initialize by patching state and owners
+* engine.owners.patch({ mediaElement: document.querySelector('video') });
+* engine.state.patch({
+*   presentation: { url: 'https://example.com/playlist.m3u8' },
+*   preload: 'auto',
+* });
+*
+* // Inspect state
+* console.log(engine.state.current);
+*
+* // Cleanup
+* engine.destroy();
+*/
+function createPlaybackEngine(config = {}) {
+	const state = createState({ bandwidthState: {
+		fastEstimate: 0,
+		fastTotalWeight: 0,
+		slowEstimate: 0,
+		slowTotalWeight: 0,
+		bytesSampled: 0
+	} });
+	const owners = createState({});
+	const events = createEventStream();
+	const cleanups = [
+		syncPreloadAttribute(state, owners),
+		trackPlaybackInitiated({
+			state,
+			owners,
+			events
+		}),
+		resolvePresentation({
+			state,
+			events
+		}),
+		selectVideoTrack({
+			state,
+			owners,
+			events
+		}, {
+			type: "video",
+			...config.initialBandwidth !== void 0 && { initialBandwidth: config.initialBandwidth }
+		}),
+		selectAudioTrack({
+			state,
+			owners,
+			events
+		}, {
+			type: "audio",
+			...config.preferredAudioLanguage !== void 0 && { preferredAudioLanguage: config.preferredAudioLanguage }
+		}),
+		selectTextTrack({
+			state,
+			owners,
+			events
+		}, {
+			type: "text",
+			...config.preferredSubtitleLanguage !== void 0 && { preferredSubtitleLanguage: config.preferredSubtitleLanguage },
+			...config.includeForcedTracks !== void 0 && { includeForcedTracks: config.includeForcedTracks },
+			...config.enableDefaultTrack !== void 0 && { enableDefaultTrack: config.enableDefaultTrack }
+		}),
+		resolveTrack({
+			state,
+			events
+		}, { type: "video" }),
+		resolveTrack({
+			state,
+			events
+		}, { type: "audio" }),
+		resolveTrack({
+			state,
+			events
+		}, { type: "text" }),
+		calculatePresentationDuration({ state }),
+		setupMediaSource({
+			state,
+			owners
+		}),
+		updateDuration({
+			state,
+			owners
+		}),
+		setupSourceBuffers({
+			state,
+			owners
+		}),
+		trackCurrentTime({
+			state,
+			owners
+		}),
+		switchQuality({ state }),
+		loadSegments({
+			state,
+			owners
+		}, { type: "video" }),
+		loadSegments({
+			state,
+			owners
+		}, { type: "audio" }),
+		endOfStream({
+			state,
+			owners
+		}),
+		setupTextTracks({
+			state,
+			owners
+		}),
+		syncTextTrackModes({
+			state,
+			owners
+		}),
+		syncSelectedTextTrackFromDom({
+			state,
+			owners
+		}),
+		loadTextTrackCues({
+			state,
+			owners
+		})
+	];
+	events.dispatch({ type: "@@INITIALIZE@@" });
+	return {
+		state,
+		owners,
+		events,
+		destroy: () => {
+			cleanups.forEach((cleanup) => cleanup());
+			destroyVttParser();
+		}
+	};
+}
+
+//#endregion
+export { createPlaybackEngine };
+//# sourceMappingURL=engine.js.map

package/dist/dev/dom/playback-engine/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","names":[],"sources":["../../../../src/dom/playback-engine/engine.ts"],"sourcesContent":["import type { BandwidthState } from '../../core/abr/bandwidth-estimator';\nimport { createEventStream } from '../../core/events/create-event-stream';\nimport { calculatePresentationDuration } from '../../core/features/calculate-presentation-duration';\nimport { switchQuality } from '../../core/features/quality-switching';\nimport {\n  type PresentationAction,\n  resolvePresentation,\n  syncPreloadAttribute,\n} from '../../core/features/resolve-presentation';\nimport { resolveTrack, type TrackResolutionAction } from '../../core/features/resolve-track';\nimport {\n  selectAudioTrack,\n  selectTextTrack,\n  selectVideoTrack,\n  type TrackSelectionAction,\n} from '../../core/features/select-tracks';\nimport { createState } from '../../core/state/create-state';\nimport { endOfStream } from '../features/end-of-stream';\nimport { loadSegments } from '../features/load-segments';\nimport type { TextTrackBufferState } from '../features/load-text-track-cues';\nimport { loadTextTrackCues } from '../features/load-text-track-cues';\nimport { setupMediaSource } from '../features/setup-mediasource';\nimport { setupSourceBuffers } from '../features/setup-sourcebuffer';\nimport { setupTextTracks } from '../features/setup-text-tracks';\nimport { syncSelectedTextTrackFromDom } from '../features/sync-selected-text-track-from-dom';\nimport { syncTextTrackModes } from '../features/sync-text-track-modes';\nimport { trackCurrentTime } from '../features/track-current-time';\nimport { trackPlaybackInitiated } from '../features/track-playback-initiated';\nimport { updateDuration } from '../features/update-duration';\nimport type { SourceBufferActor } from '../media/source-buffer-actor';\nimport { destroyVttParser } from '../text/parse-vtt-segment';\n\n/**\n * Union of all action types used by playback engine orchestrations.\n * Includes synthetic @@INITIALIZE@@ event for combineLatest bootstrapping.\n */\nexport type PlaybackEngineAction =\n  | PresentationAction\n  | TrackResolutionAction\n  | TrackSelectionAction\n  | { type: '@@INITIALIZE@@' };\n\n/**\n * Configuration for the playback engine.\n */\nexport interface PlaybackEngineConfig {\n  /**\n   * Initial bandwidth estimate for cold start (bits per second).\n   * Default: 1 Mbps (conservative).\n   */\n  initialBandwidth?: number;\n\n  /**\n   * Preferred audio language (ISO 639 code, e.g., \"en\", \"es\").\n   * If not specified, selects first audio track.\n   */\n  preferredAudioLanguage?: string;\n\n  /**\n   * Preferred subtitle language (ISO 639 code, e.g., \"en\", \"es\").\n   * If specified, selects matching text track if available.\n   */\n  preferredSubtitleLanguage?: string;\n\n  /**\n   * Include FORCED subtitle tracks in selection.\n   * Default: false (follows hls.js/http-streaming pattern)\n   */\n  includeForcedTracks?: boolean;\n\n  /**\n   * Auto-select DEFAULT track (requires DEFAULT=YES + AUTOSELECT=YES in HLS).\n   * Default: false (user opt-in, matches hls.js/http-streaming)\n   */\n  enableDefaultTrack?: boolean;\n}\n\n/**\n * Combined state shape for the playback engine.\n * Includes all state needed by orchestrations.\n */\nexport interface PlaybackEngineState {\n  // Presentation state\n  presentation?: any;\n  preload?: string;\n\n  // Track selection state\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n  // NOTE: Text Tracks (subtitles/ccs) can be unselected\n  selectedTextTrackId?: string;\n\n  // Bandwidth estimation state\n  bandwidthState?: BandwidthState;\n\n  // ABR control — set to true to suppress automatic quality switching (manual selection mode).\n  // TODO: replace with separate manualVideoTrackId / abrVideoTrackId fields so the two\n  // concerns don't share a field; see quality-switching.ts for the full design note.\n  abrDisabled?: boolean;\n\n  // Text track buffer state (tracks loaded VTT segments per text track ID)\n  textBufferState?: TextTrackBufferState;\n\n  // Current playback position (mirrored from mediaElement via trackCurrentTime)\n  currentTime?: number;\n\n  // True once the user has initiated playback (enables segment loading regardless of preload)\n  playbackInitiated?: boolean;\n}\n\n/**\n * Combined owners shape for the playback engine.\n * Includes all mutable platform objects.\n */\nexport interface PlaybackEngineOwners {\n  // Media element\n  mediaElement?: HTMLMediaElement | undefined;\n\n  // MediaSource\n  mediaSource?: MediaSource;\n\n  // SourceBuffers and their actors (created together by setupSourceBuffer)\n  videoBuffer?: SourceBuffer;\n  audioBuffer?: SourceBuffer;\n  videoBufferActor?: SourceBufferActor;\n  audioBufferActor?: SourceBufferActor;\n\n  // Text tracks (track elements by ID)\n  textTracks?: Map<string, HTMLTrackElement>;\n}\n\n/**\n * Playback engine instance.\n */\nexport interface PlaybackEngine {\n  /**\n   * Reactive state (for inspection/testing).\n   */\n  state: ReturnType<typeof createState<PlaybackEngineState>>;\n\n  /**\n   * Mutable owners (for inspection/testing).\n   */\n  owners: ReturnType<typeof createState<PlaybackEngineOwners>>;\n\n  /**\n   * Shared event stream (for inspection/testing/triggering events).\n   */\n  events: ReturnType<typeof createEventStream<PlaybackEngineAction>>;\n\n  /**\n   * Cleanup function to destroy all orchestrations.\n   */\n  destroy: () => void;\n}\n\n/**\n * Create a POC playback engine.\n *\n * Wires together all orchestrations to create a reactive playback pipeline:\n * 1. Resolve presentation (multivariant playlist)\n * 2. Select initial video and audio tracks\n * 3. Resolve selected tracks (media playlists)\n * 4. Setup MediaSource\n * 5. Setup SourceBuffers for video and audio\n *\n * Note: This is a POC - does not yet load/append segments.\n *\n * @param config - Playback engine configuration\n * @returns Playback engine instance with state, owners, and destroy function\n *\n * @example\n * const engine = createPlaybackEngine({\n *   initialBandwidth: 2_000_000,\n *   preferredAudioLanguage: 'en',\n * });\n *\n * // Initialize by patching state and owners\n * engine.owners.patch({ mediaElement: document.querySelector('video') });\n * engine.state.patch({\n *   presentation: { url: 'https://example.com/playlist.m3u8' },\n *   preload: 'auto',\n * });\n *\n * // Inspect state\n * console.log(engine.state.current);\n *\n * // Cleanup\n * engine.destroy();\n */\nexport function createPlaybackEngine(config: PlaybackEngineConfig = {}): PlaybackEngine {\n  // Create reactive state and owners (initially empty)\n  const state = createState<PlaybackEngineState>({\n    bandwidthState: {\n      fastEstimate: 0,\n      fastTotalWeight: 0,\n      slowEstimate: 0,\n      slowTotalWeight: 0,\n      bytesSampled: 0,\n    },\n  });\n  const owners = createState<PlaybackEngineOwners>({});\n\n  // Create single shared event stream for all orchestrations\n  const events = createEventStream<PlaybackEngineAction>();\n\n  // Wire up orchestrations (all share single event stream)\n  // Note: @ts-expect-error needed due to EventStream invariance - each orchestration expects\n  // specific event types, but shared stream has union of all types. Proper fix would\n  // require making EventStream covariant or refactoring event system.\n  const cleanups = [\n    // 0a. Sync preload attribute from mediaElement → state.preload\n    //     Only re-reads when the mediaElement reference changes (lastMediaElement guard).\n    //     Normalises '' (absent attribute) to 'auto' (browser default).\n    // @ts-expect-error - WritableState type variance\n    syncPreloadAttribute(state, owners),\n\n    // 0b. Bridge media element play event → state.playbackInitiated + event stream\n    //     Enables preload=\"none\"/\"metadata\" resolution via native controls / element.play()\n    // @ts-expect-error - EventStream type variance\n    trackPlaybackInitiated({ state, owners, events }),\n\n    // 1. Resolve presentation (URL already in state)\n    // @ts-expect-error - EventStream type variance\n    resolvePresentation({ state, events }),\n\n    // 2. Select initial tracks (when presentation loads)\n    selectVideoTrack(\n      // @ts-expect-error - Owners and EventStream type compatibility\n      { state, owners, events },\n      {\n        type: 'video',\n        ...(config.initialBandwidth !== undefined && { initialBandwidth: config.initialBandwidth }),\n      }\n    ),\n    selectAudioTrack(\n      // @ts-expect-error - Owners and EventStream type compatibility\n      { state, owners, events },\n      {\n        type: 'audio',\n        ...(config.preferredAudioLanguage !== undefined && { preferredAudioLanguage: config.preferredAudioLanguage }),\n      }\n    ),\n    selectTextTrack(\n      // @ts-expect-error - Owners and EventStream type compatibility\n      { state, owners, events },\n      {\n        type: 'text',\n        ...(config.preferredSubtitleLanguage !== undefined && {\n          preferredSubtitleLanguage: config.preferredSubtitleLanguage,\n        }),\n        ...(config.includeForcedTracks !== undefined && { includeForcedTracks: config.includeForcedTracks }),\n        ...(config.enableDefaultTrack !== undefined && { enableDefaultTrack: config.enableDefaultTrack }),\n      }\n    ),\n\n    // 3. Resolve selected tracks (fetch media playlists)\n    // @ts-expect-error - EventStream type variance\n    resolveTrack({ state, events }, { type: 'video' as const }),\n    // @ts-expect-error - EventStream type variance\n    resolveTrack({ state, events }, { type: 'audio' as const }),\n    // @ts-expect-error - EventStream type variance\n    resolveTrack({ state, events }, { type: 'text' as const }),\n\n    // 3.5. Calculate presentation duration from resolved tracks\n    calculatePresentationDuration({ state }),\n\n    // 4. Setup MediaSource (when presentation loaded)\n    setupMediaSource({ state, owners }),\n\n    // 4.5. Update MediaSource duration (when presentation duration available)\n    updateDuration({ state, owners }),\n\n    // 5. Setup SourceBuffers (when MediaSource ready and all selected tracks resolved)\n    // Both SourceBuffers are created in a single synchronous operation to guarantee\n    // neither is visible to loadSegments before the other exists — preventing the\n    // Firefox bug where appending video data before audio SB is created causes\n    // mozHasAudio to be permanently false.\n    setupSourceBuffers({ state, owners }),\n\n    // 5.5. Track currentTime from mediaElement (feeds forward buffer management)\n    //\n    // NOTE: SourceBufferActor wiring is intentionally absent here in Phase 1.\n    //\n    // Attempting to wire actors into the engine at this layer revealed a\n    // brittleness in the current architecture: every patch to `owners` —\n    // regardless of which field changed — wakes up ALL combineLatest subscribers\n    // (loadSegments, endOfStream, etc.). Storing actor references in owners\n    // caused loadSegments to re-evaluate mid-task, store a spurious pending\n    // state, and run a second loading cycle on completion.\n    //\n    // This means any future feature that needs to introduce new reactive state\n    // alongside SourceBuffers faces the same hazard. The right fix is for\n    // loadSegments (and other orchestrations) to route their MSE operations\n    // through the actor directly, at which point the actor lifecycle is\n    // co-located with its consumer rather than managed centrally here.\n    //\n    // Actor wiring will be introduced in Phase 2 as part of the loadSegments\n    // refactor. See .claude/plans/spf/buffer-state-shadow-actual-model.md.\n    trackCurrentTime({ state, owners }),\n\n    // 5.75. ABR quality switching (reacts to bandwidth samples from loadSegments)\n    switchQuality({ state }),\n\n    // 6. Load segments (when SourceBuffer ready and track resolved)\n    loadSegments({ state, owners }, { type: 'video' }),\n    loadSegments({ state, owners }, { type: 'audio' }),\n\n    // 6.5. Signal end of stream when all segments loaded\n    endOfStream({ state, owners }),\n\n    // 7. Setup text tracks (when mediaElement and presentation ready)\n    setupTextTracks({ state, owners }),\n\n    // 8. Sync text track modes (when track selected and track elements created)\n    syncTextTrackModes({ state, owners }),\n\n    // 8.5. Bridge DOM text track mode changes → selectedTextTrackId\n    //      Detects when external code (e.g. captions button via toggleSubtitles())\n    //      sets a subtitle/caption track to 'showing' and reflects that into SPF\n    //      state, which in turn drives loadTextTrackCues.\n    syncSelectedTextTrackFromDom({ state, owners }),\n\n    // 9. Load text track cues (when track resolved and mode set)\n    loadTextTrackCues({ state, owners }),\n  ];\n\n  // Dispatch synthetic initialize event to satisfy combineLatest\n  // (combineLatest waits for all sources to emit before triggering listeners)\n  events.dispatch({ type: '@@INITIALIZE@@' });\n\n  // Return engine instance\n  return {\n    state,\n    owners,\n    events,\n    destroy: () => {\n      cleanups.forEach((cleanup) => cleanup());\n      destroyVttParser();\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8LA,SAAgB,qBAAqB,SAA+B,EAAE,EAAkB;CAEtF,MAAM,QAAQ,YAAiC,EAC7C,gBAAgB;EACd,cAAc;EACd,iBAAiB;EACjB,cAAc;EACd,iBAAiB;EACjB,cAAc;EACf,EACF,CAAC;CACF,MAAM,SAAS,YAAkC,EAAE,CAAC;CAGpD,MAAM,SAAS,mBAAyC;CAMxD,MAAM,WAAW;EAKf,qBAAqB,OAAO,OAAO;EAKnC,uBAAuB;GAAE;GAAO;GAAQ;GAAQ,CAAC;EAIjD,oBAAoB;GAAE;GAAO;GAAQ,CAAC;EAGtC,iBAEE;GAAE;GAAO;GAAQ;GAAQ,EACzB;GACE,MAAM;GACN,GAAI,OAAO,qBAAqB,UAAa,EAAE,kBAAkB,OAAO,kBAAkB;GAC3F,CACF;EACD,iBAEE;GAAE;GAAO;GAAQ;GAAQ,EACzB;GACE,MAAM;GACN,GAAI,OAAO,2BAA2B,UAAa,EAAE,wBAAwB,OAAO,wBAAwB;GAC7G,CACF;EACD,gBAEE;GAAE;GAAO;GAAQ;GAAQ,EACzB;GACE,MAAM;GACN,GAAI,OAAO,8BAA8B,UAAa,EACpD,2BAA2B,OAAO,2BACnC;GACD,GAAI,OAAO,wBAAwB,UAAa,EAAE,qBAAqB,OAAO,qBAAqB;GACnG,GAAI,OAAO,uBAAuB,UAAa,EAAE,oBAAoB,OAAO,oBAAoB;GACjG,CACF;EAID,aAAa;GAAE;GAAO;GAAQ,EAAE,EAAE,MAAM,SAAkB,CAAC;EAE3D,aAAa;GAAE;GAAO;GAAQ,EAAE,EAAE,MAAM,SAAkB,CAAC;EAE3D,aAAa;GAAE;GAAO;GAAQ,EAAE,EAAE,MAAM,QAAiB,CAAC;EAG1D,8BAA8B,EAAE,OAAO,CAAC;EAGxC,iBAAiB;GAAE;GAAO;GAAQ,CAAC;EAGnC,eAAe;GAAE;GAAO;GAAQ,CAAC;EAOjC,mBAAmB;GAAE;GAAO;GAAQ,CAAC;EAqBrC,iBAAiB;GAAE;GAAO;GAAQ,CAAC;EAGnC,cAAc,EAAE,OAAO,CAAC;EAGxB,aAAa;GAAE;GAAO;GAAQ,EAAE,EAAE,MAAM,SAAS,CAAC;EAClD,aAAa;GAAE;GAAO;GAAQ,EAAE,EAAE,MAAM,SAAS,CAAC;EAGlD,YAAY;GAAE;GAAO;GAAQ,CAAC;EAG9B,gBAAgB;GAAE;GAAO;GAAQ,CAAC;EAGlC,mBAAmB;GAAE;GAAO;GAAQ,CAAC;EAMrC,6BAA6B;GAAE;GAAO;GAAQ,CAAC;EAG/C,kBAAkB;GAAE;GAAO;GAAQ,CAAC;EACrC;AAID,QAAO,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAG3C,QAAO;EACL;EACA;EACA;EACA,eAAe;AACb,YAAS,SAAS,YAAY,SAAS,CAAC;AACxC,qBAAkB;;EAErB"}

package/dist/dev/dom/playback-engine.d.ts

@@ -0,0 +1,3 @@
+import { PlaybackEngine, PlaybackEngineConfig, createPlaybackEngine } from "./playback-engine/engine.js";
+import { SpfMedia } from "./playback-engine/adapter.js";
+export { type PlaybackEngine, type PlaybackEngineConfig, SpfMedia, createPlaybackEngine };

package/dist/dev/dom/playback-engine.js

@@ -0,0 +1,4 @@
+import { createPlaybackEngine } from "./playback-engine/engine.js";
+import { SpfMedia } from "./playback-engine/adapter.js";
+
+export { SpfMedia, createPlaybackEngine };

package/dist/dev/dom/text/parse-vtt-segment.d.ts

@@ -0,0 +1,12 @@
+//#region src/dom/text/parse-vtt-segment.d.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.
+ */
+declare function parseVttSegment(url: string): Promise<VTTCue[]>;
+declare function destroyVttParser(): void;
+//#endregion
+export { destroyVttParser, parseVttSegment };
+//# sourceMappingURL=parse-vtt-segment.d.ts.map

package/dist/dev/dom/text/parse-vtt-segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-vtt-segment.d.ts","names":[],"sources":["../../../../src/dom/text/parse-vtt-segment.ts"],"mappings":";;AAqBA;;;;;iBAAgB,eAAA,CAAgB,GAAA,WAAc,OAAA,CAAQ,MAAA;AAAA,iBA0CtC,gBAAA,CAAA"}

package/dist/dev/dom/text/parse-vtt-segment.js

@@ -0,0 +1,56 @@
+//#region src/dom/text/parse-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) {
+		dummyVideo = document.createElement("video");
+		dummyVideo.muted = true;
+		dummyVideo.preload = "none";
+		dummyVideo.style.display = "none";
+		dummyVideo.crossOrigin = "anonymous";
+	}
+	return dummyVideo;
+}
+function parseVttSegment(url) {
+	const video = ensureDummyVideo();
+	const track = document.createElement("track");
+	track.kind = "subtitles";
+	track.default = true;
+	return new Promise((resolve, reject) => {
+		const onLoad = () => {
+			const cues = [];
+			const textTrack = track.track;
+			if (textTrack.cues) for (let i = 0; i < textTrack.cues.length; i++) {
+				const cue = textTrack.cues[i];
+				if (cue) cues.push(cue);
+			}
+			cleanup();
+			resolve(cues);
+		};
+		const onError = () => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error(`Failed to load VTT segment: ${url}`));
+		};
+		const cleanup = () => {
+			track.removeEventListener("load", onLoad);
+			track.removeEventListener("error", onError);
+			video.removeChild(track);
+		};
+		track.addEventListener("load", onLoad);
+		track.addEventListener("error", onError);
+		video.appendChild(track);
+		track.src = url;
+	});
+}
+function destroyVttParser() {
+	dummyVideo = null;
+}
+
+//#endregion
+export { destroyVttParser, parseVttSegment };
+//# sourceMappingURL=parse-vtt-segment.js.map

package/dist/dev/dom/text/parse-vtt-segment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-vtt-segment.js","names":[],"sources":["../../../../src/dom/text/parse-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 parseVttSegment(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 destroyVttParser(): 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,gBAAgB,KAAgC;CAC9D,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,mBAAyB;AACvC,cAAa"}

package/dist/dev/dom.d.ts

@@ -0,0 +1,10 @@
+import { appendSegment } from "./dom/media/append-segment.js";
+import { loadSegments } from "./dom/features/load-segments.js";
+import { loadTextTrackCues } from "./dom/features/load-text-track-cues.js";
+import { CurrentTimeOwners, CurrentTimeState, trackCurrentTime } from "./dom/features/track-current-time.js";
+import { PlaybackInitiatedOwners, PlaybackInitiatedState, trackPlaybackInitiated } from "./dom/features/track-playback-initiated.js";
+import { PlaybackRateOwners, PlaybackRateState, trackPlaybackRate } from "./dom/features/track-playback-rate.js";
+import { flushBuffer } from "./dom/media/buffer-flusher.js";
+import { SpfMedia } from "./dom/playback-engine/adapter.js";
+import { destroyVttParser, parseVttSegment } from "./dom/text/parse-vtt-segment.js";
+export { type CurrentTimeOwners, type CurrentTimeState, type PlaybackInitiatedOwners, type PlaybackInitiatedState, type PlaybackRateOwners, type PlaybackRateState, SpfMedia, appendSegment, destroyVttParser, flushBuffer, loadSegments, loadTextTrackCues, parseVttSegment, trackCurrentTime, trackPlaybackInitiated, trackPlaybackRate };

package/dist/dev/dom.js

@@ -0,0 +1,11 @@
+import { loadSegments } from "./dom/features/load-segments.js";
+import { destroyVttParser, parseVttSegment } from "./dom/text/parse-vtt-segment.js";
+import { loadTextTrackCues } from "./dom/features/load-text-track-cues.js";
+import { trackCurrentTime } from "./dom/features/track-current-time.js";
+import { trackPlaybackInitiated } from "./dom/features/track-playback-initiated.js";
+import { trackPlaybackRate } from "./dom/features/track-playback-rate.js";
+import { appendSegment } from "./dom/media/append-segment.js";
+import { flushBuffer } from "./dom/media/buffer-flusher.js";
+import { SpfMedia } from "./dom/playback-engine/adapter.js";
+
+export { SpfMedia, appendSegment, destroyVttParser, flushBuffer, loadSegments, loadTextTrackCues, parseVttSegment, trackCurrentTime, trackPlaybackInitiated, trackPlaybackRate };

package/dist/dev/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;AAWA;;;;;;;cAAa,OAAA"}

package/dist/dev/index.js

@@ -0,0 +1,14 @@
+//#region src/index.ts
+/**
+* Stream Processing Framework (SPF) for Video.js 10
+*
+* Bundle size target: < 20KB (minified + gzipped)
+* Primary use case: CMAF HLS playback with Video.js v10
+*
+* @packageDocumentation
+*/
+const VERSION = "0.1.0";
+
+//#endregion
+export { VERSION };
+//# sourceMappingURL=index.js.map

package/dist/dev/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/**\n * Stream Processing Framework (SPF) for Video.js 10\n *\n * Bundle size target: < 20KB (minified + gzipped)\n * Primary use case: CMAF HLS playback with Video.js v10\n *\n * @packageDocumentation\n */\n\n// Public API exports will be added here as features are implemented\n\nexport const VERSION = '0.1.0';\n"],"mappings":";;;;;;;;;AAWA,MAAa,UAAU"}