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

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

@@ -0,0 +1,54 @@
+import { Signal } from "signal-polyfill";
+//#region src/core/signals/primitives.ts
+/** 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).
+*
+* 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);
+*/
+function peek(source, transform = (v) => v) {
+	return untrack(() => transform(source.get()));
+}
+/** Create a writable reactive value. */
+function signal(initialValue, options) {
+	return new Signal.State(initialValue, options);
+}
+/** Create a computed reactive value. */
+function computed(fn, options) {
+	return new Signal.Computed(fn, options);
+}
+function update(signal, updater) {
+	const current = untrack(() => signal.get());
+	if (typeof updater === "function") signal.set(updater(current));
+	else signal.set({
+		...current,
+		...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.
+*
+* 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 = {};
+	for (const key in map) out[key] = map[key].get();
+	return out;
+}
+//#endregion
+export { computed, peek, signal, snapshot, untrack, update };
+
+//# sourceMappingURL=primitives.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,38 @@
+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).
+*
+* 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;
+	if (signal?.aborted) return Promise.reject(signal.reason);
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const settle = (complete) => {
+			if (settled) return;
+			settled = true;
+			complete();
+			queueMicrotask(() => {
+				signal?.removeEventListener("abort", onAbort);
+				stop();
+			});
+		};
+		const onAbort = () => settle(() => reject(signal?.reason));
+		signal?.addEventListener("abort", onAbort, { once: true });
+		const stop = effect(() => {
+			if (!settled && condition()) settle(resolve);
+		});
+	});
+}
+//#endregion
+export { when };
+
+//# sourceMappingURL=when.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,31 @@
+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.
+*
+* 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
+* layer, not in the cadence.
+*/
+function delayedReschedule(cadence) {
+	return async (task) => {
+		const startedAt = Date.now();
+		const ms = cadence(await task.run(), task.previous);
+		if (ms === null) return false;
+		await sleep(Math.max(0, ms - (Date.now() - startedAt)), task.signal);
+		return true;
+	};
+}
+//#endregion
+export { delayedReschedule };
+
+//# sourceMappingURL=delayed-reschedule.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,321 @@
+import { anyAbortSignal } from "@videojs/utils/events";
+import { generateId } from "@videojs/utils/string";
+//#region src/core/tasks/task.ts
+/**
+* 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.
+*
+* `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.
+*/
+var Task = class Task {
+	id;
+	#runFn;
+	#externalSignal;
+	#abortController = new AbortController();
+	#signal;
+	#status = "pending";
+	#value = void 0;
+	#error = void 0;
+	#previous = void 0;
+	#promise = void 0;
+	constructor(runFn, config) {
+		this.#runFn = runFn;
+		const rawId = config?.id;
+		this.id = typeof rawId === "function" ? rawId() : rawId ?? generateId();
+		this.#externalSignal = config?.signal;
+		this.#signal = config?.signal ? anyAbortSignal([this.#abortController.signal, config.signal]) : this.#abortController.signal;
+	}
+	get status() {
+		return this.#status;
+	}
+	get value() {
+		return this.#value;
+	}
+	get error() {
+		return this.#error;
+	}
+	get previous() {
+		return this.#previous;
+	}
+	get signal() {
+		return this.#signal;
+	}
+	run() {
+		this.#promise ??= this.#execute();
+		return this.#promise;
+	}
+	async #execute() {
+		this.#status = "running";
+		try {
+			const result = await this.#runFn(this.#signal);
+			this.#value = result;
+			this.#status = "done";
+			return result;
+		} catch (e) {
+			this.#error = e;
+			this.#status = "error";
+			throw e;
+		}
+	}
+	abort() {
+		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).
+	*
+	* 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, {
+			id: this.id,
+			signal: this.#externalSignal
+		});
+		cloned.#previous = this.#value ?? this.#previous;
+		return cloned;
+	}
+};
+/**
+* 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).
+*/
+var ConcurrentRunner = class {
+	#pending = /* @__PURE__ */ new Map();
+	#settled = Promise.resolve();
+	#resolveSettled = null;
+	#destroyed = false;
+	schedule(task) {
+		if (this.#destroyed) return Promise.resolve();
+		const existing = this.#pending.get(task.id);
+		if (existing) return existing.promise;
+		if (this.#pending.size === 0) this.#settled = new Promise((resolve) => {
+			this.#resolveSettled = resolve;
+		});
+		const promise = task.run();
+		promise.catch(() => {});
+		const cleanup = () => {
+			this.#pending.delete(task.id);
+			if (this.#pending.size === 0) {
+				this.#resolveSettled?.();
+				this.#resolveSettled = null;
+			}
+		};
+		promise.then(cleanup, cleanup);
+		this.#pending.set(task.id, {
+			task,
+			promise
+		});
+		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.
+	*/
+	whenSettled(callback) {
+		if (this.#pending.size === 0) return;
+		const captured = this.#settled;
+		captured.then(() => {
+			if (this.#settled !== captured) return;
+			callback();
+		}, () => {});
+	}
+	abortAll() {
+		for (const { task } of this.#pending.values()) task.abort();
+		this.#pending.clear();
+		this.#resolveSettled?.();
+		this.#resolveSettled = null;
+		this.#settled = Promise.resolve();
+	}
+	destroy() {
+		this.#destroyed = true;
+		this.abortAll();
+	}
+};
+/**
+* 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.
+*
+* 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.
+*/
+var SerialRunner = class {
+	#chain = Promise.resolve();
+	#pending = /* @__PURE__ */ new Set();
+	#current = null;
+	#destroyed = false;
+	schedule(task) {
+		if (this.#destroyed) return Promise.resolve();
+		const t = task;
+		this.#pending.add(t);
+		const result = this.#chain.then(() => {
+			this.#pending.delete(t);
+			this.#current = t;
+			return task.run();
+		}).finally(() => {
+			this.#current = null;
+		});
+		this.#chain = result.then(() => {}, () => {});
+		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.
+	*/
+	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.
+	*/
+	whenSettled(callback) {
+		if (this.#pending.size === 0 && this.#current === null) return;
+		const currentChain = this.#chain;
+		currentChain.then(() => {
+			if (this.#chain !== currentChain) return;
+			callback();
+		}, () => {});
+	}
+	/** Aborts and clears queued tasks without touching the in-flight task. */
+	abortPending() {
+		for (const task of this.#pending) task.abort();
+		this.#pending.clear();
+	}
+	abortAll() {
+		this.abortPending();
+		this.#current?.abort();
+	}
+	destroy() {
+		this.#destroyed = true;
+		this.abortAll();
+	}
+};
+/**
+* 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
+* {@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.
+*
+* 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.
+*
+* 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;
+	#active = null;
+	#destroyed = false;
+	constructor(reschedule) {
+		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 —
+	* 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.
+	*
+	* 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();
+		if (this.#active?.id === task.id) return this.#active.run();
+		this.#cancel();
+		this.#active = task;
+		return Promise.all([task.run(), this.#reschedule(task)]).then(([value, again]) => {
+			if (this.#active === task && again && !task.signal.aborted) {
+				this.#active = null;
+				return this.schedule(task.clone());
+			}
+			if (this.#active === task) this.#active = null;
+			return value;
+		}, (error) => {
+			if (this.#active === task) this.#active = null;
+			if (task.signal.aborted) return void 0;
+			throw error;
+		});
+	}
+	#cancel() {
+		this.#active?.abort();
+		this.#active = null;
+	}
+	abortAll() {
+		this.#cancel();
+	}
+	destroy() {
+		this.#destroyed = true;
+		this.abortAll();
+	}
+};
+//#endregion
+export { ConcurrentRunner, RecurringRunner, SerialRunner, Task, runOnce };
+
+//# sourceMappingURL=task.js.map

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

@@ -0,0 +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"}

package/dist/default/dom.js

@@ -0,0 +1,9 @@
+import { appendSegment } from "./media/dom/mse/append-segment.js";
+import { flushBuffer } from "./media/dom/mse/buffer-flusher.js";
+import { destroyVttResolver, resolveVttSegment } from "./media/dom/text/resolve-vtt-segment.js";
+import { loadAudioSegments, loadVideoSegments } from "./playback/behaviors/dom/load-segments.js";
+import { setupTextTrackActors } from "./playback/behaviors/dom/setup-text-track-actors.js";
+import { trackCurrentTime } from "./playback/behaviors/dom/track-current-time.js";
+import { trackLoadTriggers } from "./playback/behaviors/dom/track-load-triggers.js";
+import { trackPlaybackRate } from "./playback/behaviors/dom/track-playback-rate.js";
+export { appendSegment, destroyVttResolver, flushBuffer, loadAudioSegments, loadVideoSegments, resolveVttSegment, setupTextTrackActors, trackCurrentTime, trackLoadTriggers, trackPlaybackRate };

package/dist/default/hls-audio.js

@@ -0,0 +1,3 @@
+import { HlsAudioMediaElement, HlsAudioMediaMixin, hlsAudioMediaDefaultProps } from "./playback/adapters/hls-audio/adapter.js";
+import { HlsAudioMedia } from "./playback/adapters/hls-audio/media.js";
+export { HlsAudioMedia, HlsAudioMediaElement, HlsAudioMediaMixin, hlsAudioMediaDefaultProps };

package/dist/default/hls-background-video.js

@@ -0,0 +1,3 @@
+import { HlsBackgroundVideoMediaElement, HlsBackgroundVideoMediaMixin, hlsBackgroundVideoMediaDefaultProps } from "./playback/adapters/hls-background-video/adapter.js";
+import { HlsBackgroundVideoMedia } from "./playback/adapters/hls-background-video/media.js";
+export { HlsBackgroundVideoMedia, HlsBackgroundVideoMediaElement, HlsBackgroundVideoMediaMixin, hlsBackgroundVideoMediaDefaultProps };

package/dist/default/hls-video.js

@@ -0,0 +1,4 @@
+import { HlsVideoMediaElement, HlsVideoMediaMixin, hlsVideoMediaDefaultProps } from "./playback/adapters/hls-video/adapter.js";
+import { HlsVideoMediaMediaTracksMixin } from "./playback/adapters/hls-video/media-tracks.js";
+import { HlsVideoMedia } from "./playback/adapters/hls-video/media.js";
+export { HlsVideoMedia, HlsVideoMediaElement, HlsVideoMediaMediaTracksMixin, HlsVideoMediaMixin, hlsVideoMediaDefaultProps };

package/dist/default/hls.js

@@ -0,0 +1,8 @@
+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 { preferHighestResolution, screenResolutionCap } from "./playback/behaviors/select-tracks.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 };

package/dist/default/index.js

@@ -0,0 +1,23 @@
+import { computed, signal, snapshot, untrack, update } from "./core/signals/primitives.js";
+import { createComposition, defineBehavior } from "./core/composition/create-composition.js";
+import { makeShareSignals } from "./core/composition/share-signals.js";
+import { effect } from "./core/signals/effect.js";
+import { ConcurrentRunner, SerialRunner, Task } from "./core/tasks/task.js";
+import { createMachineActor } from "./core/actors/create-machine-actor.js";
+import { createTransitionActor } from "./core/actors/create-transition-actor.js";
+import { createMachineReactor } from "./core/reactors/create-machine-reactor.js";
+//#region src/index.ts
+/**
+* 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.
+*
+* @packageDocumentation
+*/
+const VERSION = "0.1.0";
+//#endregion
+export { ConcurrentRunner, SerialRunner, Task, VERSION, computed, createComposition, createMachineActor, createMachineReactor, createTransitionActor, defineBehavior, effect, makeShareSignals, signal, snapshot, untrack, update };
+
+//# sourceMappingURL=index.js.map

package/dist/default/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/**\n * Stream Processing Framework (SPF) for Video.js 10\n *\n * 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"}

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

@@ -0,0 +1,21 @@
+//#region src/media/abr/quality-selection.ts
+/**
+* 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.
+*/
+function resolutionArea(track) {
+	return (track.width ?? 0) * (track.height ?? 0);
+}
+//#endregion
+export { DEFAULT_QUALITY_CONFIG, resolutionArea };
+
+//# sourceMappingURL=quality-selection.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quality-selection.js","names":[],"sources":["../../../../src/media/abr/quality-selection.ts"],"sourcesContent":["/**\n * Quality Selection Algorithm\n *\n * Selects optimal video track based on bandwidth estimate with safety margin.\n * Stateless selection - picks highest quality that fits bandwidth.\n *\n * Key concepts:\n * - **Safety margin** (0.85): Pick track where bandwidth >= track.bandwidth / 0.85\n * - This ensures 15% headroom to avoid buffering\n * - At same bandwidth, prefer higher resolution\n */\n\nimport type { PartiallyResolvedVideoTrack, VideoTrack } from '../types';\n\n/**\n * Quality selection configuration.\n */\nexport interface QualityConfig {\n  /**\n   * Safety margin (0-1).\n   * To select a track, need: currentBandwidth >= track.bandwidth / safetyMargin.\n   * Default 0.85 means track must use ≤85% of available bandwidth (15% headroom).\n   */\n  safetyMargin: number;\n  /**\n   * Upgrade hysteresis ratio (>= 1). When `currentTrack` is supplied, an\n   * upgrade is applied only if `optimal.bandwidth >= currentTrack.bandwidth * upgradeMargin`.\n   * Downgrades are always applied. Default 1.15 means optimal must clear\n   * the current bandwidth by at least 15% to trigger an upgrade.\n   */\n  upgradeMargin: number;\n}\n\n/**\n * Default quality selection configuration.\n * Values match Shaka Player upgrade threshold (0.85 = 15% headroom).\n */\nexport const DEFAULT_QUALITY_CONFIG: QualityConfig = {\n  safetyMargin: 0.85,\n  upgradeMargin: 1.15,\n};\n\n/**\n * Selection context for `selectQuality`. The `bandwidth` field carries the\n * current network estimate; `safetyMargin` / `upgradeMargin` override the\n * defaults; `currentTrack` enables upgrade-vs-downgrade hysteresis.\n *\n * Shape matches the unified `selectOptimal` contract of\n * `setupTrackSwitching` (`playback/behaviors/track-switching.ts`) so the\n * function can be passed directly as a variant's `selectOptimal`.\n */\nexport interface SelectQualityCtx<T extends { bandwidth: number } = PartiallyResolvedVideoTrack | VideoTrack>\n  extends Partial<QualityConfig> {\n  bandwidth: number;\n  /**\n   * Track currently selected. When supplied, `selectQuality` returns\n   * `currentTrack` (no change) for upgrades that don't clear the\n   * `upgradeMargin`. When omitted, no hysteresis is applied — the\n   * computed optimal is returned regardless.\n   */\n  currentTrack?: T;\n}\n\n/**\n * Select the track to apply now, given a context that carries current\n * bandwidth, an optional `currentTrack`, and tuning overrides. Returns:\n *\n * - The bandwidth-fitting optimal when no `currentTrack` is supplied.\n * - The optimal when it's a downgrade vs. `currentTrack` (downgrades\n *   apply immediately — no hysteresis).\n * - The optimal when it clears `currentTrack.bandwidth * upgradeMargin`\n *   (upgrade clears hysteresis).\n * - `currentTrack` itself when an upgrade doesn't clear the margin\n *   (stay put — caller checks identity to no-op).\n *\n * \"Optimal\" is the highest-bandwidth track where the available bandwidth\n * meets the safety requirement (`bandwidth >= track.bandwidth / safetyMargin`).\n * Falls back to the lowest-bandwidth track when nothing fits the safety\n * margin (preserves a definitive pick under under-bandwidth conditions).\n *\n * @example\n * const tracks = [low, mid, high];\n * selectQuality(tracks, { bandwidth: 5_000_000, currentTrack: low });\n * // Returns `high` if 5 Mbps clears safety AND high.bandwidth >= low.bandwidth * upgradeMargin.\n * // Returns `low` (no-op signal) otherwise.\n */\nexport function selectQuality(\n  tracks: readonly (PartiallyResolvedVideoTrack | VideoTrack)[],\n  ctx: SelectQualityCtx\n): PartiallyResolvedVideoTrack | VideoTrack | undefined {\n  if (tracks.length === 0) {\n    return undefined;\n  }\n\n  const safetyMargin = ctx.safetyMargin ?? DEFAULT_QUALITY_CONFIG.safetyMargin;\n  const upgradeMargin = ctx.upgradeMargin ?? DEFAULT_QUALITY_CONFIG.upgradeMargin;\n  const { bandwidth: currentBandwidth, currentTrack } = ctx;\n\n  // Sort tracks by bandwidth (lowest first)\n  const sortedTracks = tracks.slice().sort((a, b) => a.bandwidth - b.bandwidth);\n\n  // Start with no selection\n  let chosen: PartiallyResolvedVideoTrack | VideoTrack | undefined;\n\n  for (const track of sortedTracks) {\n    // Check if we have enough bandwidth for this track with safety margin\n    // Required bandwidth = track.bandwidth / safetyMargin\n    const requiredBandwidth = track.bandwidth / safetyMargin;\n\n    if (currentBandwidth >= requiredBandwidth) {\n      // We can support this track - prefer it if better than current choice\n      if (\n        !chosen ||\n        track.bandwidth > chosen.bandwidth ||\n        (track.bandwidth === chosen.bandwidth && hasHigherResolution(track, chosen))\n      ) {\n        chosen = track;\n      }\n    }\n  }\n\n  // If no track fits with safety margin, fall back to lowest quality\n  const optimal = chosen ?? sortedTracks[0];\n  if (!optimal) return undefined;\n\n  // Apply upgrade hysteresis. No currentTrack → no hysteresis, return\n  // optimal. Downgrade (optimal.bandwidth < current) → always apply.\n  // Upgrade → only when `optimal.bandwidth >= current * upgradeMargin`,\n  // else stay put (return currentTrack so caller's id-compare no-ops).\n  if (!currentTrack) return optimal;\n  if (optimal.bandwidth < currentTrack.bandwidth) return optimal;\n  if (optimal.bandwidth >= currentTrack.bandwidth * upgradeMargin) return optimal;\n  return currentTrack;\n}\n\n/**\n * Select the lowest-bandwidth track from the candidate set.\n *\n * Used as a safety-net fallback by callers that need a definitive pick when\n * a primary selection algorithm declines to choose. Pairs naturally with\n * `selectQuality` — when ABR has no good answer (e.g., all candidates\n * exceed available bandwidth and the algorithm doesn't fall back\n * internally), the lowest bitrate is the safest default.\n *\n * @param tracks - Candidate tracks (can be unsorted)\n * @returns The lowest-bandwidth track, or `undefined` if `tracks` is empty\n *\n * @example\n * const fallback = selectLowestQuality(tracks);\n */\nexport function selectLowestQuality<T extends { bandwidth: number }>(tracks: readonly T[]): T | undefined {\n  if (tracks.length === 0) return undefined;\n  return tracks.reduce((min, t) => (t.bandwidth < min.bandwidth ? t : min));\n}\n\n/**\n * Resolution as a total pixel count (`width × height`), the basis for\n * comparing two tracks at the same bitrate. Missing dimensions count as 0, so\n * tracks without resolution metadata (e.g. audio) area-compare equal.\n */\nexport function resolutionArea(track: { width?: number; height?: number }): number {\n  return (track.width ?? 0) * (track.height ?? 0);\n}\n\n/**\n * Check if track A has higher resolution than track B.\n * Compares by total pixel count (width × height).\n *\n * @param trackA - First track to compare\n * @param trackB - Second track to compare\n * @returns True if trackA has more pixels than trackB\n */\nfunction hasHigherResolution(\n  trackA: PartiallyResolvedVideoTrack | VideoTrack,\n  trackB: PartiallyResolvedVideoTrack | VideoTrack\n): boolean {\n  return resolutionArea(trackA) > resolutionArea(trackB);\n}\n"],"mappings":";;;;;AAqCA,MAAa,yBAAwC;CACnD,cAAc;CACd,eAAe;AACjB;;;;;;AAwHA,SAAgB,eAAe,OAAoD;CACjF,QAAQ,MAAM,SAAS,MAAM,MAAM,UAAU;AAC/C"}