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

package/dist/dev/{dom/playback-engine → playback/engines/hls}/adapter.js

@@ -1,6 +1,9 @@
-import { update } from "../../core/signals/primitives.js";
-import { createPlaybackEngine } from "./engine.js";
-//#region src/dom/playback-engine/adapter.ts
+import { createSimpleHlsEngine } from "./engine.js";
+//#region src/playback/engines/hls/adapter.ts
+const simpleHlsMediaDefaultProps = {
+	src: "",
+	preload: ""
+};
 /**
 * Mixin that adds SPF playback engine behavior to any base class.
 *
@@ -13,35 +16,36 @@ import { createPlaybackEngine } from "./engine.js";
 * changes and re-applied to the new engine automatically.
 *
 * @example
-* class SimpleHlsMedia extends SpfMediaMixin(HTMLVideoElementHost) {}
+* class SimpleHlsMedia extends SimpleHlsMediaMixin(HTMLVideoElementHost) {}
 *
 * const media = new SimpleHlsMedia();
 * media.attach(document.querySelector('video'));
 * media.src = 'https://stream.mux.com/abc123.m3u8';
 */
-function SpfMediaMixin(BaseClass) {
-	class SpfMediaImpl extends BaseClass {
+function SimpleHlsMediaMixin(BaseClass) {
+	class SimpleHlsMediaImpl extends BaseClass {
 		#engine;
 		#config;
-		#preload = "";
+		#signals;
+		#preload = simpleHlsMediaDefaultProps.preload;
 		/** Pending loadstart listener from a deferred play() retry, if any. */
 		#loadstartListener = null;
 		constructor(...args) {
 			super(...args);
 			const { config } = args?.[0] ?? {};
 			this.#config = config;
-			this.#engine = createPlaybackEngine(config);
+			this.#engine = this.#createEngine();
 		}
 		get engine() {
 			return this.#engine;
 		}
 		attach(mediaElement) {
 			super.attach?.(mediaElement);
-			update(this.#engine.owners, { mediaElement });
+			this.#signals.context.mediaElement.set(mediaElement);
 		}
 		detach() {
 			this.#cancelPendingPlay();
-			update(this.#engine.owners, { mediaElement: void 0 });
+			this.#signals.context.mediaElement.set(void 0);
 			super.detach?.();
 		}
 		destroy() {
@@ -53,24 +57,24 @@ function SpfMediaMixin(BaseClass) {
 		}
 		set preload(value) {
 			this.#preload = value;
-			if (value) update(this.#engine.state, { preload: value });
+			if (value) this.#signals.state.preload.set(value);
 		}
 		get src() {
-			return this.#engine.state.get().presentation?.url ?? "";
+			return this.#signals.state.presentation.get()?.url ?? "";
 		}
 		set src(value) {
-			const prevMediaElement = this.#engine.owners.get().mediaElement;
+			const prevMediaElement = this.#signals.context.mediaElement.get();
 			this.#cancelPendingPlay();
 			this.#engine.destroy();
-			this.#engine = createPlaybackEngine(this.#config);
-			if (this.#preload) update(this.#engine.state, { preload: this.#preload });
-			if (prevMediaElement) update(this.#engine.owners, { mediaElement: prevMediaElement });
-			if (value) update(this.#engine.state, { presentation: { url: value } });
+			this.#engine = this.#createEngine();
+			if (this.#preload) this.#signals.state.preload.set(this.#preload);
+			if (prevMediaElement) this.#signals.context.mediaElement.set(prevMediaElement);
+			if (value) this.#signals.state.presentation.set({ url: value });
 		}
 		play() {
-			const { mediaElement } = this.#engine.owners.get();
-			if (!mediaElement) return Promise.reject(/* @__PURE__ */ new Error("SpfMedia: no media element attached"));
-			update(this.#engine.state, { playbackInitiated: true });
+			const mediaElement = this.#signals.context.mediaElement.get();
+			if (!mediaElement) return Promise.reject(/* @__PURE__ */ new Error("SimpleHlsMediaElement: no media element attached"));
+			this.#signals.state.loadActivated.set(true);
 			return mediaElement.play().catch((err) => {
 				if (this.src) return new Promise((resolve, reject) => {
 					const listener = () => {
@@ -83,18 +87,25 @@ function SpfMediaMixin(BaseClass) {
 				throw err;
 			});
 		}
+		#createEngine() {
+			return createSimpleHlsEngine({
+				...this.#config,
+				onSignalsReady: (signals) => {
+					this.#signals = signals;
+				}
+			});
+		}
 		#cancelPendingPlay() {
 			if (!this.#loadstartListener) return;
-			const { mediaElement } = this.#engine.owners.get();
-			mediaElement?.removeEventListener("loadstart", this.#loadstartListener);
+			this.#signals.context.mediaElement.get()?.removeEventListener("loadstart", this.#loadstartListener);
 			this.#loadstartListener = null;
 		}
 	}
-	return SpfMediaImpl;
+	return SimpleHlsMediaImpl;
 }
 /** Standalone SPF media adapter with no base class. */
-var SpfMedia = class extends SpfMediaMixin(class {}) {};
+var SimpleHlsMediaElement = class extends SimpleHlsMediaMixin(class {}) {};
 //#endregion
-export { SpfMedia, SpfMediaMixin };
+export { SimpleHlsMediaElement, SimpleHlsMediaMixin, simpleHlsMediaDefaultProps };
 
 //# sourceMappingURL=adapter.js.map

package/dist/dev/playback/engines/hls/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","names":["#config","#engine","#createEngine","#signals","#cancelPendingPlay","#preload","#loadstartListener"],"sources":["../../../../../src/playback/engines/hls/adapter.ts"],"sourcesContent":["import type { Constructor, MixinReturn } from '@videojs/utils/types';\nimport type { Composition } from '../../../core/composition/create-composition';\nimport {\n  createSimpleHlsEngine,\n  type SimpleHlsEngineConfig,\n  type SimpleHlsEngineContext,\n  type SimpleHlsEngineSignals,\n  type SimpleHlsEngineState,\n} from './engine';\n\nexport interface SimpleHlsMediaProps {\n  src: string;\n  preload: '' | 'none' | 'metadata' | 'auto';\n}\n\nexport const simpleHlsMediaDefaultProps: SimpleHlsMediaProps = {\n  src: '',\n  preload: '',\n};\n\nexport interface SimpleHlsMediaAPI extends SimpleHlsMediaProps {\n  readonly engine: Composition<SimpleHlsEngineState, SimpleHlsEngineContext>;\n  attach(mediaElement: HTMLMediaElement): void;\n  detach(): void;\n  destroy(): void;\n  play(): Promise<void>;\n}\n\n/**\n * Mixin that adds SPF playback engine behavior to any base class.\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 * class SimpleHlsMedia extends SimpleHlsMediaMixin(HTMLVideoElementHost) {}\n *\n * const media = new SimpleHlsMedia();\n * media.attach(document.querySelector('video'));\n * media.src = 'https://stream.mux.com/abc123.m3u8';\n */\nexport function SimpleHlsMediaMixin<Base extends Constructor<any>>(BaseClass: Base) {\n  class SimpleHlsMediaImpl extends BaseClass {\n    #engine: Composition<SimpleHlsEngineState, SimpleHlsEngineContext>;\n    #config: SimpleHlsEngineConfig;\n    #signals!: SimpleHlsEngineSignals;\n    #preload: '' | 'none' | 'metadata' | 'auto' = simpleHlsMediaDefaultProps.preload;\n\n    /** Pending loadstart listener from a deferred play() retry, if any. */\n    #loadstartListener: (() => void) | null = null;\n\n    constructor(...args: any[]) {\n      super(...args);\n\n      const { config } = args?.[0] ?? {};\n      this.#config = config;\n      this.#engine = this.#createEngine();\n    }\n\n    get engine(): Composition<SimpleHlsEngineState, SimpleHlsEngineContext> {\n      return this.#engine;\n    }\n\n    // -------------------------------------------------------------------------\n    // Media element lifecycle\n    // -------------------------------------------------------------------------\n\n    attach(mediaElement: HTMLMediaElement): void {\n      super.attach?.(mediaElement);\n      this.#signals.context.mediaElement.set(mediaElement);\n    }\n\n    detach(): void {\n      this.#cancelPendingPlay();\n      this.#signals.context.mediaElement.set(undefined);\n      super.detach?.();\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.#signals.state.preload.set(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.#signals.state.presentation.get()?.url ?? '';\n    }\n\n    set src(value: string) {\n      const prevMediaElement = this.#signals.context.mediaElement.get();\n\n      this.#cancelPendingPlay();\n      this.#engine.destroy();\n      this.#engine = this.#createEngine();\n\n      // Apply explicit preload before setting context so it's already in\n      // state.preload when syncPreload's read effect runs on the attach —\n      // the read effect only overwrites when the element's `preload` is a\n      // W3C value (which a freshly-created <video> with no attribute is not).\n      if (this.#preload) {\n        this.#signals.state.preload.set(this.#preload);\n      }\n\n      if (prevMediaElement) {\n        this.#signals.context.mediaElement.set(prevMediaElement);\n      }\n\n      if (value) {\n        this.#signals.state.presentation.set({ 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.#signals.context.mediaElement.get();\n      if (!mediaElement) {\n        return Promise.reject(new Error('SimpleHlsMediaElement: no media element attached'));\n      }\n\n      // Signal play intent — enables loading even with preload=\"none\"\n      this.#signals.state.loadActivated.set(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    #createEngine(): Composition<SimpleHlsEngineState, SimpleHlsEngineContext> {\n      return createSimpleHlsEngine({\n        ...this.#config,\n        onSignalsReady: (signals) => {\n          this.#signals = signals;\n        },\n      });\n    }\n\n    #cancelPendingPlay(): void {\n      if (!this.#loadstartListener) return;\n      const mediaElement = this.#signals.context.mediaElement.get();\n      mediaElement?.removeEventListener('loadstart', this.#loadstartListener);\n      this.#loadstartListener = null;\n    }\n  }\n\n  return SimpleHlsMediaImpl as unknown as MixinReturn<Base, SimpleHlsMediaAPI>;\n}\n\n/** Standalone SPF media adapter with no base class. */\nexport class SimpleHlsMediaElement extends SimpleHlsMediaMixin(class {}) {}\n"],"mappings":";;AAeA,MAAa,6BAAkD;CAC7D,KAAK;CACL,SAAS;CACV;;;;;;;;;;;;;;;;;;;AA4BD,SAAgB,oBAAmD,WAAiB;CAClF,MAAM,2BAA2B,UAAU;EACzC;EACA;EACA;EACA,WAA8C,2BAA2B;;EAGzE,qBAA0C;EAE1C,YAAY,GAAG,MAAa;AAC1B,SAAM,GAAG,KAAK;GAEd,MAAM,EAAE,WAAW,OAAO,MAAM,EAAE;AAClC,SAAA,SAAe;AACf,SAAA,SAAe,MAAA,cAAoB;;EAGrC,IAAI,SAAoE;AACtE,UAAO,MAAA;;EAOT,OAAO,cAAsC;AAC3C,SAAM,SAAS,aAAa;AAC5B,SAAA,QAAc,QAAQ,aAAa,IAAI,aAAa;;EAGtD,SAAe;AACb,SAAA,mBAAyB;AACzB,SAAA,QAAc,QAAQ,aAAa,IAAI,KAAA,EAAU;AACjD,SAAM,UAAU;;EAGlB,UAAgB;AACd,SAAA,mBAAyB;AACzB,SAAA,OAAa,SAAS;;EAOxB,IAAI,UAA6C;AAC/C,UAAO,MAAA;;EAGT,IAAI,QAAQ,OAA0C;AACpD,SAAA,UAAgB;AAChB,OAAI,MACF,OAAA,QAAc,MAAM,QAAQ,IAAI,MAAM;;EAa1C,IAAI,MAAc;AAChB,UAAO,MAAA,QAAc,MAAM,aAAa,KAAK,EAAE,OAAO;;EAGxD,IAAI,IAAI,OAAe;GACrB,MAAM,mBAAmB,MAAA,QAAc,QAAQ,aAAa,KAAK;AAEjE,SAAA,mBAAyB;AACzB,SAAA,OAAa,SAAS;AACtB,SAAA,SAAe,MAAA,cAAoB;AAMnC,OAAI,MAAA,QACF,OAAA,QAAc,MAAM,QAAQ,IAAI,MAAA,QAAc;AAGhD,OAAI,iBACF,OAAA,QAAc,QAAQ,aAAa,IAAI,iBAAiB;AAG1D,OAAI,MACF,OAAA,QAAc,MAAM,aAAa,IAAI,EAAE,KAAK,OAAO,CAAC;;EASxD,OAAsB;GACpB,MAAM,eAAe,MAAA,QAAc,QAAQ,aAAa,KAAK;AAC7D,OAAI,CAAC,aACH,QAAO,QAAQ,uBAAO,IAAI,MAAM,mDAAmD,CAAC;AAItF,SAAA,QAAc,MAAM,cAAc,IAAI,KAAK;AAE3C,UAAO,aAAa,MAAM,CAAC,OAAO,QAAiB;AAIjD,QAAI,KAAK,IACP,QAAO,IAAI,SAAe,SAAS,WAAW;KAC5C,MAAM,iBAAiB;AACrB,YAAA,oBAA0B;AAC1B,mBAAa,MAAM,CAAC,KAAK,SAAS,OAAO;;AAE3C,WAAA,oBAA0B;AAC1B,kBAAa,iBAAiB,aAAa,UAAU,EAAE,MAAM,MAAM,CAAC;MACpE;AAEJ,UAAM;KACN;;EAOJ,gBAA2E;AACzE,UAAO,sBAAsB;IAC3B,GAAG,MAAA;IACH,iBAAiB,YAAY;AAC3B,WAAA,UAAgB;;IAEnB,CAAC;;EAGJ,qBAA2B;AACzB,OAAI,CAAC,MAAA,kBAAyB;AACT,SAAA,QAAc,QAAQ,aAAa,KAAK,EAC/C,oBAAoB,aAAa,MAAA,kBAAwB;AACvE,SAAA,oBAA0B;;;AAI9B,QAAO;;;AAIT,IAAa,wBAAb,cAA2C,oBAAoB,MAAM,GAAG,CAAC"}

package/dist/dev/playback/engines/hls/engine.d.ts

@@ -0,0 +1,177 @@
+import { Composition, ContextSignals, StateSignals } from "../../../core/composition/create-composition.js";
+import { ShareSignalsConfig } from "../../../core/composition/share-signals.js";
+import { MaybeResolvedPresentation, VideoTrack } from "../../../media/types/index.js";
+import { BackBufferConfig } from "../../../media/buffer/back-buffer.js";
+import { ForwardBufferConfig } from "../../../media/buffer/forward-buffer.js";
+import { SourceBufferActor } from "../../actors/dom/source-buffer.js";
+import { SegmentLoaderActor } from "../../actors/dom/segment-loader.js";
+import { TextTracksActor } from "../../actors/text-tracks.js";
+import { TextTrackSegmentLoaderActor, TextTrackSegmentResolver } from "../../actors/text-track-segment-loader.js";
+import { QualityConfig } from "../../../media/abr/quality-selection.js";
+import { addSubtitlesTracksToMedia, getShowingSubtitlesTrackFromMedia, removeAllSubtitlesTracksFromMedia } from "../../../media/dom/text/text-track-slots.js";
+import { BandwidthConfig, BandwidthState } from "../../../network/bandwidth-estimator.js";
+import { PresentationDurationResolver } from "../../behaviors/calculate-presentation-duration.js";
+import { ParsePresentation } from "../../behaviors/resolve-presentation.js";
+
+//#region src/playback/engines/hls/engine.d.ts
+/**
+ * State shape for the HLS playback engine.
+ *
+ * This is the union of all state required by the behaviors composed into
+ * the HLS engine. Each behavior declares its own state interface; this
+ * type satisfies all of them.
+ */
+interface SimpleHlsEngineState {
+  /**
+   * The presentation being played. A caller writes `{ url }`;
+   * `resolvePresentation` parses the manifest and populates the rest.
+   */
+  presentation?: MaybeResolvedPresentation;
+  preload?: 'auto' | 'metadata' | 'none';
+  selectedVideoTrackId?: string;
+  selectedAudioTrackId?: string;
+  selectedTextTrackId?: string;
+  bandwidthState?: BandwidthState;
+  userVideoTrackSelection?: Partial<VideoTrack>;
+  currentTime?: number;
+  loadActivated?: boolean;
+}
+/**
+ * Context shape for the HLS playback engine.
+ *
+ * Platform objects and actor references managed by HLS behaviors.
+ */
+interface SimpleHlsEngineContext {
+  mediaElement?: HTMLMediaElement | undefined;
+  mediaSource?: MediaSource;
+  videoBufferActor?: SourceBufferActor;
+  audioBufferActor?: SourceBufferActor;
+  videoSegmentLoaderActor?: SegmentLoaderActor;
+  audioSegmentLoaderActor?: SegmentLoaderActor;
+  textTracksActor?: TextTracksActor;
+  textTrackSegmentLoaderActor?: TextTrackSegmentLoaderActor;
+}
+/**
+ * The composition signal refs handed to `onSignalsReady` callers — the
+ * canonical way to drive the engine externally (writes) or observe its
+ * state (reads) without touching `composition.state` / `composition.context`
+ * directly.
+ */
+type SimpleHlsEngineSignals = {
+  state: StateSignals<SimpleHlsEngineState>;
+  context: ContextSignals<SimpleHlsEngineContext>;
+};
+/**
+ * Configuration for the HLS playback engine.
+ *
+ * Each option is consumed by the appropriate behavior — the engine itself
+ * has no config beyond what its behaviors read.
+ */
+interface SimpleHlsEngineConfig extends ShareSignalsConfig<SimpleHlsEngineState, SimpleHlsEngineContext> {
+  /**
+   * Bandwidth estimate in bps to use before enough samples have been
+   * collected. Default: `DEFAULT_INITIAL_BANDWIDTH` (5 Mbps).
+   */
+  initialBandwidth?: number;
+  preferredAudioLanguage?: string;
+  preferredSubtitleLanguage?: string;
+  includeForcedTracks?: boolean;
+  enableDefaultTrack?: boolean;
+  /**
+   * Resolver that turns a text-track segment fetch into VTT cues.
+   * Defaults to the DOM-bound `resolveVttSegment` resolver, which uses an
+   * offscreen `<track>` element to parse WebVTT.
+   */
+  resolveTextTrackSegment?: TextTrackSegmentResolver<VTTCue>;
+  /**
+   * Resolver for `presentation.duration`. Defaults to picking the first
+   * resolved selected track's duration (video preferred, audio fallback) —
+   * appropriate for VoD and audio-only. Live engines should supply a
+   * resolver that returns `Number.POSITIVE_INFINITY` once the presentation
+   * is established as live; downstream `updateMediaSourceDuration` propagates
+   * that value to `mediaSource.duration` per the MSE spec.
+   */
+  resolveDuration?: PresentationDurationResolver;
+  /**
+   * Manifest parser handed to `resolvePresentation`. Defaults to the HLS
+   * multivariant-playlist parser; supply your own for alternate format
+   * support without forking the engine.
+   */
+  parsePresentation?: ParsePresentation;
+  /**
+   * Allocate SPF-owned text-track slots on the media element. Defaults to
+   * the standard `<track>`-element implementation in
+   * `media/dom/text/text-track-slots`.
+   */
+  addSubtitlesTracksToMedia?: typeof addSubtitlesTracksToMedia;
+  /**
+   * Return the SPF-owned subtitle/caption `TextTrack` currently in showing
+   * mode. Defaults to the standard selector-based implementation in
+   * `media/dom/text/text-track-slots`.
+   */
+  getShowingSubtitlesTrackFromMedia?: typeof getShowingSubtitlesTrackFromMedia;
+  /**
+   * Evict all SPF-owned text-track slots from the media element. Defaults to
+   * the standard selector-based implementation in
+   * `media/dom/text/text-track-slots`.
+   */
+  removeAllSubtitlesTracksFromMedia?: typeof removeAllSubtitlesTracksFromMedia;
+  /**
+   * Forward-buffer tuning. `bufferDuration` controls how far ahead of the
+   * playhead segments are loaded (and where forward-flush kicks in).
+   * Defaults: see `DEFAULT_FORWARD_BUFFER_CONFIG` (30 seconds). Threaded to
+   * segment-loader actors (v/a + text) at construction time and to
+   * `loadXSegments` dispatchers for the load-message range.
+   */
+  forwardBuffer?: Partial<ForwardBufferConfig>;
+  /**
+   * Back-buffer tuning. `keepSegments` controls how many segments stay
+   * behind the playhead before eviction. Defaults: see
+   * `DEFAULT_BACK_BUFFER_CONFIG` (2 segments). Threaded to the v/a
+   * segment-loader actor only (text tracks don't use back-buffer eviction).
+   */
+  backBuffer?: Partial<BackBufferConfig>;
+  /**
+   * Bandwidth-estimator tuning. Overrides any field of `BandwidthConfig`
+   * (`fastHalfLife`, `slowHalfLife`, `minTotalBytes`, `minBytes`,
+   * `minDuration`). `bandwidth.minTotalBytes` supersedes the flat
+   * `minTotalBytes` field above. Defaults: see `DEFAULT_BANDWIDTH_CONFIG`.
+   */
+  bandwidth?: Partial<BandwidthConfig>;
+  /**
+   * Quality-selection tuning. `safetyMargin` is the bandwidth-headroom
+   * multiplier used by `selectQuality`; `upgradeMargin` is the hysteresis
+   * ratio gating ABR upgrades. Defaults: `DEFAULT_QUALITY_CONFIG` (0.85 / 1.15).
+   */
+  quality?: Partial<QualityConfig>;
+}
+/**
+ * Create an HLS playback engine.
+ *
+ * Composes SPF behaviors into a reactive pipeline for HLS playback over MSE:
+ * manifest resolution, track selection, ABR, segment loading, and
+ * end-of-stream coordination.
+ *
+ * @example
+ * ```ts
+ * let signals: SimpleHlsEngineSignals;
+ * const engine = createSimpleHlsEngine({
+ *   initialBandwidth: 2_000_000,
+ *   preferredAudioLanguage: 'en',
+ *   onSignalsReady: (refs) => {
+ *     signals = refs;
+ *   },
+ * });
+ *
+ * signals.context.mediaElement.set(videoEl);
+ * signals.state.presentation.set({ url: 'https://example.com/stream.m3u8' });
+ *
+ * videoEl.play();
+ *
+ * await engine.destroy();
+ * ```
+ */
+declare function createSimpleHlsEngine(config?: SimpleHlsEngineConfig): Composition<SimpleHlsEngineState, SimpleHlsEngineContext>;
+//#endregion
+export { SimpleHlsEngineConfig, SimpleHlsEngineContext, SimpleHlsEngineSignals, SimpleHlsEngineState, createSimpleHlsEngine };
+//# sourceMappingURL=engine.d.ts.map

package/dist/dev/playback/engines/hls/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","names":[],"sources":["../../../../../src/playback/engines/hls/engine.ts"],"mappings":";;;;;;;;;;;;;;;;;;;AAsDA;;;;UAAiB,oBAAA;EAWmB;;;;EANlC,YAAA,GAAe,yBAAA;EACf,OAAA;EACA,oBAAA;EACA,oBAAA;EACA,mBAAA;EACA,cAAA,GAAiB,cAAA;EACjB,uBAAA,GAA0B,OAAA,CAAQ,UAAA;EAClC,WAAA;EACA,aAAA;AAAA;;;;;;UAQe,sBAAA;EACf,YAAA,GAAe,gBAAA;EACf,WAAA,GAAc,WAAA;EACd,gBAAA,GAAmB,iBAAA;EACnB,gBAAA,GAAmB,iBAAA;EACnB,uBAAA,GAA0B,kBAAA;EAC1B,uBAAA,GAA0B,kBAAA;EAC1B,eAAA,GAAkB,eAAA;EAClB,2BAAA,GAA8B,2BAAA;AAAA;;;;;;;KASpB,sBAAA;EACV,KAAA,EAAO,YAAA,CAAa,oBAAA;EACpB,OAAA,EAAS,cAAA,CAAe,sBAAA;AAAA;;;;;;;UAST,qBAAA,SAA8B,kBAAA,CAAmB,oBAAA,EAAsB,sBAAA;EApBtF;;;;EAyBA,gBAAA;EACA,sBAAA;EACA,yBAAA;EACA,mBAAA;EACA,kBAAA;EAlBwB;;;;;EAwBxB,uBAAA,GAA0B,wBAAA,CAAyB,MAAA;EAzB/B;;;;;;AAUtB;;EAwBE,eAAA,GAAkB,4BAAA;EAxB8C;;;;;EA8BhE,iBAAA,GAAoB,iBAAA;EAMe;;;;;EAAnC,yBAAA,UAAmC,yBAAA;EA2BtB;;;;;EArBb,iCAAA,UAA2C,iCAAA;EA1CoB;;;;;EAgD/D,iCAAA,UAA2C,iCAAA;EA1C3C;;;;;;;EAkDA,aAAA,GAAgB,OAAA,CAAQ,mBAAA;EAhCN;;;;;;EAuClB,UAAA,GAAa,OAAA,CAAQ,gBAAA;EAfrB;;;;;;EAsBA,SAAA,GAAY,OAAA,CAAQ,eAAA;EAPC;;;;;EAarB,OAAA,GAAU,OAAA,CAAQ,aAAA;AAAA;;;AAwCpB;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,qBAAA,CACd,MAAA,GAAQ,qBAAA,GACP,WAAA,CAAY,oBAAA,EAAsB,sBAAA"}

package/dist/dev/playback/engines/hls/engine.js

@@ -0,0 +1,102 @@
+import { createComposition } from "../../../core/composition/create-composition.js";
+import { makeShareSignals } from "../../../core/composition/share-signals.js";
+import { resolveVttSegment } from "../../../media/dom/text/resolve-vtt-segment.js";
+import { loadAudioSegments, loadTextTrackSegments, loadVideoSegments } from "../../behaviors/dom/load-segments.js";
+import { setupTextTrackActors } from "../../behaviors/dom/setup-text-track-actors.js";
+import { trackCurrentTime } from "../../behaviors/dom/track-current-time.js";
+import { trackLoadTriggers } from "../../behaviors/dom/track-load-triggers.js";
+import { addSubtitlesTracksToMedia, getShowingSubtitlesTrackFromMedia, removeAllSubtitlesTracksFromMedia } from "../../../media/dom/text/text-track-slots.js";
+import { parseMultivariantPlaylist } from "../../../media/hls/parse-multivariant.js";
+import { getResolvedSelectedTrackDuration } from "../../../media/utils/track-selection.js";
+import { calculatePresentationDuration } from "../../behaviors/calculate-presentation-duration.js";
+import { endOfStream } from "../../behaviors/dom/end-of-stream.js";
+import { setupAudioBufferActors, setupVideoBufferActors } from "../../behaviors/dom/setup-buffer-actors.js";
+import { setupMediaSource } from "../../behaviors/dom/setup-mediasource.js";
+import { syncTextTracks } from "../../behaviors/dom/sync-text-tracks.js";
+import { updateMediaSourceDuration } from "../../behaviors/dom/update-mediasource-duration.js";
+import { switchVideoQuality } from "../../behaviors/quality-switching.js";
+import { resolvePresentation } from "../../behaviors/resolve-presentation.js";
+import { resolveAudioTrack, resolveTextTrack, resolveVideoTrack } from "../../behaviors/resolve-track.js";
+import { selectAudioTrack, selectTextTrack } from "../../behaviors/select-tracks.js";
+import { syncPreload } from "../../behaviors/sync-preload.js";
+//#region src/playback/engines/hls/engine.ts
+/**
+* Generic `shareSignals` instantiated against the HLS engine's full state
+* and context — captures composition signal refs into the consumer's
+* `onSignalsReady` callback at setup time.
+*/
+const shareSignals = makeShareSignals();
+/**
+* Create an HLS playback engine.
+*
+* Composes SPF behaviors into a reactive pipeline for HLS playback over MSE:
+* manifest resolution, track selection, ABR, segment loading, and
+* end-of-stream coordination.
+*
+* @example
+* ```ts
+* let signals: SimpleHlsEngineSignals;
+* const engine = createSimpleHlsEngine({
+*   initialBandwidth: 2_000_000,
+*   preferredAudioLanguage: 'en',
+*   onSignalsReady: (refs) => {
+*     signals = refs;
+*   },
+* });
+*
+* signals.context.mediaElement.set(videoEl);
+* signals.state.presentation.set({ url: 'https://example.com/stream.m3u8' });
+*
+* videoEl.play();
+*
+* await engine.destroy();
+* ```
+*/
+function createSimpleHlsEngine(config = {}) {
+	const finalConfig = {
+		...config,
+		resolveTextTrackSegment: config.resolveTextTrackSegment ?? resolveVttSegment,
+		resolveDuration: config.resolveDuration ?? getResolvedSelectedTrackDuration,
+		parsePresentation: config.parsePresentation ?? parseMultivariantPlaylist,
+		addSubtitlesTracksToMedia: config.addSubtitlesTracksToMedia ?? addSubtitlesTracksToMedia,
+		getShowingSubtitlesTrackFromMedia: config.getShowingSubtitlesTrackFromMedia ?? getShowingSubtitlesTrackFromMedia,
+		removeAllSubtitlesTracksFromMedia: config.removeAllSubtitlesTracksFromMedia ?? removeAllSubtitlesTracksFromMedia
+	};
+	return createComposition([
+		syncPreload,
+		trackLoadTriggers,
+		resolvePresentation,
+		selectAudioTrack,
+		selectTextTrack,
+		resolveVideoTrack,
+		resolveAudioTrack,
+		resolveTextTrack,
+		calculatePresentationDuration,
+		setupMediaSource,
+		updateMediaSourceDuration,
+		setupVideoBufferActors,
+		setupAudioBufferActors,
+		trackCurrentTime,
+		switchVideoQuality,
+		loadVideoSegments,
+		loadAudioSegments,
+		endOfStream,
+		syncTextTracks,
+		setupTextTrackActors,
+		loadTextTrackSegments,
+		shareSignals
+	], {
+		config: finalConfig,
+		initialState: { bandwidthState: {
+			fastEstimate: 0,
+			fastTotalWeight: 0,
+			slowEstimate: 0,
+			slowTotalWeight: 0,
+			bytesSampled: 0
+		} }
+	});
+}
+//#endregion
+export { createSimpleHlsEngine };
+
+//# sourceMappingURL=engine.js.map

package/dist/dev/playback/engines/hls/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","names":[],"sources":["../../../../../src/playback/engines/hls/engine.ts"],"sourcesContent":["import {\n  type Composition,\n  type ContextSignals,\n  createComposition,\n  type StateSignals,\n} from '../../../core/composition/create-composition';\nimport { makeShareSignals, type ShareSignalsConfig } from '../../../core/composition/share-signals';\nimport type { QualityConfig } from '../../../media/abr/quality-selection';\nimport type { BackBufferConfig } from '../../../media/buffer/back-buffer';\nimport type { ForwardBufferConfig } from '../../../media/buffer/forward-buffer';\nimport { resolveVttSegment } from '../../../media/dom/text/resolve-vtt-segment';\nimport {\n  addSubtitlesTracksToMedia,\n  getShowingSubtitlesTrackFromMedia,\n  removeAllSubtitlesTracksFromMedia,\n} from '../../../media/dom/text/text-track-slots';\nimport { parseMultivariantPlaylist } from '../../../media/hls/parse-multivariant';\nimport type { MaybeResolvedPresentation, VideoTrack } from '../../../media/types';\nimport { getResolvedSelectedTrackDuration } from '../../../media/utils/track-selection';\nimport type { BandwidthConfig, BandwidthState } from '../../../network/bandwidth-estimator';\nimport type { SegmentLoaderActor } from '../../actors/dom/segment-loader';\nimport type { SourceBufferActor } from '../../actors/dom/source-buffer';\nimport type { TextTracksActor } from '../../actors/dom/text-tracks';\nimport type { TextTrackSegmentLoaderActor, TextTrackSegmentResolver } from '../../actors/text-track-segment-loader';\nimport {\n  calculatePresentationDuration,\n  type PresentationDurationResolver,\n} from '../../behaviors/calculate-presentation-duration';\nimport { endOfStream } from '../../behaviors/dom/end-of-stream';\nimport { loadAudioSegments, loadTextTrackSegments, loadVideoSegments } from '../../behaviors/dom/load-segments';\nimport { setupAudioBufferActors, setupVideoBufferActors } from '../../behaviors/dom/setup-buffer-actors';\nimport { setupMediaSource } from '../../behaviors/dom/setup-mediasource';\nimport { setupTextTrackActors } from '../../behaviors/dom/setup-text-track-actors';\nimport { syncTextTracks } from '../../behaviors/dom/sync-text-tracks';\nimport { trackCurrentTime } from '../../behaviors/dom/track-current-time';\nimport { trackLoadTriggers } from '../../behaviors/dom/track-load-triggers';\nimport { updateMediaSourceDuration } from '../../behaviors/dom/update-mediasource-duration';\nimport { switchVideoQuality } from '../../behaviors/quality-switching';\nimport { type ParsePresentation, resolvePresentation } from '../../behaviors/resolve-presentation';\nimport { resolveAudioTrack, resolveTextTrack, resolveVideoTrack } from '../../behaviors/resolve-track';\nimport { selectAudioTrack, selectTextTrack } from '../../behaviors/select-tracks';\nimport { syncPreload } from '../../behaviors/sync-preload';\n\n// ============================================================================\n// HLS Engine State & Context\n// ============================================================================\n\n/**\n * State shape for the HLS playback engine.\n *\n * This is the union of all state required by the behaviors composed into\n * the HLS engine. Each behavior declares its own state interface; this\n * type satisfies all of them.\n */\nexport interface SimpleHlsEngineState {\n  /**\n   * The presentation being played. A caller writes `{ url }`;\n   * `resolvePresentation` parses the manifest and populates the rest.\n   */\n  presentation?: MaybeResolvedPresentation;\n  preload?: 'auto' | 'metadata' | 'none';\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n  selectedTextTrackId?: string;\n  bandwidthState?: BandwidthState;\n  userVideoTrackSelection?: Partial<VideoTrack>;\n  currentTime?: number;\n  loadActivated?: boolean;\n}\n\n/**\n * Context shape for the HLS playback engine.\n *\n * Platform objects and actor references managed by HLS behaviors.\n */\nexport interface SimpleHlsEngineContext {\n  mediaElement?: HTMLMediaElement | undefined;\n  mediaSource?: MediaSource;\n  videoBufferActor?: SourceBufferActor;\n  audioBufferActor?: SourceBufferActor;\n  videoSegmentLoaderActor?: SegmentLoaderActor;\n  audioSegmentLoaderActor?: SegmentLoaderActor;\n  textTracksActor?: TextTracksActor;\n  textTrackSegmentLoaderActor?: TextTrackSegmentLoaderActor;\n}\n\n/**\n * The composition signal refs handed to `onSignalsReady` callers — the\n * canonical way to drive the engine externally (writes) or observe its\n * state (reads) without touching `composition.state` / `composition.context`\n * directly.\n */\nexport type SimpleHlsEngineSignals = {\n  state: StateSignals<SimpleHlsEngineState>;\n  context: ContextSignals<SimpleHlsEngineContext>;\n};\n\n/**\n * Configuration for the HLS playback engine.\n *\n * Each option is consumed by the appropriate behavior — the engine itself\n * has no config beyond what its behaviors read.\n */\nexport interface SimpleHlsEngineConfig extends ShareSignalsConfig<SimpleHlsEngineState, SimpleHlsEngineContext> {\n  /**\n   * Bandwidth estimate in bps to use before enough samples have been\n   * collected. Default: `DEFAULT_INITIAL_BANDWIDTH` (5 Mbps).\n   */\n  initialBandwidth?: number;\n  preferredAudioLanguage?: string;\n  preferredSubtitleLanguage?: string;\n  includeForcedTracks?: boolean;\n  enableDefaultTrack?: boolean;\n  /**\n   * Resolver that turns a text-track segment fetch into VTT cues.\n   * Defaults to the DOM-bound `resolveVttSegment` resolver, which uses an\n   * offscreen `<track>` element to parse WebVTT.\n   */\n  resolveTextTrackSegment?: TextTrackSegmentResolver<VTTCue>;\n  /**\n   * Resolver for `presentation.duration`. Defaults to picking the first\n   * resolved selected track's duration (video preferred, audio fallback) —\n   * appropriate for VoD and audio-only. Live engines should supply a\n   * resolver that returns `Number.POSITIVE_INFINITY` once the presentation\n   * is established as live; downstream `updateMediaSourceDuration` propagates\n   * that value to `mediaSource.duration` per the MSE spec.\n   */\n  resolveDuration?: PresentationDurationResolver;\n  /**\n   * Manifest parser handed to `resolvePresentation`. Defaults to the HLS\n   * multivariant-playlist parser; supply your own for alternate format\n   * support without forking the engine.\n   */\n  parsePresentation?: ParsePresentation;\n  /**\n   * Allocate SPF-owned text-track slots on the media element. Defaults to\n   * the standard `<track>`-element implementation in\n   * `media/dom/text/text-track-slots`.\n   */\n  addSubtitlesTracksToMedia?: typeof addSubtitlesTracksToMedia;\n  /**\n   * Return the SPF-owned subtitle/caption `TextTrack` currently in showing\n   * mode. Defaults to the standard selector-based implementation in\n   * `media/dom/text/text-track-slots`.\n   */\n  getShowingSubtitlesTrackFromMedia?: typeof getShowingSubtitlesTrackFromMedia;\n  /**\n   * Evict all SPF-owned text-track slots from the media element. Defaults to\n   * the standard selector-based implementation in\n   * `media/dom/text/text-track-slots`.\n   */\n  removeAllSubtitlesTracksFromMedia?: typeof removeAllSubtitlesTracksFromMedia;\n  /**\n   * Forward-buffer tuning. `bufferDuration` controls how far ahead of the\n   * playhead segments are loaded (and where forward-flush kicks in).\n   * Defaults: see `DEFAULT_FORWARD_BUFFER_CONFIG` (30 seconds). Threaded to\n   * segment-loader actors (v/a + text) at construction time and to\n   * `loadXSegments` dispatchers for the load-message range.\n   */\n  forwardBuffer?: Partial<ForwardBufferConfig>;\n  /**\n   * Back-buffer tuning. `keepSegments` controls how many segments stay\n   * behind the playhead before eviction. Defaults: see\n   * `DEFAULT_BACK_BUFFER_CONFIG` (2 segments). Threaded to the v/a\n   * segment-loader actor only (text tracks don't use back-buffer eviction).\n   */\n  backBuffer?: Partial<BackBufferConfig>;\n  /**\n   * Bandwidth-estimator tuning. Overrides any field of `BandwidthConfig`\n   * (`fastHalfLife`, `slowHalfLife`, `minTotalBytes`, `minBytes`,\n   * `minDuration`). `bandwidth.minTotalBytes` supersedes the flat\n   * `minTotalBytes` field above. Defaults: see `DEFAULT_BANDWIDTH_CONFIG`.\n   */\n  bandwidth?: Partial<BandwidthConfig>;\n  /**\n   * Quality-selection tuning. `safetyMargin` is the bandwidth-headroom\n   * multiplier used by `selectQuality`; `upgradeMargin` is the hysteresis\n   * ratio gating ABR upgrades. Defaults: `DEFAULT_QUALITY_CONFIG` (0.85 / 1.15).\n   */\n  quality?: Partial<QualityConfig>;\n}\n\n// ============================================================================\n// HLS Playback Engine\n// ============================================================================\n\n/**\n * Generic `shareSignals` instantiated against the HLS engine's full state\n * and context — captures composition signal refs into the consumer's\n * `onSignalsReady` callback at setup time.\n */\nconst shareSignals = makeShareSignals<SimpleHlsEngineState, SimpleHlsEngineContext>();\n\n/**\n * Create an HLS playback engine.\n *\n * Composes SPF behaviors into a reactive pipeline for HLS playback over MSE:\n * manifest resolution, track selection, ABR, segment loading, and\n * end-of-stream coordination.\n *\n * @example\n * ```ts\n * let signals: SimpleHlsEngineSignals;\n * const engine = createSimpleHlsEngine({\n *   initialBandwidth: 2_000_000,\n *   preferredAudioLanguage: 'en',\n *   onSignalsReady: (refs) => {\n *     signals = refs;\n *   },\n * });\n *\n * signals.context.mediaElement.set(videoEl);\n * signals.state.presentation.set({ url: 'https://example.com/stream.m3u8' });\n *\n * videoEl.play();\n *\n * await engine.destroy();\n * ```\n */\nexport function createSimpleHlsEngine(\n  config: SimpleHlsEngineConfig = {}\n): Composition<SimpleHlsEngineState, SimpleHlsEngineContext> {\n  const finalConfig = {\n    ...config,\n    resolveTextTrackSegment: config.resolveTextTrackSegment ?? resolveVttSegment,\n    resolveDuration: config.resolveDuration ?? getResolvedSelectedTrackDuration,\n    parsePresentation: config.parsePresentation ?? parseMultivariantPlaylist,\n    addSubtitlesTracksToMedia: config.addSubtitlesTracksToMedia ?? addSubtitlesTracksToMedia,\n    getShowingSubtitlesTrackFromMedia: config.getShowingSubtitlesTrackFromMedia ?? getShowingSubtitlesTrackFromMedia,\n    removeAllSubtitlesTracksFromMedia: config.removeAllSubtitlesTracksFromMedia ?? removeAllSubtitlesTracksFromMedia,\n  };\n\n  return createComposition(\n    [\n      syncPreload,\n      trackLoadTriggers,\n      resolvePresentation,\n\n      // Track selection (reads config for initial preferences).\n      // Video selection lives in switchVideoQuality, which owns the\n      // default-pick + ABR-driven adjustment for selectedVideoTrackId.\n      selectAudioTrack,\n      selectTextTrack,\n\n      // Resolve selected tracks (fetch media playlists)\n      resolveVideoTrack,\n      resolveAudioTrack,\n      resolveTextTrack,\n\n      // Presentation duration\n      calculatePresentationDuration,\n\n      // MSE setup. Video cluster is registered first so that, when both\n      // per-type variants flip to `'buffer-ready'` on the shared gate's\n      // monitor evaluation, `addSourceBuffer(video)` runs before\n      // `addSourceBuffer(audio)` — see the Firefox `mozHasAudio` invariant\n      // in setup-buffer-actors.ts.\n      setupMediaSource,\n      updateMediaSourceDuration,\n      setupVideoBufferActors,\n      setupAudioBufferActors,\n\n      // Playback tracking\n      trackCurrentTime,\n      switchVideoQuality,\n\n      // Segment loading\n      loadVideoSegments,\n      loadAudioSegments,\n\n      // End of stream coordination\n      endOfStream,\n\n      // Text tracks\n      syncTextTracks,\n      setupTextTrackActors,\n      loadTextTrackSegments,\n\n      // Behavior whose sole purpose is to use a callback to allow for signal writing from the outside (e.g. an adapter)\n      // NOTE: While not required, adding at the end since behaviors are setup in order, so this increases the likelihood\n      // that initial signal setup will have occurred before shareSignals' callback is invoked. (CJP)\n      shareSignals,\n    ],\n    {\n      config: finalConfig,\n      // Seed bandwidthState so switchVideoQuality fires on initial subscribe\n      // with the `initialBandwidth` fallback rather than waiting for the\n      // first chunk. The empty sample buffer means `getBandwidthEstimate`\n      // returns the configured initial bandwidth until real samples land.\n      initialState: {\n        bandwidthState: {\n          fastEstimate: 0,\n          fastTotalWeight: 0,\n          slowEstimate: 0,\n          slowTotalWeight: 0,\n          bytesSampled: 0,\n        },\n      },\n    }\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA+LA,MAAM,eAAe,kBAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BrF,SAAgB,sBACd,SAAgC,EAAE,EACyB;CAC3D,MAAM,cAAc;EAClB,GAAG;EACH,yBAAyB,OAAO,2BAA2B;EAC3D,iBAAiB,OAAO,mBAAmB;EAC3C,mBAAmB,OAAO,qBAAqB;EAC/C,2BAA2B,OAAO,6BAA6B;EAC/D,mCAAmC,OAAO,qCAAqC;EAC/E,mCAAmC,OAAO,qCAAqC;EAChF;AAED,QAAO,kBACL;EACE;EACA;EACA;EAKA;EACA;EAGA;EACA;EACA;EAGA;EAOA;EACA;EACA;EACA;EAGA;EACA;EAGA;EACA;EAGA;EAGA;EACA;EACA;EAKA;EACD,EACD;EACE,QAAQ;EAKR,cAAc,EACZ,gBAAgB;GACd,cAAc;GACd,iBAAiB;GACjB,cAAc;GACd,iBAAiB;GACjB,cAAc;GACf,EACF;EACF,CACF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@videojs/spf",
   "type": "module",
-  "version": "10.0.0-beta.22",
+  "version": "10.0.0-beta.24",
   "description": "Stream Processing Framework for Video.js 10",
   "license": "Apache-2.0",
   "repository": {
@@ -28,10 +28,10 @@
       "development": "./dist/dev/dom.js",
       "default": "./dist/default/dom.js"
     },
-    "./playback-engine": {
-      "types": "./dist/dev/dom/playback-engine.d.ts",
-      "development": "./dist/dev/dom/playback-engine.js",
-      "default": "./dist/default/dom/playback-engine.js"
+    "./hls": {
+      "types": "./dist/dev/hls.d.ts",
+      "development": "./dist/dev/hls.js",
+      "default": "./dist/default/hls.js"
     }
   },
   "main": "dist/default/index.js",
@@ -42,7 +42,7 @@
   ],
   "dependencies": {
     "signal-polyfill": "^0.2.2",
-    "@videojs/utils": "10.0.0-beta.22"
+    "@videojs/utils": "10.0.0-beta.24"
   },
   "devDependencies": {
     "@vitest/browser": "^4.1.0",
@@ -50,8 +50,7 @@
     "@vitest/coverage-v8": "^4.1.0",
     "jsdom": "^26.1.0",
     "playwright": "^1.59.1",
-    "tsdown": "^0.21.4",
-    "typescript": "^6.0.2",
+    "tsdown": "^0.21.9",
     "vitest": "^4.1.0"
   },
   "publishConfig": {
@@ -64,7 +63,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "clean": "rimraf --glob dist types '*.tsbuildinfo'",
-    "size": "node scripts/measure-size.js --playback-engine",
+    "size": "node scripts/measure-size.js --hls",
     "size:all": "node scripts/measure-size.js --all"
   }
 }

package/dist/default/core/abr/bandwidth-estimator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bandwidth-estimator.js","names":[],"sources":["../../../../src/core/abr/bandwidth-estimator.ts"],"sourcesContent":["/**\n * Dual EWMA Bandwidth Estimator\n *\n * Estimates available bandwidth using two EWMA calculations with different\n * half-lives, taking the minimum of both. This approach (from Shaka Player):\n *\n * - **Fast EWMA** (2s half-life): Reacts quickly to bandwidth drops\n * - **Slow EWMA** (5s half-life): Provides stability during fluctuations\n * - **min(fast, slow)**: Adapts down quickly, up slowly\n *\n * This naturally provides asymmetric behavior needed for good QoE:\n * avoiding stalls (quick downgrade) while preventing oscillation (slow upgrade).\n */\n\nimport { applyZeroFactor, calculateEwma } from './ewma';\n\n/**\n * Bandwidth estimator state.\n *\n * This state structure will be managed by O1 (State Container).\n * Functions in this module operate on this state immutably.\n */\nexport interface BandwidthState {\n  /** Fast-moving EWMA estimate (raw, uncorrected). */\n  fastEstimate: number;\n  /** Total weight accumulated in fast EWMA. */\n  fastTotalWeight: number;\n  /** Slow-moving EWMA estimate (raw, uncorrected). */\n  slowEstimate: number;\n  /** Total weight accumulated in slow EWMA. */\n  slowTotalWeight: number;\n  /** Total bytes sampled across all valid samples. */\n  bytesSampled: number;\n}\n\n/**\n * Configuration for bandwidth estimation.\n */\nexport interface BandwidthConfig {\n  /** Half-life for fast EWMA in seconds. */\n  fastHalfLife: number;\n  /** Half-life for slow EWMA in seconds. */\n  slowHalfLife: number;\n  /** Minimum total bytes before trusting the estimate. */\n  minTotalBytes: number;\n  /** Minimum bytes per sample to count (filters TTFB-dominated samples). */\n  minBytes: number;\n  /** Minimum sample duration in ms (filters cached responses). */\n  minDuration: number;\n}\n\n/**\n * Default bandwidth estimator configuration.\n *\n * Values match Shaka Player defaults based on experimentation.\n */\nexport const DEFAULT_BANDWIDTH_CONFIG: BandwidthConfig = {\n  fastHalfLife: 2, // 2 seconds\n  slowHalfLife: 5, // 5 seconds\n  minTotalBytes: 128_000, // 128 KB\n  minBytes: 16_000, // 16 KB\n  minDuration: 5, // 5 ms\n};\n\n/**\n * Add a bandwidth sample from a segment download.\n *\n * Samples are filtered based on:\n * - Minimum bytes (filters TTFB-dominated small segments)\n * - Minimum duration (filters cached responses)\n *\n * Valid samples update both fast and slow EWMA estimates.\n *\n * @param state - Current estimator state\n * @param durationMs - Download duration in milliseconds\n * @param numBytes - Number of bytes downloaded\n * @param config - Optional estimator configuration (uses defaults if not provided)\n * @returns New estimator state with sample incorporated (or unchanged if filtered)\n *\n * @example\n * let state = { fastEstimate: 0, fastTotalWeight: 0, ... };\n * // Sample: 1MB in 1 second\n * state = sampleBandwidth(state, 1000, 1_000_000);\n */\nexport function sampleBandwidth(\n  state: BandwidthState,\n  durationMs: number,\n  numBytes: number,\n  config: BandwidthConfig = DEFAULT_BANDWIDTH_CONFIG\n): BandwidthState {\n  // Always track bytes for startup phase calculation\n  const updatedBytesSampled = state.bytesSampled + numBytes;\n\n  // Filter: Ignore samples below minimum bytes (TTFB-dominated)\n  // Small segments' download time is mostly connection setup latency,\n  // which would artificially lower our bandwidth estimate\n  if (numBytes < config.minBytes) {\n    return { ...state, bytesSampled: updatedBytesSampled };\n  }\n\n  // Filter: Ignore samples faster than minimum duration (cached responses)\n  // Cached responses load nearly instantly and would artificially inflate\n  // our bandwidth estimate\n  if (durationMs < config.minDuration) {\n    return { ...state, bytesSampled: updatedBytesSampled };\n  }\n\n  // Calculate bandwidth in bits per second\n  // Formula: (bytes * 8 bits/byte * 1000 ms/s) / ms = bits/s\n  const bandwidth = (8000 * numBytes) / durationMs;\n\n  // Weight by duration in seconds\n  // Longer downloads are more reliable indicators of true bandwidth\n  const weight = durationMs / 1000;\n\n  return {\n    fastEstimate: calculateEwma(state.fastEstimate, bandwidth, weight, config.fastHalfLife),\n    fastTotalWeight: state.fastTotalWeight + weight,\n    slowEstimate: calculateEwma(state.slowEstimate, bandwidth, weight, config.slowHalfLife),\n    slowTotalWeight: state.slowTotalWeight + weight,\n    bytesSampled: updatedBytesSampled,\n  };\n}\n\n/**\n * Get the current bandwidth estimate.\n *\n * Returns the **minimum** of the fast and slow EWMA estimates.\n * This provides the key asymmetric behavior:\n * - When bandwidth drops, fast EWMA reacts first and dominates (quick adaptation)\n * - When bandwidth rises, slow EWMA lags behind and dominates (slow adaptation)\n *\n * Uses default estimate until enough data has been sampled.\n *\n * @param state - Current estimator state\n * @param defaultEstimate - Fallback estimate before sufficient samples (bps)\n * @param config - Optional estimator configuration (uses defaults if not provided)\n * @returns Bandwidth estimate in bits per second\n *\n * @example\n * const estimate = getBandwidthEstimate(state, 5_000_000); // 5 Mbps default\n */\nexport function getBandwidthEstimate(\n  state: BandwidthState,\n  defaultEstimate: number,\n  config: BandwidthConfig = DEFAULT_BANDWIDTH_CONFIG\n): number {\n  // Use default until we have enough samples to trust our estimate\n  if (state.bytesSampled < config.minTotalBytes) {\n    return defaultEstimate;\n  }\n\n  // Apply zero-factor correction to both estimates\n  const fastEstimate = applyZeroFactor(state.fastEstimate, state.fastTotalWeight, config.fastHalfLife);\n\n  const slowEstimate = applyZeroFactor(state.slowEstimate, state.slowTotalWeight, config.slowHalfLife);\n\n  // Take the minimum - this is the key insight from Shaka Player\n  // It naturally provides \"down quickly, up slowly\" behavior\n  return Math.min(fastEstimate, slowEstimate);\n}\n\n/**\n * Check if the estimator has enough data to provide a reliable estimate.\n *\n * Requires both:\n * - Enough total bytes sampled (minTotalBytes threshold)\n * - At least one valid EWMA sample (totalWeight > 0)\n *\n * @param state - Current estimator state\n * @param config - Optional estimator configuration (uses defaults if not provided)\n * @returns True if we've sampled enough bytes to trust the estimate\n *\n * @example\n * if (hasGoodEstimate(state)) {\n *   const estimate = getBandwidthEstimate(state, 5_000_000);\n * }\n */\nexport function hasGoodEstimate(state: BandwidthState, config: BandwidthConfig = DEFAULT_BANDWIDTH_CONFIG): boolean {\n  // Need enough total bytes AND at least one valid EWMA sample\n  return state.bytesSampled >= config.minTotalBytes && state.fastTotalWeight > 0 && state.slowTotalWeight > 0;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAwDA,MAAa,2BAA4C;CACvD,cAAc;CACd,cAAc;CACd,eAAe;CACf,UAAU;CACV,aAAa;CACd;;;;;;;;;;;;;;;;;;;;;AAsBD,SAAgB,gBACd,OACA,YACA,UACA,SAA0B,0BACV;CAEhB,MAAM,sBAAsB,MAAM,eAAe;AAKjD,KAAI,WAAW,OAAO,SACpB,QAAO;EAAE,GAAG;EAAO,cAAc;EAAqB;AAMxD,KAAI,aAAa,OAAO,YACtB,QAAO;EAAE,GAAG;EAAO,cAAc;EAAqB;CAKxD,MAAM,YAAa,MAAO,WAAY;CAItC,MAAM,SAAS,aAAa;AAE5B,QAAO;EACL,cAAc,cAAc,MAAM,cAAc,WAAW,QAAQ,OAAO,aAAa;EACvF,iBAAiB,MAAM,kBAAkB;EACzC,cAAc,cAAc,MAAM,cAAc,WAAW,QAAQ,OAAO,aAAa;EACvF,iBAAiB,MAAM,kBAAkB;EACzC,cAAc;EACf;;;;;;;;;;;;;;;;;;;;AAqBH,SAAgB,qBACd,OACA,iBACA,SAA0B,0BAClB;AAER,KAAI,MAAM,eAAe,OAAO,cAC9B,QAAO;CAIT,MAAM,eAAe,gBAAgB,MAAM,cAAc,MAAM,iBAAiB,OAAO,aAAa;CAEpG,MAAM,eAAe,gBAAgB,MAAM,cAAc,MAAM,iBAAiB,OAAO,aAAa;AAIpG,QAAO,KAAK,IAAI,cAAc,aAAa"}

package/dist/default/core/abr/ewma.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ewma.js","names":[],"sources":["../../../../src/core/abr/ewma.ts"],"sourcesContent":["/**\n * Exponentially Weighted Moving Average (EWMA)\n *\n * Pure functional implementation of EWMA calculations.\n * Based on Shaka Player's EWMA algorithm.\n */\n\n/**\n * Calculate alpha (decay factor) from half-life.\n *\n * Alpha determines how quickly old data \"expires\":\n * - alpha close to 1 = slow decay (long memory)\n * - alpha close to 0 = fast decay (short memory)\n *\n * @param halfLife - The quantity of prior samples (by weight) that make up\n *   half of the new estimate. Must be positive.\n * @returns Alpha value between 0 and 1\n *\n * @example\n * const alpha = calculateAlpha(2); // ≈ 0.7071 for 2-second half-life\n */\nexport function calculateAlpha(halfLife: number): number {\n  return Math.exp(Math.log(0.5) / halfLife);\n}\n\n/**\n * Calculate exponentially weighted moving average.\n *\n * Updates an estimate by blending a new value with the previous estimate,\n * weighted by the sample duration. Longer samples have more influence.\n *\n * @param prevEstimate - Previous EWMA estimate\n * @param value - New sample value to incorporate\n * @param weight - Sample weight (typically duration in seconds)\n * @param halfLife - Half-life for decay (typically 2-5 seconds)\n * @returns Updated EWMA estimate\n *\n * @example\n * let estimate = 0;\n * estimate = calculateEwma(estimate, 1_000_000, 1, 2); // First sample\n * estimate = calculateEwma(estimate, 2_000_000, 1, 2); // Second sample\n */\nexport function calculateEwma(prevEstimate: number, value: number, weight: number, halfLife: number): number {\n  const alpha = calculateAlpha(halfLife);\n  const adjAlpha = alpha ** weight;\n  return value * (1 - adjAlpha) + adjAlpha * prevEstimate;\n}\n\n/**\n * Apply zero-factor correction to EWMA estimate.\n *\n * The zero-factor correction compensates for bias when starting from zero.\n * Without this correction, early estimates would be artificially low.\n *\n * As totalWeight increases, the correction factor approaches 1, meaning\n * the estimate becomes more reliable and needs less correction.\n *\n * @param estimate - Raw EWMA estimate (uncorrected)\n * @param totalWeight - Accumulated weight from all samples\n * @param halfLife - Half-life used in EWMA calculation\n * @returns Corrected estimate, or 0 if totalWeight is 0\n *\n * @example\n * const raw = calculateEwma(0, 1_000_000, 1, 2);\n * const corrected = applyZeroFactor(raw, 1, 2); // ≈ 1_000_000\n */\nexport function applyZeroFactor(estimate: number, totalWeight: number, halfLife: number): number {\n  if (totalWeight === 0) {\n    return 0;\n  }\n\n  const alpha = calculateAlpha(halfLife);\n  const zeroFactor = 1 - alpha ** totalWeight;\n  return estimate / zeroFactor;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,eAAe,UAA0B;AACvD,QAAO,KAAK,IAAI,KAAK,IAAI,GAAI,GAAG,SAAS;;;;;;;;;;;;;;;;;;;AAoB3C,SAAgB,cAAc,cAAsB,OAAe,QAAgB,UAA0B;CAE3G,MAAM,WADQ,eAAe,SAAS,IACZ;AAC1B,QAAO,SAAS,IAAI,YAAY,WAAW;;;;;;;;;;;;;;;;;;;;AAqB7C,SAAgB,gBAAgB,UAAkB,aAAqB,UAA0B;AAC/F,KAAI,gBAAgB,EAClB,QAAO;AAKT,QAAO,YADY,IADL,eAAe,SAAS,IACN"}

package/dist/default/core/abr/quality-selection.js

@@ -1,53 +0,0 @@
-//#region src/core/abr/quality-selection.ts
-/**
-* Default quality selection configuration.
-* Values match Shaka Player upgrade threshold (0.85 = 15% headroom).
-*/
-const DEFAULT_QUALITY_CONFIG = { safetyMargin: .85 };
-/**
-* Select the best video track based on current bandwidth estimate.
-*
-* Selects the highest quality track where bandwidth is sufficient with safety margin:
-* - currentBandwidth >= track.bandwidth / safetyMargin
-* - Default safetyMargin 0.85 means track uses ≤85% of bandwidth (15% headroom)
-* - At same bandwidth, prefers higher resolution
-*
-* @param tracks - Available video tracks (can be unsorted)
-* @param currentBandwidth - Current bandwidth estimate in bits per second
-* @param config - Optional quality selection configuration
-* @returns Selected track, or undefined if no tracks available
-*
-* @example
-* const tracks = [
-*   { id: '360p', bandwidth: 500_000, ... },
-*   { id: '720p', bandwidth: 2_000_000, ... },
-*   { id: '1080p', bandwidth: 4_000_000, ... },
-* ];
-*
-* // With 2.5 Mbps, selects 720p (1080p needs 4M/0.85 = 4.7 Mbps)
-* const selected = selectQuality(tracks, 2_500_000);
-*/
-function selectQuality(tracks, currentBandwidth, config = DEFAULT_QUALITY_CONFIG) {
-	if (tracks.length === 0) return;
-	const sortedTracks = tracks.slice().sort((a, b) => a.bandwidth - b.bandwidth);
-	let chosen;
-	for (const track of sortedTracks) if (currentBandwidth >= track.bandwidth / config.safetyMargin) {
-		if (!chosen || track.bandwidth > chosen.bandwidth || track.bandwidth === chosen.bandwidth && hasHigherResolution(track, chosen)) chosen = track;
-	}
-	return chosen ?? sortedTracks[0];
-}
-/**
-* Check if track A has higher resolution than track B.
-* Compares by total pixel count (width × height).
-*
-* @param trackA - First track to compare
-* @param trackB - Second track to compare
-* @returns True if trackA has more pixels than trackB
-*/
-function hasHigherResolution(trackA, trackB) {
-	return (trackA.width ?? 0) * (trackA.height ?? 0) > (trackB.width ?? 0) * (trackB.height ?? 0);
-}
-//#endregion
-export { selectQuality };
-
-//# sourceMappingURL=quality-selection.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"quality-selection.js","names":[],"sources":["../../../../src/core/abr/quality-selection.ts"],"sourcesContent":["/**\n * Quality Selection Algorithm\n *\n * Selects optimal video track based on bandwidth estimate with safety margin.\n * Stateless selection - picks highest quality that fits bandwidth.\n *\n * Key concepts:\n * - **Safety margin** (0.85): Pick track where bandwidth >= track.bandwidth / 0.85\n * - This ensures 15% headroom to avoid buffering\n * - At same bandwidth, prefer higher resolution\n */\n\nimport type { PartiallyResolvedVideoTrack } from '../types';\n\n/**\n * Quality selection configuration.\n */\nexport interface QualityConfig {\n  /**\n   * Safety margin (0-1).\n   * To select a track, need: currentBandwidth >= track.bandwidth / safetyMargin.\n   * Default 0.85 means track must use ≤85% of available bandwidth (15% headroom).\n   */\n  safetyMargin: number;\n}\n\n/**\n * Default quality selection configuration.\n * Values match Shaka Player upgrade threshold (0.85 = 15% headroom).\n */\nexport const DEFAULT_QUALITY_CONFIG: QualityConfig = {\n  safetyMargin: 0.85,\n};\n\n/**\n * Select the best video track based on current bandwidth estimate.\n *\n * Selects the highest quality track where bandwidth is sufficient with safety margin:\n * - currentBandwidth >= track.bandwidth / safetyMargin\n * - Default safetyMargin 0.85 means track uses ≤85% of bandwidth (15% headroom)\n * - At same bandwidth, prefers higher resolution\n *\n * @param tracks - Available video tracks (can be unsorted)\n * @param currentBandwidth - Current bandwidth estimate in bits per second\n * @param config - Optional quality selection configuration\n * @returns Selected track, or undefined if no tracks available\n *\n * @example\n * const tracks = [\n *   { id: '360p', bandwidth: 500_000, ... },\n *   { id: '720p', bandwidth: 2_000_000, ... },\n *   { id: '1080p', bandwidth: 4_000_000, ... },\n * ];\n *\n * // With 2.5 Mbps, selects 720p (1080p needs 4M/0.85 = 4.7 Mbps)\n * const selected = selectQuality(tracks, 2_500_000);\n */\nexport function selectQuality(\n  tracks: PartiallyResolvedVideoTrack[],\n  currentBandwidth: number,\n  config: QualityConfig = DEFAULT_QUALITY_CONFIG\n): PartiallyResolvedVideoTrack | undefined {\n  if (tracks.length === 0) {\n    return undefined;\n  }\n\n  // Sort tracks by bandwidth (lowest first)\n  const sortedTracks = tracks.slice().sort((a, b) => a.bandwidth - b.bandwidth);\n\n  // Start with no selection\n  let chosen: PartiallyResolvedVideoTrack | undefined;\n\n  for (const track of sortedTracks) {\n    // Check if we have enough bandwidth for this track with safety margin\n    // Required bandwidth = track.bandwidth / safetyMargin\n    const requiredBandwidth = track.bandwidth / config.safetyMargin;\n\n    if (currentBandwidth >= requiredBandwidth) {\n      // We can support this track - prefer it if better than current choice\n      if (\n        !chosen ||\n        track.bandwidth > chosen.bandwidth ||\n        (track.bandwidth === chosen.bandwidth && hasHigherResolution(track, chosen))\n      ) {\n        chosen = track;\n      }\n    }\n  }\n\n  // If no track fits with safety margin, fall back to lowest quality\n  return chosen ?? sortedTracks[0];\n}\n\n/**\n * Check if track A has higher resolution than track B.\n * Compares by total pixel count (width × height).\n *\n * @param trackA - First track to compare\n * @param trackB - Second track to compare\n * @returns True if trackA has more pixels than trackB\n */\nfunction hasHigherResolution(trackA: PartiallyResolvedVideoTrack, trackB: PartiallyResolvedVideoTrack): boolean {\n  const pixelsA = (trackA.width ?? 0) * (trackA.height ?? 0);\n  const pixelsB = (trackB.width ?? 0) * (trackB.height ?? 0);\n  return pixelsA > pixelsB;\n}\n"],"mappings":";;;;;AA8BA,MAAa,yBAAwC,EACnD,cAAc,KACf;;;;;;;;;;;;;;;;;;;;;;;;AAyBD,SAAgB,cACd,QACA,kBACA,SAAwB,wBACiB;AACzC,KAAI,OAAO,WAAW,EACpB;CAIF,MAAM,eAAe,OAAO,OAAO,CAAC,MAAM,GAAG,MAAM,EAAE,YAAY,EAAE,UAAU;CAG7E,IAAI;AAEJ,MAAK,MAAM,SAAS,aAKlB,KAAI,oBAFsB,MAAM,YAAY,OAAO;MAK/C,CAAC,UACD,MAAM,YAAY,OAAO,aACxB,MAAM,cAAc,OAAO,aAAa,oBAAoB,OAAO,OAAO,CAE3E,UAAS;;AAMf,QAAO,UAAU,aAAa;;;;;;;;;;AAWhC,SAAS,oBAAoB,QAAqC,QAA8C;AAG9G,SAFiB,OAAO,SAAS,MAAM,OAAO,UAAU,MACvC,OAAO,SAAS,MAAM,OAAO,UAAU"}

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

@@ -1 +0,0 @@
-{"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/default/core/buffer/forward-buffer.js.map

@@ -1 +0,0 @@
-{"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 Pick<Segment, 'startTime' | 'duration'>[],\n  currentTime: number,\n  config: ForwardBufferConfig = DEFAULT_FORWARD_BUFFER_CONFIG\n): Segment[] {\n  if (segments.length === 0) {\n    return [];\n  }\n\n  // Calculate target buffer end time\n  const targetTime = currentTime + config.bufferDuration;\n\n  // Create set of buffered segment start times for fast lookup\n  // V1 simple: if ANY segment is buffered at a given time, don't load for that time\n  // V2 (future): would compare by startTime + bitrate/track for quality switching\n  const bufferedStartTimes = new Set(bufferedSegments.map((seg) => seg.startTime));\n\n  // Find segments to load:\n  // - Overlaps buffer window [currentTime, targetTime)\n  // - Not already buffered at that time position\n  const toLoad = segments.filter((seg) => {\n    // Segment must overlap the buffer window\n    const segmentEnd = seg.startTime + seg.duration;\n    const isInRange = seg.startTime < targetTime && segmentEnd > currentTime;\n\n    // Must not have a segment buffered at this time position\n    const isNotBuffered = !bufferedStartTimes.has(seg.startTime);\n\n    return isInRange && isNotBuffered;\n  });\n\n  return toLoad;\n}\n"],"mappings":";;;;AAuBA,MAAa,gCAAqD,EAChE,gBAAgB,IACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDD,SAAgB,2BACd,kBACA,aACA,SAA8B,+BACtB;AACR,KAAI,iBAAiB,WAAW,EAAG,QAAO;CAE1C,MAAM,YAAY,cAAc,OAAO;CAGvC,MAAM,SAAS,iBAAiB,QAAQ,QAAQ,IAAI,aAAa,UAAU;AAE3E,KAAI,OAAO,WAAW,EAAG,QAAO;AAGhC,QAAO,KAAK,IAAI,GAAG,OAAO,KAAK,QAAQ,IAAI,UAAU,CAAC;;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"}