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

package/dist/default/core/signals/primitives.js

@@ -3,18 +3,15 @@ import { Signal } from "signal-polyfill";
 /** Read a signal value without tracking it as a dependency. */
 const untrack = Signal.subtle.untrack;
 /**
-* Read a signal's current value without tracking it as a dependency. Sugar
-* for `untrack(() => signal.get())` to reduce boilerplate at single-read
-* sites. Structurally typed to accept any signal-like (Signal, Computed,
-* ReadonlySignal).
+* Read a signal's current value without tracking it as a dependency. Sugar for `untrack(() => signal.get())` to reduce
+* boilerplate at single-read sites. Structurally typed to accept any signal-like (Signal, Computed, ReadonlySignal).
 *
-* Accepts an optional `transform` to project the value in the same call;
-* the default is the identity function so the single-arg form returns `T`
-* unchanged.
+* Accepts an optional `transform` to project the value in the same call; the default is the identity function so the
+* single-arg form returns `T` unchanged.
 *
 * @example
-* const value = peek(someSignal);
-* const id = peek(presentationSignal, (p) => p?.id);
+*   const value = peek(someSignal);
+*   const id = peek(presentationSignal, (p) => p?.id);
 */
 function peek(source, transform = (v) => v) {
 	return untrack(() => transform(source.get()));
@@ -36,12 +33,11 @@ function update(signal, updater) {
 	});
 }
 /**
-* Read every signal in a map and return a plain object snapshot. Each read
-* tracks in the surrounding Computed/Effect — equivalent to calling `.get()`
-* on a single `Signal<S>` over the merged shape.
+* Read every signal in a map and return a plain object snapshot. Each read tracks in the surrounding Computed/Effect —
+* equivalent to calling `.get()` on a single `Signal<S>` over the merged shape.
 *
-* Convenience for behaviors that pass whole state/context snapshots to pure
-* helpers; prefer per-field reads when only a few fields are needed.
+* Convenience for behaviors that pass whole state/context snapshots to pure helpers; prefer per-field reads when only a
+* few fields are needed.
 */
 function snapshot(map) {
 	const out = {};

package/dist/default/core/signals/primitives.js.map

@@ -1 +1 @@
-{"version":3,"file":"primitives.js","names":["SignalNS"],"sources":["../../../../src/core/signals/primitives.ts"],"sourcesContent":["import { Signal as SignalNS } from 'signal-polyfill';\n\n/** Read a signal value without tracking it as a dependency. */\nexport const untrack: <T>(fn: () => T) => T = SignalNS.subtle.untrack;\n\n/**\n * Read a signal's current value without tracking it as a dependency. Sugar\n * for `untrack(() => signal.get())` to reduce boilerplate at single-read\n * sites. Structurally typed to accept any signal-like (Signal, Computed,\n * ReadonlySignal).\n *\n * Accepts an optional `transform` to project the value in the same call;\n * the default is the identity function so the single-arg form returns `T`\n * unchanged.\n *\n * @example\n * const value = peek(someSignal);\n * const id = peek(presentationSignal, (p) => p?.id);\n */\nexport function peek<T, R = T>(source: { get(): T }, transform: (value: T) => R = (v: T) => v as unknown as R): R {\n  return untrack(() => transform(source.get()));\n}\n\n/** A writable reactive value (read + write). */\nexport type Signal<T> = SignalNS.State<T>;\n\n/** A derived reactive value that re-evaluates when its dependencies change (read-only). */\nexport type Computed<T> = SignalNS.Computed<T>;\n\n/** A read-only view of a reactive value. */\nexport type ReadonlySignal<T> = Omit<SignalNS.State<T>, 'set'>;\n\nexport interface SignalOptions<T> {\n  equals?: (t: T, t2: T) => boolean;\n}\n\n/** Create a writable reactive value. */\nexport function signal<T>(initialValue: T, options?: SignalOptions<T>): Signal<T> {\n  return new SignalNS.State(initialValue, options as SignalNS.Options<T>);\n}\n\n/** Create a computed reactive value. */\nexport function computed<T>(fn: () => T, options?: SignalOptions<T>): Computed<T> {\n  return new SignalNS.Computed(fn, options as SignalNS.Options<T>);\n}\n\n/**\n * Update a writable signal. Two forms:\n *\n * - **Updater function** `(current) => next`. Works for any signal type,\n *   including `Signal<T | undefined>` — handle undefined in the updater.\n * - **Partial object** to merge into the current state. Requires\n *   `T extends object`.\n *\n * @example\n * update(state, { playbackRate: 2 });\n * update(state, (s) => ({ ...s, count: s.count + 1 }));\n * update(maybeUndefinedSignal, (current) => current ?? defaultValue);\n */\nexport function update<T>(signal: Signal<T>, updater: (current: T) => T): void;\nexport function update<T extends object>(signal: Signal<T>, updater: Partial<T>): void;\nexport function update<T>(signal: Signal<T>, updater: ((current: T) => T) | object): void {\n  const current = untrack(() => signal.get());\n  if (typeof updater === 'function') {\n    signal.set((updater as (current: T) => T)(current));\n  } else {\n    // Partial<T> form — `T extends object` enforced by the public overload.\n    signal.set({ ...(current as object), ...updater } as T);\n  }\n}\n\n/**\n * Equality comparator for objects with an optional `id` field. Designed for\n * use as a `computed` `equals` option when reacting to identity changes\n * (Ham-shaped objects, JSON-API-shaped resources) while filtering internal\n * updates that preserve the id.\n *\n * Handles undefined inputs symmetrically: both undefined → equal; one\n * undefined → different.\n *\n * @example\n * const presentationById = computed(() => state.presentation.get(), {\n *   equals: equalsById,\n * });\n */\nexport function equalsById<T extends { id?: string }>(a: T | undefined, b: T | undefined): boolean {\n  return a?.id === b?.id;\n}\n\n/**\n * Read every signal in a map and return a plain object snapshot. Each read\n * tracks in the surrounding Computed/Effect — equivalent to calling `.get()`\n * on a single `Signal<S>` over the merged shape.\n *\n * Convenience for behaviors that pass whole state/context snapshots to pure\n * helpers; prefer per-field reads when only a few fields are needed.\n */\nexport function snapshot<M extends Record<string, ReadonlySignal<unknown>>>(\n  map: M\n): { [K in keyof M]: M[K] extends { get(): infer V } ? V : never } {\n  const out = {} as { [K in keyof M]: M[K] extends { get(): infer V } ? V : never };\n  for (const key in map) {\n    out[key] = map[key]!.get() as never;\n  }\n  return out;\n}\n"],"mappings":";;;AAGA,MAAa,UAAiCA,OAAS,OAAO;;;;;;;;;;;;;;;AAgB9D,SAAgB,KAAe,QAAsB,aAA8B,MAAS,GAAsB;CAChH,OAAO,cAAc,UAAU,OAAO,IAAI,CAAC,CAAC;AAC9C;;AAgBA,SAAgB,OAAU,cAAiB,SAAuC;CAChF,OAAO,IAAIA,OAAS,MAAM,cAAc,OAA8B;AACxE;;AAGA,SAAgB,SAAY,IAAa,SAAyC;CAChF,OAAO,IAAIA,OAAS,SAAS,IAAI,OAA8B;AACjE;AAiBA,SAAgB,OAAU,QAAmB,SAA6C;CACxF,MAAM,UAAU,cAAc,OAAO,IAAI,CAAC;CAC1C,IAAI,OAAO,YAAY,YACrB,OAAO,IAAK,QAA8B,OAAO,CAAC;MAGlD,OAAO,IAAI;EAAE,GAAI;EAAoB,GAAG;CAAQ,CAAM;AAE1D;;;;;;;;;AA4BA,SAAgB,SACd,KACiE;CACjE,MAAM,MAAM,CAAC;CACb,KAAK,MAAM,OAAO,KAChB,IAAI,OAAO,IAAI,IAAI,CAAE,IAAI;CAE3B,OAAO;AACT"}
+{"version":3,"file":"primitives.js","names":["SignalNS"],"sources":["../../../../src/core/signals/primitives.ts"],"sourcesContent":["import { Signal as SignalNS } from 'signal-polyfill';\n\n/** Read a signal value without tracking it as a dependency. */\nexport const untrack: <T>(fn: () => T) => T = SignalNS.subtle.untrack;\n\n/**\n * Read a signal's current value without tracking it as a dependency. Sugar for `untrack(() => signal.get())` to reduce\n * boilerplate at single-read sites. Structurally typed to accept any signal-like (Signal, Computed, ReadonlySignal).\n *\n * Accepts an optional `transform` to project the value in the same call; the default is the identity function so the\n * single-arg form returns `T` unchanged.\n *\n * @example\n *   const value = peek(someSignal);\n *   const id = peek(presentationSignal, (p) => p?.id);\n */\nexport function peek<T, R = T>(source: { get(): T }, transform: (value: T) => R = (v: T) => v as unknown as R): R {\n  return untrack(() => transform(source.get()));\n}\n\n/** A writable reactive value (read + write). */\nexport type Signal<T> = SignalNS.State<T>;\n\n/** A derived reactive value that re-evaluates when its dependencies change (read-only). */\nexport type Computed<T> = SignalNS.Computed<T>;\n\n/** A read-only view of a reactive value. */\nexport type ReadonlySignal<T> = Omit<SignalNS.State<T>, 'set'>;\n\nexport interface SignalOptions<T> {\n  equals?: (t: T, t2: T) => boolean;\n}\n\n/** Create a writable reactive value. */\nexport function signal<T>(initialValue: T, options?: SignalOptions<T>): Signal<T> {\n  return new SignalNS.State(initialValue, options as SignalNS.Options<T>);\n}\n\n/** Create a computed reactive value. */\nexport function computed<T>(fn: () => T, options?: SignalOptions<T>): Computed<T> {\n  return new SignalNS.Computed(fn, options as SignalNS.Options<T>);\n}\n\n/**\n * Update a writable signal. Two forms:\n *\n * - **Updater function** `(current) => next`. Works for any signal type, including `Signal<T | undefined>` — handle\n *   undefined in the updater.\n * - **Partial object** to merge into the current state. Requires `T extends object`.\n *\n * @example\n *   update(state, { playbackRate: 2 });\n *   update(state, (s) => ({ ...s, count: s.count + 1 }));\n *   update(maybeUndefinedSignal, (current) => current ?? defaultValue);\n */\nexport function update<T>(signal: Signal<T>, updater: (current: T) => T): void;\nexport function update<T extends object>(signal: Signal<T>, updater: Partial<T>): void;\nexport function update<T>(signal: Signal<T>, updater: ((current: T) => T) | object): void {\n  const current = untrack(() => signal.get());\n\n  if (typeof updater === 'function') {\n    signal.set((updater as (current: T) => T)(current));\n  } else {\n    // Partial<T> form — `T extends object` enforced by the public overload.\n    signal.set({ ...(current as object), ...updater } as T);\n  }\n}\n\n/**\n * Equality comparator for objects with an optional `id` field. Designed for use as a `computed` `equals` option when\n * reacting to identity changes (Ham-shaped objects, JSON-API-shaped resources) while filtering internal updates that\n * preserve the id.\n *\n * Handles undefined inputs symmetrically: both undefined → equal; one undefined → different.\n *\n * @example\n *   const presentationById = computed(() => state.presentation.get(), {\n *     equals: equalsById,\n *   });\n */\nexport function equalsById<T extends { id?: string }>(a: T | undefined, b: T | undefined): boolean {\n  return a?.id === b?.id;\n}\n\n/**\n * Read every signal in a map and return a plain object snapshot. Each read tracks in the surrounding Computed/Effect —\n * equivalent to calling `.get()` on a single `Signal<S>` over the merged shape.\n *\n * Convenience for behaviors that pass whole state/context snapshots to pure helpers; prefer per-field reads when only a\n * few fields are needed.\n */\nexport function snapshot<M extends Record<string, ReadonlySignal<unknown>>>(\n  map: M\n): { [K in keyof M]: M[K] extends { get(): infer V } ? V : never } {\n  const out = {} as { [K in keyof M]: M[K] extends { get(): infer V } ? V : never };\n\n  for (const key in map) {\n    out[key] = map[key]!.get() as never;\n  }\n\n  return out;\n}\n"],"mappings":";;;AAGA,MAAa,UAAiCA,OAAS,OAAO;;;;;;;;;;;;AAa9D,SAAgB,KAAe,QAAsB,aAA8B,MAAS,GAAsB;CAChH,OAAO,cAAc,UAAU,OAAO,IAAI,CAAC,CAAC;AAC9C;;AAgBA,SAAgB,OAAU,cAAiB,SAAuC;CAChF,OAAO,IAAIA,OAAS,MAAM,cAAc,OAA8B;AACxE;;AAGA,SAAgB,SAAY,IAAa,SAAyC;CAChF,OAAO,IAAIA,OAAS,SAAS,IAAI,OAA8B;AACjE;AAgBA,SAAgB,OAAU,QAAmB,SAA6C;CACxF,MAAM,UAAU,cAAc,OAAO,IAAI,CAAC;CAE1C,IAAI,OAAO,YAAY,YACrB,OAAO,IAAK,QAA8B,OAAO,CAAC;MAGlD,OAAO,IAAI;EAAE,GAAI;EAAoB,GAAG;CAAQ,CAAM;AAE1D;;;;;;;;AAyBA,SAAgB,SACd,KACiE;CACjE,MAAM,MAAM,CAAC;CAEb,KAAK,MAAM,OAAO,KAChB,IAAI,OAAO,IAAI,IAAI,CAAE,IAAI;CAG3B,OAAO;AACT"}

package/dist/default/core/signals/when.js

@@ -1,15 +1,13 @@
 import { effect } from "./effect.js";
 //#region src/core/signals/when.ts
 /**
-* Resolve once `condition` returns true. The condition is a tracked read — it
-* re-evaluates whenever a signal it read changes — so this is the promise
-* bridge from signal space into async task bodies (await a state condition
-* mid-task without polling).
+* Resolve once `condition` returns true. The condition is a tracked read — it re-evaluates whenever a signal it read
+* changes — so this is the promise bridge from signal space into async task bodies (await a state condition mid-task
+* without polling).
 *
-* Settles synchronously when the condition already holds. Rejects with the
-* abort reason when `signal` aborts first (an already-aborted signal rejects
-* without evaluating the condition), so a task awaiting a condition dies with
-* its runner instead of leaking the subscription.
+* Settles synchronously when the condition already holds. Rejects with the abort reason when `signal` aborts first (an
+* already-aborted signal rejects without evaluating the condition), so a task awaiting a condition dies with its runner
+* instead of leaking the subscription.
 */
 function when(condition, options = {}) {
 	const { signal } = options;

package/dist/default/core/signals/when.js.map

@@ -1 +1 @@
-{"version":3,"file":"when.js","names":[],"sources":["../../../../src/core/signals/when.ts"],"sourcesContent":["import { effect } from './effect';\n\n/**\n * Resolve once `condition` returns true. The condition is a tracked read — it\n * re-evaluates whenever a signal it read changes — so this is the promise\n * bridge from signal space into async task bodies (await a state condition\n * mid-task without polling).\n *\n * Settles synchronously when the condition already holds. Rejects with the\n * abort reason when `signal` aborts first (an already-aborted signal rejects\n * without evaluating the condition), so a task awaiting a condition dies with\n * its runner instead of leaking the subscription.\n */\nexport function when(condition: () => boolean, options: { signal?: AbortSignal } = {}): Promise<void> {\n  const { signal } = options;\n  if (signal?.aborted) return Promise.reject(signal.reason);\n\n  return new Promise<void>((resolve, reject) => {\n    let settled = false;\n    const settle = (complete: () => void) => {\n      if (settled) return;\n      settled = true;\n      complete();\n      // Deferred: on the effect's synchronous initial run `stop` isn't\n      // assigned yet, and stopping an effect from inside its own body is\n      // undefined behavior for the scheduler either way.\n      queueMicrotask(() => {\n        signal?.removeEventListener('abort', onAbort);\n        stop();\n      });\n    };\n    const onAbort = () => settle(() => reject(signal?.reason));\n    signal?.addEventListener('abort', onAbort, { once: true });\n    const stop = effect(() => {\n      if (!settled && condition()) settle(resolve);\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,SAAgB,KAAK,WAA0B,UAAoC,CAAC,GAAkB;CACpG,MAAM,EAAE,WAAW;CACnB,IAAI,QAAQ,SAAS,OAAO,QAAQ,OAAO,OAAO,MAAM;CAExD,OAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,IAAI,UAAU;EACd,MAAM,UAAU,aAAyB;GACvC,IAAI,SAAS;GACb,UAAU;GACV,SAAS;GAIT,qBAAqB;IACnB,QAAQ,oBAAoB,SAAS,OAAO;IAC5C,KAAK;GACP,CAAC;EACH;EACA,MAAM,gBAAgB,aAAa,OAAO,QAAQ,MAAM,CAAC;EACzD,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;EACzD,MAAM,OAAO,aAAa;GACxB,IAAI,CAAC,WAAW,UAAU,GAAG,OAAO,OAAO;EAC7C,CAAC;CACH,CAAC;AACH"}
+{"version":3,"file":"when.js","names":[],"sources":["../../../../src/core/signals/when.ts"],"sourcesContent":["import { effect } from './effect';\n\n/**\n * Resolve once `condition` returns true. The condition is a tracked read — it re-evaluates whenever a signal it read\n * changes — so this is the promise bridge from signal space into async task bodies (await a state condition mid-task\n * without polling).\n *\n * Settles synchronously when the condition already holds. Rejects with the abort reason when `signal` aborts first (an\n * already-aborted signal rejects without evaluating the condition), so a task awaiting a condition dies with its runner\n * instead of leaking the subscription.\n */\nexport function when(condition: () => boolean, options: { signal?: AbortSignal } = {}): Promise<void> {\n  const { signal } = options;\n  if (signal?.aborted) return Promise.reject(signal.reason);\n\n  return new Promise<void>((resolve, reject) => {\n    let settled = false;\n    const settle = (complete: () => void) => {\n      if (settled) return;\n\n      settled = true;\n      complete();\n      // Deferred: on the effect's synchronous initial run `stop` isn't\n      // assigned yet, and stopping an effect from inside its own body is\n      // undefined behavior for the scheduler either way.\n      queueMicrotask(() => {\n        signal?.removeEventListener('abort', onAbort);\n        stop();\n      });\n    };\n    const onAbort = () => settle(() => reject(signal?.reason));\n\n    signal?.addEventListener('abort', onAbort, { once: true });\n    const stop = effect(() => {\n      if (!settled && condition()) settle(resolve);\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;AAWA,SAAgB,KAAK,WAA0B,UAAoC,CAAC,GAAkB;CACpG,MAAM,EAAE,WAAW;CACnB,IAAI,QAAQ,SAAS,OAAO,QAAQ,OAAO,OAAO,MAAM;CAExD,OAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,IAAI,UAAU;EACd,MAAM,UAAU,aAAyB;GACvC,IAAI,SAAS;GAEb,UAAU;GACV,SAAS;GAIT,qBAAqB;IACnB,QAAQ,oBAAoB,SAAS,OAAO;IAC5C,KAAK;GACP,CAAC;EACH;EACA,MAAM,gBAAgB,aAAa,OAAO,QAAQ,MAAM,CAAC;EAEzD,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;EACzD,MAAM,OAAO,aAAa;GACxB,IAAI,CAAC,WAAW,UAAU,GAAG,OAAO,OAAO;EAC7C,CAAC;CACH,CAAC;AACH"}

package/dist/default/core/tasks/delayed-reschedule.js

@@ -1,19 +1,15 @@
 import { sleep } from "@videojs/utils/time";
 //#region src/core/tasks/delayed-reschedule.ts
 /**
-* Build a {@link Reschedule} from a pure cadence function — the common
-* timer-based, *start-anchored* implementation.
+* Build a {@link Reschedule} from a pure cadence function — the common timer-based, _start-anchored_ implementation.
 *
-* Invoked concurrently with the run, it observes the result, then waits
-* `cadence(current, previous)` milliseconds **measured from when it was invoked**
-* (≈ the run's start): it subtracts the run's own elapsed time, so consecutive
-* runs begin one cadence apart regardless of how long each run takes (per
-* RFC 8216 §6.3.4's "measured from the last time the client began loading"). If
-* the run takes longer than the cadence, the next run starts immediately.
+* Invoked concurrently with the run, it observes the result, then waits `cadence(current, previous)` milliseconds
+* **measured from when it was invoked** (≈ the run's start): it subtracts the run's own elapsed time, so consecutive
+* runs begin one cadence apart regardless of how long each run takes (per RFC 8216 §6.3.4's "measured from the last
+* time the client began loading"). If the run takes longer than the cadence, the next run starts immediately.
 *
-* A `null` cadence stops the recurrence. A rejected run rejects this reschedule,
-* which the `RecurringRunner` propagates as the recurrence's failure — error
-* recovery (e.g. retrying transient fetch failures) belongs below, at the fetch
+* A `null` cadence stops the recurrence. A rejected run rejects this reschedule, which the `RecurringRunner` propagates
+* as the recurrence's failure — error recovery (e.g. retrying transient fetch failures) belongs below, at the fetch
 * layer, not in the cadence.
 */
 function delayedReschedule(cadence) {

package/dist/default/core/tasks/delayed-reschedule.js.map

@@ -1 +1 @@
-{"version":3,"file":"delayed-reschedule.js","names":[],"sources":["../../../../src/core/tasks/delayed-reschedule.ts"],"sourcesContent":["import { sleep } from '@videojs/utils/time';\nimport type { Reschedule } from './task';\n\n/**\n * Build a {@link Reschedule} from a pure cadence function — the common\n * timer-based, *start-anchored* implementation.\n *\n * Invoked concurrently with the run, it observes the result, then waits\n * `cadence(current, previous)` milliseconds **measured from when it was invoked**\n * (≈ the run's start): it subtracts the run's own elapsed time, so consecutive\n * runs begin one cadence apart regardless of how long each run takes (per\n * RFC 8216 §6.3.4's \"measured from the last time the client began loading\"). If\n * the run takes longer than the cadence, the next run starts immediately.\n *\n * A `null` cadence stops the recurrence. A rejected run rejects this reschedule,\n * which the `RecurringRunner` propagates as the recurrence's failure — error\n * recovery (e.g. retrying transient fetch failures) belongs below, at the fetch\n * layer, not in the cadence.\n */\nexport function delayedReschedule<TValue>(\n  cadence: (current: TValue, previous: TValue | undefined) => number | null\n): Reschedule<TValue> {\n  return async (task) => {\n    const startedAt = Date.now();\n    const current = await task.run();\n    // `task.previous` is the prior successful value (carried by the runner's\n    // clone); read-only for the cadence, hence the cast off `DeepReadonly`.\n    const ms = cadence(current, task.previous as TValue | undefined);\n    if (ms === null) return false;\n    await sleep(Math.max(0, ms - (Date.now() - startedAt)), task.signal);\n    return true;\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,SAAgB,kBACd,SACoB;CACpB,OAAO,OAAO,SAAS;EACrB,MAAM,YAAY,KAAK,IAAI;EAI3B,MAAM,KAAK,QAAQ,MAHG,KAAK,IAAI,GAGH,KAAK,QAA8B;EAC/D,IAAI,OAAO,MAAM,OAAO;EACxB,MAAM,MAAM,KAAK,IAAI,GAAG,MAAM,KAAK,IAAI,IAAI,UAAU,GAAG,KAAK,MAAM;EACnE,OAAO;CACT;AACF"}
+{"version":3,"file":"delayed-reschedule.js","names":[],"sources":["../../../../src/core/tasks/delayed-reschedule.ts"],"sourcesContent":["import { sleep } from '@videojs/utils/time';\n\nimport type { Reschedule } from './task';\n\n/**\n * Build a {@link Reschedule} from a pure cadence function — the common timer-based, _start-anchored_ implementation.\n *\n * Invoked concurrently with the run, it observes the result, then waits `cadence(current, previous)` milliseconds\n * **measured from when it was invoked** (≈ the run's start): it subtracts the run's own elapsed time, so consecutive\n * runs begin one cadence apart regardless of how long each run takes (per RFC 8216 §6.3.4's \"measured from the last\n * time the client began loading\"). If the run takes longer than the cadence, the next run starts immediately.\n *\n * A `null` cadence stops the recurrence. A rejected run rejects this reschedule, which the `RecurringRunner` propagates\n * as the recurrence's failure — error recovery (e.g. retrying transient fetch failures) belongs below, at the fetch\n * layer, not in the cadence.\n */\nexport function delayedReschedule<TValue>(\n  cadence: (current: TValue, previous: TValue | undefined) => number | null\n): Reschedule<TValue> {\n  return async (task) => {\n    const startedAt = Date.now();\n    const current = await task.run();\n    // `task.previous` is the prior successful value (carried by the runner's\n    // clone); read-only for the cadence, hence the cast off `DeepReadonly`.\n    const ms = cadence(current, task.previous as TValue | undefined);\n    if (ms === null) return false;\n\n    await sleep(Math.max(0, ms - (Date.now() - startedAt)), task.signal);\n    return true;\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;AAgBA,SAAgB,kBACd,SACoB;CACpB,OAAO,OAAO,SAAS;EACrB,MAAM,YAAY,KAAK,IAAI;EAI3B,MAAM,KAAK,QAAQ,MAHG,KAAK,IAAI,GAGH,KAAK,QAA8B;EAC/D,IAAI,OAAO,MAAM,OAAO;EAExB,MAAM,MAAM,KAAK,IAAI,GAAG,MAAM,KAAK,IAAI,IAAI,UAAU,GAAG,KAAK,MAAM;EACnE,OAAO;CACT;AACF"}

package/dist/default/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/default/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":"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"}
+{"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/default/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/default/index.js

@@ -10,9 +10,8 @@ import { createMachineReactor } from "./core/reactors/create-machine-reactor.js"
 /**
 * 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/default/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/**\n * Stream Processing Framework (SPF) for Video.js 10\n *\n * The compositional primitives: createComposition, signals, tasks, actors,\n * reactors. Media-domain helpers and the HLS playback engine live behind\n * the `./dom` and `./hls` subpaths.\n *\n * @packageDocumentation\n */\n\nexport const VERSION = '0.1.0';\n\n// =============================================================================\n// Composition\n// =============================================================================\n\nexport type {\n  Behavior,\n  BehaviorCleanup,\n  BehaviorDeps,\n  Composition,\n  CompositionOptions,\n  ContextSignals,\n  InferBehaviorConfig,\n  InferBehaviorContext,\n  InferBehaviorState,\n  ResolveBehaviorConfig,\n  ResolveBehaviorContext,\n  ResolveBehaviorState,\n  StateSignals,\n} from './core/composition/create-composition';\nexport { createComposition, defineBehavior } from './core/composition/create-composition';\nexport type { ShareSignalsConfig } from './core/composition/share-signals';\nexport { makeShareSignals } from './core/composition/share-signals';\n\n// =============================================================================\n// Signals\n// =============================================================================\n\nexport { effect } from './core/signals/effect';\nexport type { Computed, ReadonlySignal, Signal, SignalOptions } from './core/signals/primitives';\nexport { computed, signal, snapshot, untrack, update } from './core/signals/primitives';\n\n// =============================================================================\n// Tasks\n// =============================================================================\n\nexport type { TaskConfig, TaskLike, TaskStatus } from './core/tasks/task';\nexport { ConcurrentRunner, SerialRunner, Task } from './core/tasks/task';\n\n// =============================================================================\n// Machine (shared by actors and reactors)\n// =============================================================================\n\nexport type { Machine, MachineSnapshot } from './core/machine';\n\n// =============================================================================\n// Actors\n// =============================================================================\n\nexport type { ActorSnapshot, CallbackActor, SignalActor } from './core/actors/actor';\nexport type {\n  ActorDefinition,\n  ActorStateDefinition,\n  HandlerContext,\n  MessageActor,\n  RunnerLike,\n} from './core/actors/create-machine-actor';\nexport { createMachineActor } from './core/actors/create-machine-actor';\nexport type { TransitionActor } from './core/actors/create-transition-actor';\nexport { createTransitionActor } from './core/actors/create-transition-actor';\n\n// =============================================================================\n// Reactors\n// =============================================================================\n\nexport type {\n  Reactor,\n  ReactorDefinition,\n  ReactorDeriveFn,\n  ReactorEffectFn,\n  ReactorStateDefinition,\n} from './core/reactors/create-machine-reactor';\nexport { createMachineReactor } from './core/reactors/create-machine-reactor';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAUA,MAAa,UAAU"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/**\n * Stream Processing Framework (SPF) for Video.js 10\n *\n * The compositional primitives: createComposition, signals, tasks, actors, reactors. Media-domain helpers and the HLS\n * playback engine live behind the `./dom` and `./hls` subpaths.\n *\n * @packageDocumentation\n */\n\nexport const VERSION = '0.1.0';\n\n// =============================================================================\n// Composition\n// =============================================================================\n\nexport type {\n  Behavior,\n  BehaviorCleanup,\n  BehaviorDeps,\n  Composition,\n  CompositionOptions,\n  ContextSignals,\n  InferBehaviorConfig,\n  InferBehaviorContext,\n  InferBehaviorState,\n  ResolveBehaviorConfig,\n  ResolveBehaviorContext,\n  ResolveBehaviorState,\n  StateSignals,\n} from './core/composition/create-composition';\nexport { createComposition, defineBehavior } from './core/composition/create-composition';\nexport type { ShareSignalsConfig } from './core/composition/share-signals';\nexport { makeShareSignals } from './core/composition/share-signals';\n\n// =============================================================================\n// Signals\n// =============================================================================\n\nexport { effect } from './core/signals/effect';\nexport type { Computed, ReadonlySignal, Signal, SignalOptions } from './core/signals/primitives';\nexport { computed, signal, snapshot, untrack, update } from './core/signals/primitives';\n\n// =============================================================================\n// Tasks\n// =============================================================================\n\nexport type { TaskConfig, TaskLike, TaskStatus } from './core/tasks/task';\nexport { ConcurrentRunner, SerialRunner, Task } from './core/tasks/task';\n\n// =============================================================================\n// Machine (shared by actors and reactors)\n// =============================================================================\n\nexport type { Machine, MachineSnapshot } from './core/machine';\n\n// =============================================================================\n// Actors\n// =============================================================================\n\nexport type { ActorSnapshot, CallbackActor, SignalActor } from './core/actors/actor';\nexport type {\n  ActorDefinition,\n  ActorStateDefinition,\n  HandlerContext,\n  MessageActor,\n  RunnerLike,\n} from './core/actors/create-machine-actor';\nexport { createMachineActor } from './core/actors/create-machine-actor';\nexport type { TransitionActor } from './core/actors/create-transition-actor';\nexport { createTransitionActor } from './core/actors/create-transition-actor';\n\n// =============================================================================\n// Reactors\n// =============================================================================\n\nexport type {\n  Reactor,\n  ReactorDefinition,\n  ReactorDeriveFn,\n  ReactorEffectFn,\n  ReactorStateDefinition,\n} from './core/reactors/create-machine-reactor';\nexport { createMachineReactor } from './core/reactors/create-machine-reactor';\n"],"mappings":";;;;;;;;;;;;;;;;;AASA,MAAa,UAAU"}

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

@@ -1,16 +1,12 @@
 //#region src/media/abr/quality-selection.ts
-/**
-* Default quality selection configuration.
-* Values match Shaka Player upgrade threshold (0.85 = 15% headroom).
-*/
+/** Default quality selection configuration. Values match Shaka Player upgrade threshold (0.85 = 15% headroom). */
 const DEFAULT_QUALITY_CONFIG = {
 	safetyMargin: .85,
 	upgradeMargin: 1.15
 };
 /**
-* Resolution as a total pixel count (`width × height`), the basis for
-* comparing two tracks at the same bitrate. Missing dimensions count as 0, so
-* tracks without resolution metadata (e.g. audio) area-compare equal.
+* Resolution as a total pixel count (`width × height`), the basis for comparing two tracks at the same bitrate. Missing
+* dimensions count as 0, so tracks without resolution metadata (e.g. audio) area-compare equal.
 */
 function resolutionArea(track) {
 	return (track.width ?? 0) * (track.height ?? 0);