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

package/dist/dev/core/tasks/task.d.ts

@@ -2,42 +2,33 @@
 /** Recursively marks all properties as readonly. */
 type DeepReadonly<T> = T extends (infer U)[] ? ReadonlyArray<DeepReadonly<U>> : T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]>; } : T;
 type TaskStatus = 'pending' | 'running' | 'done' | 'error';
-/**
- * Configuration for a Task.
- */
+/** Configuration for a Task. */
 interface TaskConfig {
   /**
-   * Identifier for this task.
-   * - string: used as-is
-   * - () => string: called once at construction time
-   * - undefined: a unique ID is generated via generateId()
+   * Identifier for this task. - string: used as-is - () => string: called once at construction time - undefined: a
+   * unique ID is generated via generateId()
    */
   id?: string | (() => string);
   /**
-   * Optional external AbortSignal to compose with the task's internal one.
-   * The task's work is aborted when either the internal controller (via abort())
-   * or this external signal fires — whichever comes first.
+   * Optional external AbortSignal to compose with the task's internal one. The task's work is aborted when either the
+   * internal controller (via abort()) or this external signal fires — whichever comes first.
    */
   signal?: AbortSignal;
 }
-/**
- * Minimal contract for a schedulable unit of async work.
- */
+/** Minimal contract for a schedulable unit of async work. */
 interface TaskLike<TValue = void, TError = unknown> {
   readonly id: string;
   readonly status: TaskStatus;
   readonly value: DeepReadonly<TValue> | undefined;
   readonly error: DeepReadonly<TError> | undefined;
   /**
-   * The last successful value carried forward from the run this was `clone()`d
-   * from — the prior cycle's result for a `RecurringRunner` (undefined for an
-   * original, or until the lineage has produced a success).
+   * The last successful value carried forward from the run this was `clone()`d from — the prior cycle's result for a
+   * `RecurringRunner` (undefined for an original, or until the lineage has produced a success).
    */
   readonly previous: DeepReadonly<TValue> | undefined;
   /**
-   * The signal this task's work runs under (its own abort composed with any
-   * external one). Aborting the task fires it — so a `reschedule` can wait on it
-   * to have its delay cancelled when the recurrence is aborted.
+   * The signal this task's work runs under (its own abort composed with any external one). Aborting the task fires it —
+   * so a `reschedule` can wait on it to have its delay cancelled when the recurrence is aborted.
    */
   readonly signal: AbortSignal;
   /** Run the work, memoized: repeated calls share one execution + result. */
@@ -49,19 +40,16 @@ interface TaskLike<TValue = void, TError = unknown> {
 /**
  * Generic reusable task that wraps an async run function.
  *
- * Owns its own AbortController so it can always be aborted independently.
- * Optionally composes an external AbortSignal so that a parent's cancellation
- * propagates into the task's work without requiring the caller to track the
- * task separately.
+ * Owns its own AbortController so it can always be aborted independently. Optionally composes an external AbortSignal
+ * so that a parent's cancellation propagates into the task's work without requiring the caller to track the task
+ * separately.
  *
- * `run()` is memoized: the work runs at most once per instance, and every call
- * returns the same promise (so observers can `await run()` to read the result
- * without re-triggering the work). To re-run the *same* work, take a `clone()` —
- * a fresh instance with its own AbortController and a pending state.
+ * `run()` is memoized: the work runs at most once per instance, and every call returns the same promise (so observers
+ * can `await run()` to read the result without re-triggering the work). To re-run the _same_ work, take a `clone()` — a
+ * fresh instance with its own AbortController and a pending state.
  *
- * Ordering guarantee: `value` is written before `status` transitions to `'done'`;
- * `error` is written before `status` transitions to `'error'`. Any reader
- * observing `status === 'done'` is guaranteed `value` is already present.
+ * Ordering guarantee: `value` is written before `status` transitions to `'done'`; `error` is written before `status`
+ * transitions to `'error'`. Any reader observing `status === 'done'` is guaranteed `value` is already present.
  */
 declare class Task<TValue = void, TError = unknown> implements TaskLike<TValue, TError> {
   #private;
@@ -75,32 +63,28 @@ declare class Task<TValue = void, TError = unknown> implements TaskLike<TValue,
   run(): Promise<TValue>;
   abort(): void;
   /**
-   * A fresh task with the same work, id, and external signal, in a pending state
-   * (its own AbortController, no memoized result) — so it can be run again. Used
-   * to re-run structurally identical work (e.g. `RecurringRunner` reloads).
+   * A fresh task with the same work, id, and external signal, in a pending state (its own AbortController, no memoized
+   * result) — so it can be run again. Used to re-run structurally identical work (e.g. `RecurringRunner` reloads).
    *
-   * The clone inherits this run's value as its `previous` (or this run's own
-   * `previous` if it never produced one — e.g. it errored), so a recurrence's
-   * `previous` always tracks the last *successful* value across the lineage with
-   * no bookkeeping in the runner.
+   * The clone inherits this run's value as its `previous` (or this run's own `previous` if it never produced one — e.g.
+   * it errored), so a recurrence's `previous` always tracks the last _successful_ value across the lineage with no
+   * bookkeeping in the runner.
    */
   clone(): Task<TValue, TError>;
 }
 /**
  * Runs tasks concurrently, deduplicated by task id.
  *
- * If a task with a given id is already in flight, subsequent schedule() calls
- * for that id are silently ignored until the first completes. Tasks are stored
- * so abortAll() can cancel any in-flight work (e.g. on engine cleanup).
+ * If a task with a given id is already in flight, subsequent schedule() calls for that id are silently ignored until
+ * the first completes. Tasks are stored so abortAll() can cancel any in-flight work (e.g. on engine cleanup).
  */
 declare class ConcurrentRunner {
   #private;
   schedule<TValue = void, TError = unknown>(task: TaskLike<TValue, TError>): Promise<TValue>;
   /**
-   * Registers a callback to fire when all currently in-flight tasks settle.
-   * If the runner is already idle, the callback is never called. If abortAll()
-   * is called before the batch settles, the callback is superseded and silently
-   * dropped — no stale callbacks, no generation token required by the caller.
+   * Registers a callback to fire when all currently in-flight tasks settle. If the runner is already idle, the callback
+   * is never called. If abortAll() is called before the batch settles, the callback is superseded and silently dropped
+   * — no stale callbacks, no generation token required by the caller.
    */
   whenSettled(callback: () => void): void;
   abortAll(): void;
@@ -109,33 +93,28 @@ declare class ConcurrentRunner {
 /**
  * Runs tasks one at a time in submission order.
  *
- * Each schedule() call returns a Promise that resolves or rejects with the
- * task's result when it is eventually executed. Tasks wait in queue until the
- * prior task completes.
+ * Each schedule() call returns a Promise that resolves or rejects with the task's result when it is eventually
+ * executed. Tasks wait in queue until the prior task completes.
  *
- * Serialization is achieved by chaining each task's run() onto the tail of a
- * shared promise chain — no explicit queue or drain loop needed.
+ * Serialization is achieved by chaining each task's run() onto the tail of a shared promise chain — no explicit queue
+ * or drain loop needed.
  *
- * abortAll() aborts all pending (not yet started) tasks and the currently
- * in-flight task. Pending tasks still run briefly but receive an aborted
- * signal and are expected to exit early.
+ * AbortAll() aborts all pending (not yet started) tasks and the currently in-flight task. Pending tasks still run
+ * briefly but receive an aborted signal and are expected to exit early.
  */
 declare class SerialRunner {
   #private;
   schedule<TValue = void, TError = unknown>(task: TaskLike<TValue, TError>): Promise<TValue>;
   /**
-   * A promise that resolves when all currently-scheduled tasks have settled.
-   * Use the reference as a generation token: capture it after scheduling a
-   * batch, then check identity in the resolution callback to detect whether
-   * a subsequent abortAll() + new batch has superseded this one.
+   * A promise that resolves when all currently-scheduled tasks have settled. Use the reference as a generation token:
+   * capture it after scheduling a batch, then check identity in the resolution callback to detect whether a subsequent
+   * abortAll() + new batch has superseded this one.
    */
   get settled(): Promise<void>;
   /**
-   * Registers a callback to fire when all currently-pending tasks settle.
-   * If the runner is already idle (no pending or running tasks), the callback
-   * is never called. If new tasks are scheduled before the current batch
-   * settles, the callback is superseded and silently dropped — no stale
-   * callbacks, no generation token required by the caller.
+   * Registers a callback to fire when all currently-pending tasks settle. If the runner is already idle (no pending or
+   * running tasks), the callback is never called. If new tasks are scheduled before the current batch settles, the
+   * callback is superseded and silently dropped — no stale callbacks, no generation token required by the caller.
    */
   whenSettled(callback: () => void): void;
   /** Aborts and clears queued tasks without touching the in-flight task. */
@@ -144,21 +123,20 @@ declare class SerialRunner {
   destroy(): void;
 }
 /**
- * Decides whether — and *when* — a {@link RecurringRunner} re-runs its task.
- * Invoked **concurrently with the run** (so the inter-run interval can be
- * measured from when the run *started*, not when it finished) with the single
+ * Decides whether — and _when_ — a {@link RecurringRunner} re-runs its task. Invoked **concurrently with the run** (so
+ * the inter-run interval can be measured from when the run _started_, not when it finished) with the single
  * {@link TaskLike}, which carries everything a decision needs:
- * - `task.run()` — the in-flight run, observable via this memoized call (does
- *   not re-trigger work), e.g. to read its result for a cadence/stop decision.
- * - `task.previous` — the prior successful run's value (`undefined` on the
- *   first), for decisions that compare consecutive results.
+ *
+ * - `task.run()` — the in-flight run, observable via this memoized call (does not re-trigger work), e.g. to read its
+ *   result for a cadence/stop decision.
+ * - `task.previous` — the prior successful run's value (`undefined` on the first), for decisions that compare consecutive
+ *   results.
  * - `task.signal` — aborts the wait (and the recurrence) when the task is.
  *
- * Resolves `true` to re-run (after whatever delay it owns) or `false` to stop.
- * The runner deals only in this awaitable verdict — *how* the delay is produced
- * (a timer, a frame, an event) and *when* it's measured from live entirely in
- * the reschedule function, so the runner itself knows nothing about time. See
- * `delayedReschedule` for the common timer-based, start-anchored implementation.
+ * Resolves `true` to re-run (after whatever delay it owns) or `false` to stop. The runner deals only in this awaitable
+ * verdict — _how_ the delay is produced (a timer, a frame, an event) and _when_ it's measured from live entirely in the
+ * reschedule function, so the runner itself knows nothing about time. See `delayedReschedule` for the common
+ * timer-based, start-anchored implementation.
  */
 type Reschedule<TValue> = (task: TaskLike<TValue>) => PromiseLike<boolean>;
 //#endregion

package/dist/dev/core/tasks/task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task.d.ts","names":[],"sources":["../../../../src/core/tasks/task.ts"],"mappings":";;KAQY,aAAa,KAAK,iBAAiB,OAC3C,cAAc,aAAa,MAC3B,+BACc,WAAW,IAAI,aAAa,EAAE,SAC1C;KAMM;;;;UAKK;;;;;;;EAOf;;;;;;EAOA,SAAS;;;;;UAMM,SAAS,eAAe;WAC9B;WACA,QAAQ;WACR,OAAO,aAAa;WACpB,OAAO,aAAa;;;;;;WAMpB,UAAU,aAAa;;;;;;WAMvB,QAAQ;;EAEjB,OAAO,QAAQ;EACf;;EAEA,SAAS,SAAS,QAAQ;;;;;;;;;;;;;;;;;;;cAoBf,KAAK,eAAe,6BAA6B,SAAS,QAAQ;;WACpE;EAYT,YAAY,QAAQ,QAAQ,gBAAgB,QAAQ,SAAS,SAAS;MAUlE,UAAU;MAIV,SAAS,aAAa;MAItB,SAAS,aAAa;MAItB,YAAY,aAAa;MAIzB,UAAU;EAId,OAAO,QAAQ;EAuBf;;;;;;;;;;;EAcA,SAAS,KAAK,QAAQ;;;;;;;;;cAkBX;;EAMX,SAAS,eAAe,kBAAkB,MAAM,SAAS,QAAQ,UAAU,QAAQ;;;;;;;EAkCnF,YAAY;EAYZ;EAWA;;;;;;;;;;;;;;;;cAwBW;;EAMX,SAAS,eAAe,kBAAkB,MAAM,SAAS,QAAQ,UAAU,QAAQ;;;;;;;MA8B/E,WAAW;;;;;;;;EAWf,YAAY;;EAaZ;EAKA;EAKA;;;;;;;;;;;;;;;;;;;KA2BU,WAAW,WAAW,MAAM,SAAS,YAAY"}
+{"version":3,"file":"task.d.ts","names":[],"sources":["../../../../src/core/tasks/task.ts"],"mappings":";;KAQY,aAAa,KAAK,iBAAiB,OAC3C,cAAc,aAAa,MAC3B,+BACc,WAAW,IAAI,aAAa,EAAE,SAC1C;KAMM;;UAGK;;;;;EAKf;;;;;EAMA,SAAS;;;UAIM,SAAS,eAAe;WAC9B;WACA,QAAQ;WACR,OAAO,aAAa;WACpB,OAAO,aAAa;;;;;WAKpB,UAAU,aAAa;;;;;WAKvB,QAAQ;;EAEjB,OAAO,QAAQ;EACf;;EAEA,SAAS,SAAS,QAAQ;;;;;;;;;;;;;;;;cAiBf,KAAK,eAAe,6BAA6B,SAAS,QAAQ;;WACpE;EAYT,YAAY,QAAQ,QAAQ,gBAAgB,QAAQ,SAAS,SAAS;MAWlE,UAAU;MAIV,SAAS,aAAa;MAItB,SAAS,aAAa;MAItB,YAAY,aAAa;MAIzB,UAAU;EAId,OAAO,QAAQ;EAyBf;;;;;;;;;EAYA,SAAS,KAAK,QAAQ;;;;;;;;cAkBX;;EAMX,SAAS,eAAe,kBAAkB,MAAM,SAAS,QAAQ,UAAU,QAAQ;;;;;;EAqCnF,YAAY;EAeZ;EAYA;;;;;;;;;;;;;;cAsBW;;EAMX,SAAS,eAAe,kBAAkB,MAAM,SAAS,QAAQ,UAAU,QAAQ;;;;;;MA+B/E,WAAW;;;;;;EASf,YAAY;;EAgBZ;EAMA;EAKA;;;;;;;;;;;;;;;;;;KA0BU,WAAW,WAAW,MAAM,SAAS,YAAY"}

package/dist/dev/core/tasks/task.js

@@ -4,19 +4,16 @@ import { generateId } from "@videojs/utils/string";
 /**
 * Generic reusable task that wraps an async run function.
 *
-* Owns its own AbortController so it can always be aborted independently.
-* Optionally composes an external AbortSignal so that a parent's cancellation
-* propagates into the task's work without requiring the caller to track the
-* task separately.
+* Owns its own AbortController so it can always be aborted independently. Optionally composes an external AbortSignal
+* so that a parent's cancellation propagates into the task's work without requiring the caller to track the task
+* separately.
 *
-* `run()` is memoized: the work runs at most once per instance, and every call
-* returns the same promise (so observers can `await run()` to read the result
-* without re-triggering the work). To re-run the *same* work, take a `clone()` —
-* a fresh instance with its own AbortController and a pending state.
+* `run()` is memoized: the work runs at most once per instance, and every call returns the same promise (so observers
+* can `await run()` to read the result without re-triggering the work). To re-run the _same_ work, take a `clone()` — a
+* fresh instance with its own AbortController and a pending state.
 *
-* Ordering guarantee: `value` is written before `status` transitions to `'done'`;
-* `error` is written before `status` transitions to `'error'`. Any reader
-* observing `status === 'done'` is guaranteed `value` is already present.
+* Ordering guarantee: `value` is written before `status` transitions to `'done'`; `error` is written before `status`
+* transitions to `'error'`. Any reader observing `status === 'done'` is guaranteed `value` is already present.
 */
 var Task = class Task {
 	id;
@@ -72,14 +69,12 @@ var Task = class Task {
 		this.#abortController.abort();
 	}
 	/**
-	* A fresh task with the same work, id, and external signal, in a pending state
-	* (its own AbortController, no memoized result) — so it can be run again. Used
-	* to re-run structurally identical work (e.g. `RecurringRunner` reloads).
+	* A fresh task with the same work, id, and external signal, in a pending state (its own AbortController, no memoized
+	* result) — so it can be run again. Used to re-run structurally identical work (e.g. `RecurringRunner` reloads).
 	*
-	* The clone inherits this run's value as its `previous` (or this run's own
-	* `previous` if it never produced one — e.g. it errored), so a recurrence's
-	* `previous` always tracks the last *successful* value across the lineage with
-	* no bookkeeping in the runner.
+	* The clone inherits this run's value as its `previous` (or this run's own `previous` if it never produced one — e.g.
+	* it errored), so a recurrence's `previous` always tracks the last _successful_ value across the lineage with no
+	* bookkeeping in the runner.
 	*/
 	clone() {
 		const cloned = new Task(this.#runFn, {
@@ -93,9 +88,8 @@ var Task = class Task {
 /**
 * Runs tasks concurrently, deduplicated by task id.
 *
-* If a task with a given id is already in flight, subsequent schedule() calls
-* for that id are silently ignored until the first completes. Tasks are stored
-* so abortAll() can cancel any in-flight work (e.g. on engine cleanup).
+* If a task with a given id is already in flight, subsequent schedule() calls for that id are silently ignored until
+* the first completes. Tasks are stored so abortAll() can cancel any in-flight work (e.g. on engine cleanup).
 */
 var ConcurrentRunner = class {
 	#pending = /* @__PURE__ */ new Map();
@@ -126,10 +120,9 @@ var ConcurrentRunner = class {
 		return promise;
 	}
 	/**
-	* Registers a callback to fire when all currently in-flight tasks settle.
-	* If the runner is already idle, the callback is never called. If abortAll()
-	* is called before the batch settles, the callback is superseded and silently
-	* dropped — no stale callbacks, no generation token required by the caller.
+	* Registers a callback to fire when all currently in-flight tasks settle. If the runner is already idle, the callback
+	* is never called. If abortAll() is called before the batch settles, the callback is superseded and silently dropped
+	* — no stale callbacks, no generation token required by the caller.
 	*/
 	whenSettled(callback) {
 		if (this.#pending.size === 0) return;
@@ -154,16 +147,14 @@ var ConcurrentRunner = class {
 /**
 * Runs tasks one at a time in submission order.
 *
-* Each schedule() call returns a Promise that resolves or rejects with the
-* task's result when it is eventually executed. Tasks wait in queue until the
-* prior task completes.
+* Each schedule() call returns a Promise that resolves or rejects with the task's result when it is eventually
+* executed. Tasks wait in queue until the prior task completes.
 *
-* Serialization is achieved by chaining each task's run() onto the tail of a
-* shared promise chain — no explicit queue or drain loop needed.
+* Serialization is achieved by chaining each task's run() onto the tail of a shared promise chain — no explicit queue
+* or drain loop needed.
 *
-* abortAll() aborts all pending (not yet started) tasks and the currently
-* in-flight task. Pending tasks still run briefly but receive an aborted
-* signal and are expected to exit early.
+* AbortAll() aborts all pending (not yet started) tasks and the currently in-flight task. Pending tasks still run
+* briefly but receive an aborted signal and are expected to exit early.
 */
 var SerialRunner = class {
 	#chain = Promise.resolve();
@@ -185,20 +176,17 @@ var SerialRunner = class {
 		return result;
 	}
 	/**
-	* A promise that resolves when all currently-scheduled tasks have settled.
-	* Use the reference as a generation token: capture it after scheduling a
-	* batch, then check identity in the resolution callback to detect whether
-	* a subsequent abortAll() + new batch has superseded this one.
+	* A promise that resolves when all currently-scheduled tasks have settled. Use the reference as a generation token:
+	* capture it after scheduling a batch, then check identity in the resolution callback to detect whether a subsequent
+	* abortAll() + new batch has superseded this one.
 	*/
 	get settled() {
 		return this.#chain;
 	}
 	/**
-	* Registers a callback to fire when all currently-pending tasks settle.
-	* If the runner is already idle (no pending or running tasks), the callback
-	* is never called. If new tasks are scheduled before the current batch
-	* settles, the callback is superseded and silently dropped — no stale
-	* callbacks, no generation token required by the caller.
+	* Registers a callback to fire when all currently-pending tasks settle. If the runner is already idle (no pending or
+	* running tasks), the callback is never called. If new tasks are scheduled before the current batch settles, the
+	* callback is superseded and silently dropped — no stale callbacks, no generation token required by the caller.
 	*/
 	whenSettled(callback) {
 		if (this.#pending.size === 0 && this.#current === null) return;
@@ -223,39 +211,32 @@ var SerialRunner = class {
 	}
 };
 /**
-* A {@link Reschedule} that never recurs — the task runs exactly once. Pass it to
-* a {@link RecurringRunner} for non-recurring, run-once work (e.g. resolving a
-* complete VoD playlist that can never go stale).
+* A {@link Reschedule} that never recurs — the task runs exactly once. Pass it to a {@link RecurringRunner} for
+* non-recurring, run-once work (e.g. resolving a complete VoD playlist that can never go stale).
 */
 const runOnce = () => Promise.resolve(false);
 /**
-* Runs a task, then re-runs it whenever a {@link Reschedule} function says to,
-* until it says stop (or it's aborted) — the recurring sibling of
-* {@link ConcurrentRunner} / {@link SerialRunner}, and like them it's handed a
+* Runs a task, then re-runs it whenever a {@link Reschedule} function says to, until it says stop (or it's aborted) —
+* the recurring sibling of {@link ConcurrentRunner} / {@link SerialRunner}, and like them it's handed a
 * {@link TaskLike} to run.
 *
-* The runner has no notion of time: it just awaits whatever `reschedule`
-* returns (resolves `true` → re-run; `false` → stop). A `reschedule` is required;
-* pass {@link runOnce} for non-recurring, run-exactly-once work.
+* The runner has no notion of time: it just awaits whatever `reschedule` returns (resolves `true` → re-run; `false` →
+* stop). A `reschedule` is required; pass {@link runOnce} for non-recurring, run-exactly-once work.
 *
-* Single-slot, keyed by task **id**: there is always at most one identified
-* active task for re-running. Scheduling a task whose id matches the active one
-* is a no-op — the existing recurrence keeps running (dedup by id). Scheduling a
-* task with a *different* id aborts the prior task's in-flight run and pending
-* reschedule, then takes over the slot (abort-and-replace) — the right shape
-* when there's one logical unit of recurring work (e.g. reloading the *selected*
+* Single-slot, keyed by task **id**: there is always at most one identified active task for re-running. Scheduling a
+* task whose id matches the active one is a no-op — the existing recurrence keeps running (dedup by id). Scheduling a
+* task with a _different_ id aborts the prior task's in-flight run and pending reschedule, then takes over the slot
+* (abort-and-replace) — the right shape when there's one logical unit of recurring work (e.g. reloading the _selected_
 * track's media playlist).
 *
-* Each re-run is a fresh `clone()` of the task (since `Task.run()` is memoized —
-* the same instance won't re-execute), carrying the same id so the slot's
-* identity is stable across cycles. The clone also carries the prior cycle's
-* value forward as `task.previous`. The run function should read any inputs that
-* change between cycles at call time rather than capturing them once.
+* Each re-run is a fresh `clone()` of the task (since `Task.run()` is memoized — the same instance won't re-execute),
+* carrying the same id so the slot's identity is stable across cycles. The clone also carries the prior cycle's value
+* forward as `task.previous`. The run function should read any inputs that change between cycles at call time rather
+* than capturing them once.
 *
-* The task is the sole cancellation channel: `abortAll()` aborts the active task,
-* which fires `task.signal` — cancelling both its in-flight run and any pending
-* reschedule delay waiting on that signal. An aborted (or stopped) recurrence
-* frees the slot, so a later schedule of the same id starts fresh.
+* The task is the sole cancellation channel: `abortAll()` aborts the active task, which fires `task.signal` —
+* cancelling both its in-flight run and any pending reschedule delay waiting on that signal. An aborted (or stopped)
+* recurrence frees the slot, so a later schedule of the same id starts fresh.
 */
 var RecurringRunner = class {
 	#reschedule;
@@ -265,25 +246,21 @@ var RecurringRunner = class {
 		this.#reschedule = reschedule;
 	}
 	/**
-	* Run `task` and recur per the `reschedule` verdict, as a single promise.
-	* Resolves with the *final* cycle's value when the recurrence stops; **rejects**
-	* if a run (or reschedule) genuinely fails — the rejection propagates to the
-	* caller, who owns error handling; the runner only frees its slot (no
-	* swallowing). The runner's *own* cancellation (abort/supersede/destroy) is not
-	* a failure, so an aborted recurrence settles quietly rather than rejecting —
+	* Run `task` and recur per the `reschedule` verdict, as a single promise. Resolves with the _final_ cycle's value
+	* when the recurrence stops; **rejects** if a run (or reschedule) genuinely fails — the rejection propagates to the
+	* caller, who owns error handling; the runner only frees its slot (no swallowing). The runner's _own_ cancellation
+	* (abort/supersede/destroy) is not a failure, so an aborted recurrence settles quietly rather than rejecting —
 	* callers don't have to `.catch` routine teardown.
 	*
-	* Each cycle runs the task and consults `reschedule` concurrently (so the delay
-	* can be measured from the run's start); when both settle and this cycle still
-	* owns the slot, a `true` verdict re-schedules a `clone()` whose promise is
-	* *returned* — so the recurrence is the method calling itself, threaded into one
-	* promise, no separate loop. The clone shares the id, so the slot's identity is
-	* stable across cycles; it's released just before the re-schedule so the call
-	* advances rather than dedup-returning.
+	* Each cycle runs the task and consults `reschedule` concurrently (so the delay can be measured from the run's
+	* start); when both settle and this cycle still owns the slot, a `true` verdict re-schedules a `clone()` whose
+	* promise is _returned_ — so the recurrence is the method calling itself, threaded into one promise, no separate
+	* loop. The clone shares the id, so the slot's identity is stable across cycles; it's released just before the
+	* re-schedule so the call advances rather than dedup-returning.
 	*
-	* Note: because each cycle's promise adopts the next, the chain retains every
-	* prior cycle for the life of the recurrence — bounded for finite recurrences,
-	* an unbounded (small per-cycle) cost for a long-lived one (e.g. live reload).
+	* Note: because each cycle's promise adopts the next, the chain retains every prior cycle for the life of the
+	* recurrence — bounded for finite recurrences, an unbounded (small per-cycle) cost for a long-lived one (e.g. live
+	* reload).
 	*/
 	schedule(task) {
 		if (this.#destroyed) return Promise.resolve();

package/dist/dev/core/tasks/task.js.map

@@ -1 +1 @@
-{"version":3,"file":"task.js","names":["#runFn","#externalSignal","#abortController","#signal","#status","#value","#error","#previous","#promise","#execute","#pending","#destroyed","#settled","#resolveSettled","#chain","#current","#reschedule","#active","#cancel"],"sources":["../../../../src/core/tasks/task.ts"],"sourcesContent":["import { anyAbortSignal } from '@videojs/utils/events';\nimport { generateId } from '@videojs/utils/string';\n\n// =============================================================================\n// DeepReadonly\n// =============================================================================\n\n/** Recursively marks all properties as readonly. */\nexport type DeepReadonly<T> = T extends (infer U)[]\n  ? ReadonlyArray<DeepReadonly<U>>\n  : T extends object\n    ? { readonly [K in keyof T]: DeepReadonly<T[K]> }\n    : T;\n\n// =============================================================================\n// Task\n// =============================================================================\n\nexport type TaskStatus = 'pending' | 'running' | 'done' | 'error';\n\n/**\n * Configuration for a Task.\n */\nexport interface TaskConfig {\n  /**\n   * Identifier for this task.\n   * - string: used as-is\n   * - () => string: called once at construction time\n   * - undefined: a unique ID is generated via generateId()\n   */\n  id?: string | (() => string);\n\n  /**\n   * Optional external AbortSignal to compose with the task's internal one.\n   * The task's work is aborted when either the internal controller (via abort())\n   * or this external signal fires — whichever comes first.\n   */\n  signal?: AbortSignal;\n}\n\n/**\n * Minimal contract for a schedulable unit of async work.\n */\nexport interface TaskLike<TValue = void, TError = unknown> {\n  readonly id: string;\n  readonly status: TaskStatus;\n  readonly value: DeepReadonly<TValue> | undefined;\n  readonly error: DeepReadonly<TError> | undefined;\n  /**\n   * The last successful value carried forward from the run this was `clone()`d\n   * from — the prior cycle's result for a `RecurringRunner` (undefined for an\n   * original, or until the lineage has produced a success).\n   */\n  readonly previous: DeepReadonly<TValue> | undefined;\n  /**\n   * The signal this task's work runs under (its own abort composed with any\n   * external one). Aborting the task fires it — so a `reschedule` can wait on it\n   * to have its delay cancelled when the recurrence is aborted.\n   */\n  readonly signal: AbortSignal;\n  /** Run the work, memoized: repeated calls share one execution + result. */\n  run(): Promise<TValue>;\n  abort(): void;\n  /** A fresh, structurally identical task (same work + id) in a pending state — for re-running. */\n  clone(): TaskLike<TValue, TError>;\n}\n\n/**\n * Generic reusable task that wraps an async run function.\n *\n * Owns its own AbortController so it can always be aborted independently.\n * Optionally composes an external AbortSignal so that a parent's cancellation\n * propagates into the task's work without requiring the caller to track the\n * task separately.\n *\n * `run()` is memoized: the work runs at most once per instance, and every call\n * returns the same promise (so observers can `await run()` to read the result\n * without re-triggering the work). To re-run the *same* work, take a `clone()` —\n * a fresh instance with its own AbortController and a pending state.\n *\n * Ordering guarantee: `value` is written before `status` transitions to `'done'`;\n * `error` is written before `status` transitions to `'error'`. Any reader\n * observing `status === 'done'` is guaranteed `value` is already present.\n */\nexport class Task<TValue = void, TError = unknown> implements TaskLike<TValue, TError> {\n  readonly id: string;\n  readonly #runFn: (signal: AbortSignal) => Promise<TValue>;\n  readonly #externalSignal: AbortSignal | undefined;\n  readonly #abortController = new AbortController();\n  readonly #signal: AbortSignal;\n\n  #status: TaskStatus = 'pending';\n  #value: TValue | undefined = undefined;\n  #error: TError | undefined = undefined;\n  #previous: TValue | undefined = undefined;\n  #promise: Promise<TValue> | undefined = undefined;\n\n  constructor(runFn: (signal: AbortSignal) => Promise<TValue>, config?: TaskConfig) {\n    this.#runFn = runFn;\n    const rawId = config?.id;\n    this.id = typeof rawId === 'function' ? rawId() : (rawId ?? generateId());\n    this.#externalSignal = config?.signal;\n    this.#signal = config?.signal\n      ? anyAbortSignal([this.#abortController.signal, config.signal])\n      : this.#abortController.signal;\n  }\n\n  get status(): TaskStatus {\n    return this.#status;\n  }\n\n  get value(): DeepReadonly<TValue> | undefined {\n    return this.#value as DeepReadonly<TValue> | undefined;\n  }\n\n  get error(): DeepReadonly<TError> | undefined {\n    return this.#error as DeepReadonly<TError> | undefined;\n  }\n\n  get previous(): DeepReadonly<TValue> | undefined {\n    return this.#previous as DeepReadonly<TValue> | undefined;\n  }\n\n  get signal(): AbortSignal {\n    return this.#signal;\n  }\n\n  run(): Promise<TValue> {\n    // Memoized: run the work once, sharing the same promise across calls. The\n    // memoized promise IS what callers await, so it's always handled (no orphan\n    // `Promise.resolve/reject`); a sync-throwing `#runFn` is captured as a\n    // rejection rather than re-run.\n    this.#promise ??= this.#execute();\n    return this.#promise;\n  }\n\n  async #execute(): Promise<TValue> {\n    this.#status = 'running';\n    try {\n      const result = await this.#runFn(this.#signal);\n      this.#value = result; // value before status — ordering guarantee\n      this.#status = 'done';\n      return result;\n    } catch (e) {\n      this.#error = e as TError; // error before status — ordering guarantee\n      this.#status = 'error';\n      throw e;\n    }\n  }\n\n  abort(): void {\n    this.#abortController.abort();\n  }\n\n  /**\n   * A fresh task with the same work, id, and external signal, in a pending state\n   * (its own AbortController, no memoized result) — so it can be run again. Used\n   * to re-run structurally identical work (e.g. `RecurringRunner` reloads).\n   *\n   * The clone inherits this run's value as its `previous` (or this run's own\n   * `previous` if it never produced one — e.g. it errored), so a recurrence's\n   * `previous` always tracks the last *successful* value across the lineage with\n   * no bookkeeping in the runner.\n   */\n  clone(): Task<TValue, TError> {\n    const cloned = new Task<TValue, TError>(this.#runFn, { id: this.id, signal: this.#externalSignal });\n    cloned.#previous = this.#value ?? this.#previous;\n    return cloned;\n  }\n}\n\n// =============================================================================\n// ConcurrentRunner\n// =============================================================================\n\n/**\n * Runs tasks concurrently, deduplicated by task id.\n *\n * If a task with a given id is already in flight, subsequent schedule() calls\n * for that id are silently ignored until the first completes. Tasks are stored\n * so abortAll() can cancel any in-flight work (e.g. on engine cleanup).\n */\nexport class ConcurrentRunner {\n  readonly #pending = new Map<string, { task: TaskLike<unknown, unknown>; promise: Promise<unknown> }>();\n  #settled: Promise<void> = Promise.resolve();\n  #resolveSettled: (() => void) | null = null;\n  #destroyed = false;\n\n  schedule<TValue = void, TError = unknown>(task: TaskLike<TValue, TError>): Promise<TValue> {\n    if (this.#destroyed) return Promise.resolve() as Promise<TValue>;\n    const existing = this.#pending.get(task.id);\n    if (existing) return existing.promise as Promise<TValue>;\n\n    if (this.#pending.size === 0) {\n      this.#settled = new Promise((resolve) => {\n        this.#resolveSettled = resolve;\n      });\n    }\n\n    const promise = task.run();\n    // Suppress unhandled rejection for callers that ignore the return value.\n    promise.catch(() => {});\n    // Cleanup: update pending and resolve settled regardless of outcome.\n    const cleanup = () => {\n      this.#pending.delete(task.id);\n      if (this.#pending.size === 0) {\n        this.#resolveSettled?.();\n        this.#resolveSettled = null;\n      }\n    };\n    promise.then(cleanup, cleanup);\n\n    this.#pending.set(task.id, { task: task as TaskLike<unknown, unknown>, promise: promise as Promise<unknown> });\n    return promise;\n  }\n\n  /**\n   * Registers a callback to fire when all currently in-flight tasks settle.\n   * If the runner is already idle, the callback is never called. If abortAll()\n   * is called before the batch settles, the callback is superseded and silently\n   * dropped — no stale callbacks, no generation token required by the caller.\n   */\n  whenSettled(callback: () => void): void {\n    if (this.#pending.size === 0) return;\n    const captured = this.#settled;\n    captured.then(\n      () => {\n        if (this.#settled !== captured) return;\n        callback();\n      },\n      () => {}\n    );\n  }\n\n  abortAll(): void {\n    for (const { task } of this.#pending.values()) task.abort();\n    this.#pending.clear();\n    // Resolve the current settled promise so any .then() handlers are queued,\n    // then replace the reference — whenSettled callbacks that captured the old\n    // reference will see the identity mismatch and be dropped.\n    this.#resolveSettled?.();\n    this.#resolveSettled = null;\n    this.#settled = Promise.resolve();\n  }\n\n  destroy(): void {\n    this.#destroyed = true;\n    this.abortAll();\n  }\n}\n\n// =============================================================================\n// SerialRunner\n// =============================================================================\n\n/**\n * Runs tasks one at a time in submission order.\n *\n * Each schedule() call returns a Promise that resolves or rejects with the\n * task's result when it is eventually executed. Tasks wait in queue until the\n * prior task completes.\n *\n * Serialization is achieved by chaining each task's run() onto the tail of a\n * shared promise chain — no explicit queue or drain loop needed.\n *\n * abortAll() aborts all pending (not yet started) tasks and the currently\n * in-flight task. Pending tasks still run briefly but receive an aborted\n * signal and are expected to exit early.\n */\nexport class SerialRunner {\n  #chain: Promise<unknown> = Promise.resolve();\n  readonly #pending = new Set<TaskLike<unknown, unknown>>();\n  #current: TaskLike<unknown, unknown> | null = null;\n  #destroyed = false;\n\n  schedule<TValue = void, TError = unknown>(task: TaskLike<TValue, TError>): Promise<TValue> {\n    if (this.#destroyed) return Promise.resolve() as Promise<TValue>;\n    const t = task as TaskLike<unknown, unknown>;\n    this.#pending.add(t);\n\n    const result = this.#chain\n      .then(() => {\n        this.#pending.delete(t);\n        this.#current = t;\n        return task.run();\n      })\n      .finally(() => {\n        this.#current = null;\n      });\n\n    // Advance the chain regardless of whether this task succeeds or fails.\n    this.#chain = result.then(\n      () => {},\n      () => {}\n    );\n\n    return result as Promise<TValue>;\n  }\n\n  /**\n   * A promise that resolves when all currently-scheduled tasks have settled.\n   * Use the reference as a generation token: capture it after scheduling a\n   * batch, then check identity in the resolution callback to detect whether\n   * a subsequent abortAll() + new batch has superseded this one.\n   */\n  get settled(): Promise<void> {\n    return this.#chain as Promise<void>;\n  }\n\n  /**\n   * Registers a callback to fire when all currently-pending tasks settle.\n   * If the runner is already idle (no pending or running tasks), the callback\n   * is never called. If new tasks are scheduled before the current batch\n   * settles, the callback is superseded and silently dropped — no stale\n   * callbacks, no generation token required by the caller.\n   */\n  whenSettled(callback: () => void): void {\n    if (this.#pending.size === 0 && this.#current === null) return;\n    const currentChain = this.#chain;\n    currentChain.then(\n      () => {\n        if (this.#chain !== currentChain) return;\n        callback();\n      },\n      () => {}\n    );\n  }\n\n  /** Aborts and clears queued tasks without touching the in-flight task. */\n  abortPending(): void {\n    for (const task of this.#pending) task.abort();\n    this.#pending.clear();\n  }\n\n  abortAll(): void {\n    this.abortPending();\n    this.#current?.abort();\n  }\n\n  destroy(): void {\n    this.#destroyed = true;\n    this.abortAll();\n  }\n}\n\n// =============================================================================\n// RecurringRunner\n// =============================================================================\n\n/**\n * Decides whether — and *when* — a {@link RecurringRunner} re-runs its task.\n * Invoked **concurrently with the run** (so the inter-run interval can be\n * measured from when the run *started*, not when it finished) with the single\n * {@link TaskLike}, which carries everything a decision needs:\n * - `task.run()` — the in-flight run, observable via this memoized call (does\n *   not re-trigger work), e.g. to read its result for a cadence/stop decision.\n * - `task.previous` — the prior successful run's value (`undefined` on the\n *   first), for decisions that compare consecutive results.\n * - `task.signal` — aborts the wait (and the recurrence) when the task is.\n *\n * Resolves `true` to re-run (after whatever delay it owns) or `false` to stop.\n * The runner deals only in this awaitable verdict — *how* the delay is produced\n * (a timer, a frame, an event) and *when* it's measured from live entirely in\n * the reschedule function, so the runner itself knows nothing about time. See\n * `delayedReschedule` for the common timer-based, start-anchored implementation.\n */\nexport type Reschedule<TValue> = (task: TaskLike<TValue>) => PromiseLike<boolean>;\n\n/**\n * A {@link Reschedule} that never recurs — the task runs exactly once. Pass it to\n * a {@link RecurringRunner} for non-recurring, run-once work (e.g. resolving a\n * complete VoD playlist that can never go stale).\n */\nexport const runOnce: Reschedule<unknown> = () => Promise.resolve(false);\n\n/**\n * Runs a task, then re-runs it whenever a {@link Reschedule} function says to,\n * until it says stop (or it's aborted) — the recurring sibling of\n * {@link ConcurrentRunner} / {@link SerialRunner}, and like them it's handed a\n * {@link TaskLike} to run.\n *\n * The runner has no notion of time: it just awaits whatever `reschedule`\n * returns (resolves `true` → re-run; `false` → stop). A `reschedule` is required;\n * pass {@link runOnce} for non-recurring, run-exactly-once work.\n *\n * Single-slot, keyed by task **id**: there is always at most one identified\n * active task for re-running. Scheduling a task whose id matches the active one\n * is a no-op — the existing recurrence keeps running (dedup by id). Scheduling a\n * task with a *different* id aborts the prior task's in-flight run and pending\n * reschedule, then takes over the slot (abort-and-replace) — the right shape\n * when there's one logical unit of recurring work (e.g. reloading the *selected*\n * track's media playlist).\n *\n * Each re-run is a fresh `clone()` of the task (since `Task.run()` is memoized —\n * the same instance won't re-execute), carrying the same id so the slot's\n * identity is stable across cycles. The clone also carries the prior cycle's\n * value forward as `task.previous`. The run function should read any inputs that\n * change between cycles at call time rather than capturing them once.\n *\n * The task is the sole cancellation channel: `abortAll()` aborts the active task,\n * which fires `task.signal` — cancelling both its in-flight run and any pending\n * reschedule delay waiting on that signal. An aborted (or stopped) recurrence\n * frees the slot, so a later schedule of the same id starts fresh.\n */\nexport class RecurringRunner<TValue = unknown> {\n  readonly #reschedule: Reschedule<TValue>;\n  // The identified active task — the one being (re)run. Held across cycles\n  // (including the inter-cycle wait); null once the recurrence stops/aborts. Also\n  // serves as the ownership token: a cycle advances or frees the slot only while\n  // `#active` still points at its own task (a supersede/abortAll swaps it).\n  #active: TaskLike<TValue, unknown> | null = null;\n  #destroyed = false;\n\n  constructor(reschedule: Reschedule<TValue>) {\n    this.#reschedule = reschedule;\n  }\n\n  /**\n   * Run `task` and recur per the `reschedule` verdict, as a single promise.\n   * Resolves with the *final* cycle's value when the recurrence stops; **rejects**\n   * if a run (or reschedule) genuinely fails — the rejection propagates to the\n   * caller, who owns error handling; the runner only frees its slot (no\n   * swallowing). The runner's *own* cancellation (abort/supersede/destroy) is not\n   * a failure, so an aborted recurrence settles quietly rather than rejecting —\n   * callers don't have to `.catch` routine teardown.\n   *\n   * Each cycle runs the task and consults `reschedule` concurrently (so the delay\n   * can be measured from the run's start); when both settle and this cycle still\n   * owns the slot, a `true` verdict re-schedules a `clone()` whose promise is\n   * *returned* — so the recurrence is the method calling itself, threaded into one\n   * promise, no separate loop. The clone shares the id, so the slot's identity is\n   * stable across cycles; it's released just before the re-schedule so the call\n   * advances rather than dedup-returning.\n   *\n   * Note: because each cycle's promise adopts the next, the chain retains every\n   * prior cycle for the life of the recurrence — bounded for finite recurrences,\n   * an unbounded (small per-cycle) cost for a long-lived one (e.g. live reload).\n   */\n  schedule(task: TaskLike<TValue, unknown>): Promise<TValue> {\n    if (this.#destroyed) return Promise.resolve() as Promise<TValue>;\n    // Dedup by id: this id is already the active re-run target, so the existing\n    // recurrence continues uninterrupted (don't restart it) — hand back its\n    // in-flight run.\n    if (this.#active?.id === task.id) return this.#active.run();\n    // Different id supersedes: abort the prior recurrence, then take over.\n    this.#cancel();\n    this.#active = task;\n\n    // Drive the run (in case `reschedule` doesn't observe it — e.g. `runOnce`)\n    // and the verdict together; a rejected run rejects the whole cycle.\n    return Promise.all([task.run(), this.#reschedule(task)]).then(\n      ([value, again]) => {\n        // Only act while we still own the slot — a supersede/abortAll swapped\n        // `#active`, in which case this stale cycle does nothing.\n        if (this.#active === task && again && !task.signal.aborted) {\n          // Release first so the same-id clone advances (isn't dedup-returned),\n          // then chain the next cycle into this promise.\n          this.#active = null;\n          return this.schedule(task.clone());\n        }\n        if (this.#active === task) this.#active = null; // natural stop / superseded\n        return value;\n      },\n      (error) => {\n        // The recurrence ended on a rejection; free the slot if we still own it.\n        if (this.#active === task) this.#active = null;\n        // The runner's own cancellation isn't a failure — settle quietly so\n        // routine teardown (abort/supersede/destroy) needs no caller `.catch`.\n        // A genuine run/reschedule failure propagates to the caller.\n        if (task.signal.aborted) return undefined as TValue;\n        throw error;\n      }\n    );\n  }\n\n  #cancel(): void {\n    this.#active?.abort();\n    this.#active = null;\n  }\n\n  abortAll(): void {\n    this.#cancel();\n  }\n\n  destroy(): void {\n    this.#destroyed = true;\n    this.abortAll();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoFA,IAAa,OAAb,MAAa,KAA0E;CACrF;CACA;CACA;CACA,mBAA4B,IAAI,gBAAgB;CAChD;CAEA,UAAsB;CACtB,SAA6B,KAAA;CAC7B,SAA6B,KAAA;CAC7B,YAAgC,KAAA;CAChC,WAAwC,KAAA;CAExC,YAAY,OAAiD,QAAqB;EAChF,KAAKA,SAAS;EACd,MAAM,QAAQ,QAAQ;EACtB,KAAK,KAAK,OAAO,UAAU,aAAa,MAAM,IAAK,SAAS,WAAW;EACvE,KAAKC,kBAAkB,QAAQ;EAC/B,KAAKE,UAAU,QAAQ,SACnB,eAAe,CAAC,KAAKD,iBAAiB,QAAQ,OAAO,MAAM,CAAC,IAC5D,KAAKA,iBAAiB;CAC5B;CAEA,IAAI,SAAqB;EACvB,OAAO,KAAKE;CACd;CAEA,IAAI,QAA0C;EAC5C,OAAO,KAAKC;CACd;CAEA,IAAI,QAA0C;EAC5C,OAAO,KAAKC;CACd;CAEA,IAAI,WAA6C;EAC/C,OAAO,KAAKC;CACd;CAEA,IAAI,SAAsB;EACxB,OAAO,KAAKJ;CACd;CAEA,MAAuB;EAKrB,KAAKK,aAAa,KAAKC,SAAS;EAChC,OAAO,KAAKD;CACd;CAEA,MAAMC,WAA4B;EAChC,KAAKL,UAAU;EACf,IAAI;GACF,MAAM,SAAS,MAAM,KAAKJ,OAAO,KAAKG,OAAO;GAC7C,KAAKE,SAAS;GACd,KAAKD,UAAU;GACf,OAAO;EACT,SAAS,GAAG;GACV,KAAKE,SAAS;GACd,KAAKF,UAAU;GACf,MAAM;EACR;CACF;CAEA,QAAc;EACZ,KAAKF,iBAAiB,MAAM;CAC9B;;;;;;;;;;;CAYA,QAA8B;EAC5B,MAAM,SAAS,IAAI,KAAqB,KAAKF,QAAQ;GAAE,IAAI,KAAK;GAAI,QAAQ,KAAKC;EAAgB,CAAC;EAClG,OAAOM,YAAY,KAAKF,UAAU,KAAKE;EACvC,OAAO;CACT;AACF;;;;;;;;AAaA,IAAa,mBAAb,MAA8B;CAC5B,2BAAoB,IAAI,IAA6E;CACrG,WAA0B,QAAQ,QAAQ;CAC1C,kBAAuC;CACvC,aAAa;CAEb,SAA0C,MAAiD;EACzF,IAAI,KAAKI,YAAY,OAAO,QAAQ,QAAQ;EAC5C,MAAM,WAAW,KAAKD,SAAS,IAAI,KAAK,EAAE;EAC1C,IAAI,UAAU,OAAO,SAAS;EAE9B,IAAI,KAAKA,SAAS,SAAS,GACzB,KAAKE,WAAW,IAAI,SAAS,YAAY;GACvC,KAAKC,kBAAkB;EACzB,CAAC;EAGH,MAAM,UAAU,KAAK,IAAI;EAEzB,QAAQ,YAAY,CAAC,CAAC;EAEtB,MAAM,gBAAgB;GACpB,KAAKH,SAAS,OAAO,KAAK,EAAE;GAC5B,IAAI,KAAKA,SAAS,SAAS,GAAG;IAC5B,KAAKG,kBAAkB;IACvB,KAAKA,kBAAkB;GACzB;EACF;EACA,QAAQ,KAAK,SAAS,OAAO;EAE7B,KAAKH,SAAS,IAAI,KAAK,IAAI;GAAQ;GAA6C;EAA4B,CAAC;EAC7G,OAAO;CACT;;;;;;;CAQA,YAAY,UAA4B;EACtC,IAAI,KAAKA,SAAS,SAAS,GAAG;EAC9B,MAAM,WAAW,KAAKE;EACtB,SAAS,WACD;GACJ,IAAI,KAAKA,aAAa,UAAU;GAChC,SAAS;EACX,SACM,CAAC,CACT;CACF;CAEA,WAAiB;EACf,KAAK,MAAM,EAAE,UAAU,KAAKF,SAAS,OAAO,GAAG,KAAK,MAAM;EAC1D,KAAKA,SAAS,MAAM;EAIpB,KAAKG,kBAAkB;EACvB,KAAKA,kBAAkB;EACvB,KAAKD,WAAW,QAAQ,QAAQ;CAClC;CAEA,UAAgB;EACd,KAAKD,aAAa;EAClB,KAAK,SAAS;CAChB;AACF;;;;;;;;;;;;;;;AAoBA,IAAa,eAAb,MAA0B;CACxB,SAA2B,QAAQ,QAAQ;CAC3C,2BAAoB,IAAI,IAAgC;CACxD,WAA8C;CAC9C,aAAa;CAEb,SAA0C,MAAiD;EACzF,IAAI,KAAKA,YAAY,OAAO,QAAQ,QAAQ;EAC5C,MAAM,IAAI;EACV,KAAKD,SAAS,IAAI,CAAC;EAEnB,MAAM,SAAS,KAAKI,OACjB,WAAW;GACV,KAAKJ,SAAS,OAAO,CAAC;GACtB,KAAKK,WAAW;GAChB,OAAO,KAAK,IAAI;EAClB,CAAC,CAAC,CACD,cAAc;GACb,KAAKA,WAAW;EAClB,CAAC;EAGH,KAAKD,SAAS,OAAO,WACb,CAAC,SACD,CAAC,CACT;EAEA,OAAO;CACT;;;;;;;CAQA,IAAI,UAAyB;EAC3B,OAAO,KAAKA;CACd;;;;;;;;CASA,YAAY,UAA4B;EACtC,IAAI,KAAKJ,SAAS,SAAS,KAAK,KAAKK,aAAa,MAAM;EACxD,MAAM,eAAe,KAAKD;EAC1B,aAAa,WACL;GACJ,IAAI,KAAKA,WAAW,cAAc;GAClC,SAAS;EACX,SACM,CAAC,CACT;CACF;;CAGA,eAAqB;EACnB,KAAK,MAAM,QAAQ,KAAKJ,UAAU,KAAK,MAAM;EAC7C,KAAKA,SAAS,MAAM;CACtB;CAEA,WAAiB;EACf,KAAK,aAAa;EAClB,KAAKK,UAAU,MAAM;CACvB;CAEA,UAAgB;EACd,KAAKJ,aAAa;EAClB,KAAK,SAAS;CAChB;AACF;;;;;;AA8BA,MAAa,gBAAqC,QAAQ,QAAQ,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BvE,IAAa,kBAAb,MAA+C;CAC7C;CAKA,UAA4C;CAC5C,aAAa;CAEb,YAAY,YAAgC;EAC1C,KAAKK,cAAc;CACrB;;;;;;;;;;;;;;;;;;;;;;CAuBA,SAAS,MAAkD;EACzD,IAAI,KAAKL,YAAY,OAAO,QAAQ,QAAQ;EAI5C,IAAI,KAAKM,SAAS,OAAO,KAAK,IAAI,OAAO,KAAKA,QAAQ,IAAI;EAE1D,KAAKC,QAAQ;EACb,KAAKD,UAAU;EAIf,OAAO,QAAQ,IAAI,CAAC,KAAK,IAAI,GAAG,KAAKD,YAAY,IAAI,CAAC,CAAC,CAAC,CAAC,MACtD,CAAC,OAAO,WAAW;GAGlB,IAAI,KAAKC,YAAY,QAAQ,SAAS,CAAC,KAAK,OAAO,SAAS;IAG1D,KAAKA,UAAU;IACf,OAAO,KAAK,SAAS,KAAK,MAAM,CAAC;GACnC;GACA,IAAI,KAAKA,YAAY,MAAM,KAAKA,UAAU;GAC1C,OAAO;EACT,IACC,UAAU;GAET,IAAI,KAAKA,YAAY,MAAM,KAAKA,UAAU;GAI1C,IAAI,KAAK,OAAO,SAAS,OAAO,KAAA;GAChC,MAAM;EACR,CACF;CACF;CAEA,UAAgB;EACd,KAAKA,SAAS,MAAM;EACpB,KAAKA,UAAU;CACjB;CAEA,WAAiB;EACf,KAAKC,QAAQ;CACf;CAEA,UAAgB;EACd,KAAKP,aAAa;EAClB,KAAK,SAAS;CAChB;AACF"}
+{"version":3,"file":"task.js","names":["#runFn","#externalSignal","#abortController","#signal","#status","#value","#error","#previous","#promise","#execute","#pending","#destroyed","#settled","#resolveSettled","#chain","#current","#reschedule","#active","#cancel"],"sources":["../../../../src/core/tasks/task.ts"],"sourcesContent":["import { anyAbortSignal } from '@videojs/utils/events';\nimport { generateId } from '@videojs/utils/string';\n\n// =============================================================================\n// DeepReadonly\n// =============================================================================\n\n/** Recursively marks all properties as readonly. */\nexport type DeepReadonly<T> = T extends (infer U)[]\n  ? ReadonlyArray<DeepReadonly<U>>\n  : T extends object\n    ? { readonly [K in keyof T]: DeepReadonly<T[K]> }\n    : T;\n\n// =============================================================================\n// Task\n// =============================================================================\n\nexport type TaskStatus = 'pending' | 'running' | 'done' | 'error';\n\n/** Configuration for a Task. */\nexport interface TaskConfig {\n  /**\n   * Identifier for this task. - string: used as-is - () => string: called once at construction time - undefined: a\n   * unique ID is generated via generateId()\n   */\n  id?: string | (() => string);\n\n  /**\n   * Optional external AbortSignal to compose with the task's internal one. The task's work is aborted when either the\n   * internal controller (via abort()) or this external signal fires — whichever comes first.\n   */\n  signal?: AbortSignal;\n}\n\n/** Minimal contract for a schedulable unit of async work. */\nexport interface TaskLike<TValue = void, TError = unknown> {\n  readonly id: string;\n  readonly status: TaskStatus;\n  readonly value: DeepReadonly<TValue> | undefined;\n  readonly error: DeepReadonly<TError> | undefined;\n  /**\n   * The last successful value carried forward from the run this was `clone()`d from — the prior cycle's result for a\n   * `RecurringRunner` (undefined for an original, or until the lineage has produced a success).\n   */\n  readonly previous: DeepReadonly<TValue> | undefined;\n  /**\n   * The signal this task's work runs under (its own abort composed with any external one). Aborting the task fires it —\n   * so a `reschedule` can wait on it to have its delay cancelled when the recurrence is aborted.\n   */\n  readonly signal: AbortSignal;\n  /** Run the work, memoized: repeated calls share one execution + result. */\n  run(): Promise<TValue>;\n  abort(): void;\n  /** A fresh, structurally identical task (same work + id) in a pending state — for re-running. */\n  clone(): TaskLike<TValue, TError>;\n}\n\n/**\n * Generic reusable task that wraps an async run function.\n *\n * Owns its own AbortController so it can always be aborted independently. Optionally composes an external AbortSignal\n * so that a parent's cancellation propagates into the task's work without requiring the caller to track the task\n * separately.\n *\n * `run()` is memoized: the work runs at most once per instance, and every call returns the same promise (so observers\n * can `await run()` to read the result without re-triggering the work). To re-run the _same_ work, take a `clone()` — a\n * fresh instance with its own AbortController and a pending state.\n *\n * Ordering guarantee: `value` is written before `status` transitions to `'done'`; `error` is written before `status`\n * transitions to `'error'`. Any reader observing `status === 'done'` is guaranteed `value` is already present.\n */\nexport class Task<TValue = void, TError = unknown> implements TaskLike<TValue, TError> {\n  readonly id: string;\n  readonly #runFn: (signal: AbortSignal) => Promise<TValue>;\n  readonly #externalSignal: AbortSignal | undefined;\n  readonly #abortController = new AbortController();\n  readonly #signal: AbortSignal;\n\n  #status: TaskStatus = 'pending';\n  #value: TValue | undefined = undefined;\n  #error: TError | undefined = undefined;\n  #previous: TValue | undefined = undefined;\n  #promise: Promise<TValue> | undefined = undefined;\n\n  constructor(runFn: (signal: AbortSignal) => Promise<TValue>, config?: TaskConfig) {\n    this.#runFn = runFn;\n    const rawId = config?.id;\n\n    this.id = typeof rawId === 'function' ? rawId() : (rawId ?? generateId());\n    this.#externalSignal = config?.signal;\n    this.#signal = config?.signal\n      ? anyAbortSignal([this.#abortController.signal, config.signal])\n      : this.#abortController.signal;\n  }\n\n  get status(): TaskStatus {\n    return this.#status;\n  }\n\n  get value(): DeepReadonly<TValue> | undefined {\n    return this.#value as DeepReadonly<TValue> | undefined;\n  }\n\n  get error(): DeepReadonly<TError> | undefined {\n    return this.#error as DeepReadonly<TError> | undefined;\n  }\n\n  get previous(): DeepReadonly<TValue> | undefined {\n    return this.#previous as DeepReadonly<TValue> | undefined;\n  }\n\n  get signal(): AbortSignal {\n    return this.#signal;\n  }\n\n  run(): Promise<TValue> {\n    // Memoized: run the work once, sharing the same promise across calls. The\n    // memoized promise IS what callers await, so it's always handled (no orphan\n    // `Promise.resolve/reject`); a sync-throwing `#runFn` is captured as a\n    // rejection rather than re-run.\n    this.#promise ??= this.#execute();\n    return this.#promise;\n  }\n\n  async #execute(): Promise<TValue> {\n    this.#status = 'running';\n\n    try {\n      const result = await this.#runFn(this.#signal);\n\n      this.#value = result; // value before status — ordering guarantee\n      this.#status = 'done';\n      return result;\n    } catch (e) {\n      this.#error = e as TError; // error before status — ordering guarantee\n      this.#status = 'error';\n      throw e;\n    }\n  }\n\n  abort(): void {\n    this.#abortController.abort();\n  }\n\n  /**\n   * A fresh task with the same work, id, and external signal, in a pending state (its own AbortController, no memoized\n   * result) — so it can be run again. Used to re-run structurally identical work (e.g. `RecurringRunner` reloads).\n   *\n   * The clone inherits this run's value as its `previous` (or this run's own `previous` if it never produced one — e.g.\n   * it errored), so a recurrence's `previous` always tracks the last _successful_ value across the lineage with no\n   * bookkeeping in the runner.\n   */\n  clone(): Task<TValue, TError> {\n    const cloned = new Task<TValue, TError>(this.#runFn, { id: this.id, signal: this.#externalSignal });\n\n    cloned.#previous = this.#value ?? this.#previous;\n    return cloned;\n  }\n}\n\n// =============================================================================\n// ConcurrentRunner\n// =============================================================================\n\n/**\n * Runs tasks concurrently, deduplicated by task id.\n *\n * If a task with a given id is already in flight, subsequent schedule() calls for that id are silently ignored until\n * the first completes. Tasks are stored so abortAll() can cancel any in-flight work (e.g. on engine cleanup).\n */\nexport class ConcurrentRunner {\n  readonly #pending = new Map<string, { task: TaskLike<unknown, unknown>; promise: Promise<unknown> }>();\n  #settled: Promise<void> = Promise.resolve();\n  #resolveSettled: (() => void) | null = null;\n  #destroyed = false;\n\n  schedule<TValue = void, TError = unknown>(task: TaskLike<TValue, TError>): Promise<TValue> {\n    if (this.#destroyed) return Promise.resolve() as Promise<TValue>;\n\n    const existing = this.#pending.get(task.id);\n    if (existing) return existing.promise as Promise<TValue>;\n\n    if (this.#pending.size === 0) {\n      this.#settled = new Promise((resolve) => {\n        this.#resolveSettled = resolve;\n      });\n    }\n\n    const promise = task.run();\n\n    // Suppress unhandled rejection for callers that ignore the return value.\n    promise.catch(() => {});\n    // Cleanup: update pending and resolve settled regardless of outcome.\n    const cleanup = () => {\n      this.#pending.delete(task.id);\n\n      if (this.#pending.size === 0) {\n        this.#resolveSettled?.();\n        this.#resolveSettled = null;\n      }\n    };\n\n    promise.then(cleanup, cleanup);\n\n    this.#pending.set(task.id, { task: task as TaskLike<unknown, unknown>, promise: promise as Promise<unknown> });\n    return promise;\n  }\n\n  /**\n   * Registers a callback to fire when all currently in-flight tasks settle. If the runner is already idle, the callback\n   * is never called. If abortAll() is called before the batch settles, the callback is superseded and silently dropped\n   * — no stale callbacks, no generation token required by the caller.\n   */\n  whenSettled(callback: () => void): void {\n    if (this.#pending.size === 0) return;\n\n    const captured = this.#settled;\n\n    captured.then(\n      () => {\n        if (this.#settled !== captured) return;\n\n        callback();\n      },\n      () => {}\n    );\n  }\n\n  abortAll(): void {\n    for (const { task } of this.#pending.values()) task.abort();\n\n    this.#pending.clear();\n    // Resolve the current settled promise so any .then() handlers are queued,\n    // then replace the reference — whenSettled callbacks that captured the old\n    // reference will see the identity mismatch and be dropped.\n    this.#resolveSettled?.();\n    this.#resolveSettled = null;\n    this.#settled = Promise.resolve();\n  }\n\n  destroy(): void {\n    this.#destroyed = true;\n    this.abortAll();\n  }\n}\n\n// =============================================================================\n// SerialRunner\n// =============================================================================\n\n/**\n * Runs tasks one at a time in submission order.\n *\n * Each schedule() call returns a Promise that resolves or rejects with the task's result when it is eventually\n * executed. Tasks wait in queue until the prior task completes.\n *\n * Serialization is achieved by chaining each task's run() onto the tail of a shared promise chain — no explicit queue\n * or drain loop needed.\n *\n * AbortAll() aborts all pending (not yet started) tasks and the currently in-flight task. Pending tasks still run\n * briefly but receive an aborted signal and are expected to exit early.\n */\nexport class SerialRunner {\n  #chain: Promise<unknown> = Promise.resolve();\n  readonly #pending = new Set<TaskLike<unknown, unknown>>();\n  #current: TaskLike<unknown, unknown> | null = null;\n  #destroyed = false;\n\n  schedule<TValue = void, TError = unknown>(task: TaskLike<TValue, TError>): Promise<TValue> {\n    if (this.#destroyed) return Promise.resolve() as Promise<TValue>;\n\n    const t = task as TaskLike<unknown, unknown>;\n\n    this.#pending.add(t);\n\n    const result = this.#chain\n      .then(() => {\n        this.#pending.delete(t);\n        this.#current = t;\n        return task.run();\n      })\n      .finally(() => {\n        this.#current = null;\n      });\n\n    // Advance the chain regardless of whether this task succeeds or fails.\n    this.#chain = result.then(\n      () => {},\n      () => {}\n    );\n\n    return result as Promise<TValue>;\n  }\n\n  /**\n   * A promise that resolves when all currently-scheduled tasks have settled. Use the reference as a generation token:\n   * capture it after scheduling a batch, then check identity in the resolution callback to detect whether a subsequent\n   * abortAll() + new batch has superseded this one.\n   */\n  get settled(): Promise<void> {\n    return this.#chain as Promise<void>;\n  }\n\n  /**\n   * Registers a callback to fire when all currently-pending tasks settle. If the runner is already idle (no pending or\n   * running tasks), the callback is never called. If new tasks are scheduled before the current batch settles, the\n   * callback is superseded and silently dropped — no stale callbacks, no generation token required by the caller.\n   */\n  whenSettled(callback: () => void): void {\n    if (this.#pending.size === 0 && this.#current === null) return;\n\n    const currentChain = this.#chain;\n\n    currentChain.then(\n      () => {\n        if (this.#chain !== currentChain) return;\n\n        callback();\n      },\n      () => {}\n    );\n  }\n\n  /** Aborts and clears queued tasks without touching the in-flight task. */\n  abortPending(): void {\n    for (const task of this.#pending) task.abort();\n\n    this.#pending.clear();\n  }\n\n  abortAll(): void {\n    this.abortPending();\n    this.#current?.abort();\n  }\n\n  destroy(): void {\n    this.#destroyed = true;\n    this.abortAll();\n  }\n}\n\n// =============================================================================\n// RecurringRunner\n// =============================================================================\n\n/**\n * Decides whether — and _when_ — a {@link RecurringRunner} re-runs its task. Invoked **concurrently with the run** (so\n * the inter-run interval can be measured from when the run _started_, not when it finished) with the single\n * {@link TaskLike}, which carries everything a decision needs:\n *\n * - `task.run()` — the in-flight run, observable via this memoized call (does not re-trigger work), e.g. to read its\n *   result for a cadence/stop decision.\n * - `task.previous` — the prior successful run's value (`undefined` on the first), for decisions that compare consecutive\n *   results.\n * - `task.signal` — aborts the wait (and the recurrence) when the task is.\n *\n * Resolves `true` to re-run (after whatever delay it owns) or `false` to stop. The runner deals only in this awaitable\n * verdict — _how_ the delay is produced (a timer, a frame, an event) and _when_ it's measured from live entirely in the\n * reschedule function, so the runner itself knows nothing about time. See `delayedReschedule` for the common\n * timer-based, start-anchored implementation.\n */\nexport type Reschedule<TValue> = (task: TaskLike<TValue>) => PromiseLike<boolean>;\n\n/**\n * A {@link Reschedule} that never recurs — the task runs exactly once. Pass it to a {@link RecurringRunner} for\n * non-recurring, run-once work (e.g. resolving a complete VoD playlist that can never go stale).\n */\nexport const runOnce: Reschedule<unknown> = () => Promise.resolve(false);\n\n/**\n * Runs a task, then re-runs it whenever a {@link Reschedule} function says to, until it says stop (or it's aborted) —\n * the recurring sibling of {@link ConcurrentRunner} / {@link SerialRunner}, and like them it's handed a\n * {@link TaskLike} to run.\n *\n * The runner has no notion of time: it just awaits whatever `reschedule` returns (resolves `true` → re-run; `false` →\n * stop). A `reschedule` is required; pass {@link runOnce} for non-recurring, run-exactly-once work.\n *\n * Single-slot, keyed by task **id**: there is always at most one identified active task for re-running. Scheduling a\n * task whose id matches the active one is a no-op — the existing recurrence keeps running (dedup by id). Scheduling a\n * task with a _different_ id aborts the prior task's in-flight run and pending reschedule, then takes over the slot\n * (abort-and-replace) — the right shape when there's one logical unit of recurring work (e.g. reloading the _selected_\n * track's media playlist).\n *\n * Each re-run is a fresh `clone()` of the task (since `Task.run()` is memoized — the same instance won't re-execute),\n * carrying the same id so the slot's identity is stable across cycles. The clone also carries the prior cycle's value\n * forward as `task.previous`. The run function should read any inputs that change between cycles at call time rather\n * than capturing them once.\n *\n * The task is the sole cancellation channel: `abortAll()` aborts the active task, which fires `task.signal` —\n * cancelling both its in-flight run and any pending reschedule delay waiting on that signal. An aborted (or stopped)\n * recurrence frees the slot, so a later schedule of the same id starts fresh.\n */\nexport class RecurringRunner<TValue = unknown> {\n  readonly #reschedule: Reschedule<TValue>;\n  // The identified active task — the one being (re)run. Held across cycles\n  // (including the inter-cycle wait); null once the recurrence stops/aborts. Also\n  // serves as the ownership token: a cycle advances or frees the slot only while\n  // `#active` still points at its own task (a supersede/abortAll swaps it).\n  #active: TaskLike<TValue, unknown> | null = null;\n  #destroyed = false;\n\n  constructor(reschedule: Reschedule<TValue>) {\n    this.#reschedule = reschedule;\n  }\n\n  /**\n   * Run `task` and recur per the `reschedule` verdict, as a single promise. Resolves with the _final_ cycle's value\n   * when the recurrence stops; **rejects** if a run (or reschedule) genuinely fails — the rejection propagates to the\n   * caller, who owns error handling; the runner only frees its slot (no swallowing). The runner's _own_ cancellation\n   * (abort/supersede/destroy) is not a failure, so an aborted recurrence settles quietly rather than rejecting —\n   * callers don't have to `.catch` routine teardown.\n   *\n   * Each cycle runs the task and consults `reschedule` concurrently (so the delay can be measured from the run's\n   * start); when both settle and this cycle still owns the slot, a `true` verdict re-schedules a `clone()` whose\n   * promise is _returned_ — so the recurrence is the method calling itself, threaded into one promise, no separate\n   * loop. The clone shares the id, so the slot's identity is stable across cycles; it's released just before the\n   * re-schedule so the call advances rather than dedup-returning.\n   *\n   * Note: because each cycle's promise adopts the next, the chain retains every prior cycle for the life of the\n   * recurrence — bounded for finite recurrences, an unbounded (small per-cycle) cost for a long-lived one (e.g. live\n   * reload).\n   */\n  schedule(task: TaskLike<TValue, unknown>): Promise<TValue> {\n    if (this.#destroyed) return Promise.resolve() as Promise<TValue>;\n\n    // Dedup by id: this id is already the active re-run target, so the existing\n    // recurrence continues uninterrupted (don't restart it) — hand back its\n    // in-flight run.\n    if (this.#active?.id === task.id) return this.#active.run();\n\n    // Different id supersedes: abort the prior recurrence, then take over.\n    this.#cancel();\n    this.#active = task;\n\n    // Drive the run (in case `reschedule` doesn't observe it — e.g. `runOnce`)\n    // and the verdict together; a rejected run rejects the whole cycle.\n    return Promise.all([task.run(), this.#reschedule(task)]).then(\n      ([value, again]) => {\n        // Only act while we still own the slot — a supersede/abortAll swapped\n        // `#active`, in which case this stale cycle does nothing.\n        if (this.#active === task && again && !task.signal.aborted) {\n          // Release first so the same-id clone advances (isn't dedup-returned),\n          // then chain the next cycle into this promise.\n          this.#active = null;\n          return this.schedule(task.clone());\n        }\n\n        if (this.#active === task) this.#active = null; // natural stop / superseded\n\n        return value;\n      },\n      (error) => {\n        // The recurrence ended on a rejection; free the slot if we still own it.\n        if (this.#active === task) this.#active = null;\n\n        // The runner's own cancellation isn't a failure — settle quietly so\n        // routine teardown (abort/supersede/destroy) needs no caller `.catch`.\n        // A genuine run/reschedule failure propagates to the caller.\n        if (task.signal.aborted) return undefined as TValue;\n\n        throw error;\n      }\n    );\n  }\n\n  #cancel(): void {\n    this.#active?.abort();\n    this.#active = null;\n  }\n\n  abortAll(): void {\n    this.#cancel();\n  }\n\n  destroy(): void {\n    this.#destroyed = true;\n    this.abortAll();\n  }\n}\n"],"mappings":"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"}

package/dist/dev/hls.d.ts

@@ -3,7 +3,9 @@ import { SVTA_UNSUPPORTED_PLAYBACK_FEATURE, SvtaError, svtaCategory, svtaIndex }
 import { DeriveStartMediaTime } from "./playback/primitives/derive-start-media-time.js";
 import { derivePerTypeStartMediaTime, deriveSharedMinStartMediaTime } from "./playback/behaviors/establish-start-media-time.js";
 import { HlsAudioEngineConfig, HlsAudioEngineContext, HlsAudioEngineSignals, HlsAudioEngineState, createHlsAudioEngine } from "./playback/engines/hls/engine-audio-only.js";
+import { CodecPreferenceConfig, DEFAULT_PREFERRED_CODECS, preferCodecFamilies } from "./playback/primitives/selection-rules.js";
 import { SelectTrackRule, preferHighestResolution, screenResolutionCap } from "./playback/behaviors/select-tracks.js";
 import { BackgroundVideoEngineConfig, BackgroundVideoEngineContext, BackgroundVideoEngineSignals, BackgroundVideoEngineState, createBackgroundVideoEngine } from "./playback/engines/hls/engine-background-video.js";
 import { HlsVideoEngineConfig, HlsVideoEngineContext, HlsVideoEngineSignals, HlsVideoEngineState, createHlsVideoEngine } from "./playback/engines/hls/engine.js";
-export { type BackgroundVideoEngineConfig, type BackgroundVideoEngineContext, type BackgroundVideoEngineSignals, type BackgroundVideoEngineState, type DeriveStartMediaTime, type HlsAudioEngineConfig, type HlsAudioEngineContext, type HlsAudioEngineSignals, type HlsAudioEngineState, type HlsVideoEngineConfig, type HlsVideoEngineContext, type HlsVideoEngineSignals, type HlsVideoEngineState, type MediaPlaylistMetadata, SVTA_UNSUPPORTED_PLAYBACK_FEATURE, type SelectTrackRule, type SvtaError, createBackgroundVideoEngine, createHlsAudioEngine, createHlsVideoEngine, derivePerTypeStartMediaTime, deriveSharedMinStartMediaTime, getMediaPlaylistMetadata, preferHighestResolution, screenResolutionCap, svtaCategory, svtaIndex };
+import { stickToSelectedCodecs } from "./playback/behaviors/track-switching.js";
+export { type BackgroundVideoEngineConfig, type BackgroundVideoEngineContext, type BackgroundVideoEngineSignals, type BackgroundVideoEngineState, type CodecPreferenceConfig, DEFAULT_PREFERRED_CODECS, type DeriveStartMediaTime, type HlsAudioEngineConfig, type HlsAudioEngineContext, type HlsAudioEngineSignals, type HlsAudioEngineState, type HlsVideoEngineConfig, type HlsVideoEngineContext, type HlsVideoEngineSignals, type HlsVideoEngineState, type MediaPlaylistMetadata, SVTA_UNSUPPORTED_PLAYBACK_FEATURE, type SelectTrackRule, type SvtaError, createBackgroundVideoEngine, createHlsAudioEngine, createHlsVideoEngine, derivePerTypeStartMediaTime, deriveSharedMinStartMediaTime, getMediaPlaylistMetadata, preferCodecFamilies, preferHighestResolution, screenResolutionCap, stickToSelectedCodecs, svtaCategory, svtaIndex };

package/dist/dev/hls.js

@@ -1,8 +1,10 @@
 import { getMediaPlaylistMetadata } from "./media/types/index.js";
 import { SVTA_UNSUPPORTED_PLAYBACK_FEATURE, svtaCategory, svtaIndex } from "./media/errors.js";
 import { derivePerTypeStartMediaTime, deriveSharedMinStartMediaTime } from "./playback/behaviors/establish-start-media-time.js";
+import { DEFAULT_PREFERRED_CODECS, preferCodecFamilies } from "./playback/primitives/selection-rules.js";
 import { preferHighestResolution, screenResolutionCap } from "./playback/behaviors/select-tracks.js";
+import { stickToSelectedCodecs } from "./playback/behaviors/track-switching.js";
 import { createHlsVideoEngine } from "./playback/engines/hls/engine.js";
 import { createHlsAudioEngine } from "./playback/engines/hls/engine-audio-only.js";
 import { createBackgroundVideoEngine } from "./playback/engines/hls/engine-background-video.js";
-export { SVTA_UNSUPPORTED_PLAYBACK_FEATURE, createBackgroundVideoEngine, createHlsAudioEngine, createHlsVideoEngine, derivePerTypeStartMediaTime, deriveSharedMinStartMediaTime, getMediaPlaylistMetadata, preferHighestResolution, screenResolutionCap, svtaCategory, svtaIndex };
+export { DEFAULT_PREFERRED_CODECS, SVTA_UNSUPPORTED_PLAYBACK_FEATURE, createBackgroundVideoEngine, createHlsAudioEngine, createHlsVideoEngine, derivePerTypeStartMediaTime, deriveSharedMinStartMediaTime, getMediaPlaylistMetadata, preferCodecFamilies, preferHighestResolution, screenResolutionCap, stickToSelectedCodecs, svtaCategory, svtaIndex };

package/dist/dev/index.d.ts

@@ -12,9 +12,8 @@ import { Reactor, ReactorDefinition, ReactorDeriveFn, ReactorEffectFn, ReactorSt
 /**
  * Stream Processing Framework (SPF) for Video.js 10
  *
- * The compositional primitives: createComposition, signals, tasks, actors,
- * reactors. Media-domain helpers and the HLS playback engine live behind
- * the `./dom` and `./hls` subpaths.
+ * The compositional primitives: createComposition, signals, tasks, actors, reactors. Media-domain helpers and the HLS
+ * playback engine live behind the `./dom` and `./hls` subpaths.
  *
  * @packageDocumentation
  */

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

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