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

package/dist/dev/core/reactors/create-machine-reactor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-machine-reactor.js","names":[],"sources":["../../../../src/core/reactors/create-machine-reactor.ts"],"sourcesContent":["import type { Machine, MachineSnapshot } from '../machine';\nimport { createMachineCore } from '../machine';\nimport { effect } from '../signals/effect';\nimport { untrack } from '../signals/primitives';\n\n// =============================================================================\n// Definition types\n// =============================================================================\n\n/**\n * A reactive state-deriving function used in the `monitor` field.\n *\n * Returns the target state the reactor should be in. Any signals read inside\n * the fn body create reactive dependencies — the framework re-evaluates it when\n * those signals change and automatically calls `transition()` when the returned\n * state differs from the current one.\n */\nexport type ReactorDeriveFn<State extends string> = () => State;\n\n/**\n * An effect function used in reactor `entry` and `effects` blocks.\n *\n * May return a cleanup function that runs before each re-evaluation and on\n * state exit (including destroy).\n */\nexport type ReactorEffectFn = () => (() => void) | { abort(): void } | void;\n\n/**\n * Per-state effect grouping for a single reactor state.\n *\n * - `entry` effects run once on state entry. The fn body is automatically\n *   untracked — no `untrack()` calls are needed inside. Use this for\n *   one-time setup: reading current values, attaching event listeners, etc.\n * - `effects` run on state entry and re-run whenever a signal read inside\n *   the fn body changes. Use `untrack()` for reads you do not want to track.\n *   Use this for work that must stay in sync with reactive state.\n *\n * Both are optional; pass `{}` for states with no effects.\n */\nexport type ReactorStateDefinition = {\n  entry?: ReactorEffectFn | ReactorEffectFn[];\n  effects?: ReactorEffectFn | ReactorEffectFn[];\n};\n\n/**\n * Full reactor definition passed to `createMachineReactor`.\n *\n * `State` is the set of domain-meaningful states. `'destroying'` and\n * `'destroyed'` are always added by the framework as implicit terminal states —\n * do not include them here.\n */\nexport type ReactorDefinition<State extends string> = {\n  /** Initial state. */\n  initial: State;\n  /**\n   * Reactive state derivation. Registered before per-state effects — the\n   * ordering guarantee ensures transitions fired here take effect before\n   * per-state effects re-evaluate in the same flush.\n   */\n  monitor?: ReactorDeriveFn<State> | ReactorDeriveFn<State>[];\n  /**\n   * Per-state effect groupings. Every valid state must be declared — pass `{}`\n   * for states with no effects. `entry` and `effects` each become independent\n   * `effect()` calls gated on that state, with their own cleanup lifecycles.\n   */\n  states: Record<State, ReactorStateDefinition>;\n};\n\n// =============================================================================\n// Live reactor interface\n// =============================================================================\n\n/** Live reactor instance returned by `createMachineReactor`. */\nexport type Reactor<State extends string> = Machine<MachineSnapshot<State>>;\n\n// =============================================================================\n// Implementation helpers\n// =============================================================================\n\nconst toArray = <T>(x: T | T[] | undefined): T[] => (x === undefined ? [] : Array.isArray(x) ? x : [x]);\n\n// =============================================================================\n// Implementation\n// =============================================================================\n\n/**\n * Creates a reactive Reactor from a declarative definition.\n *\n * A Reactor is driven by subscriptions to external signals rather than\n * imperative messages. Each state holds an array of effect functions —\n * every element becomes one independent `effect()` call gated on that state,\n * with its own dependency tracking and cleanup lifecycle.\n *\n * `'destroying'` and `'destroyed'` are always implicit terminal states.\n * `destroy()` transitions through both in sequence: `'destroying'` first (for\n * potential async teardown in a future extension), then immediately `'destroyed'`\n * for the synchronous base case. Active effect cleanups fire via disposal.\n *\n * @example\n * const reactor = createMachineReactor({\n *   initial: 'waiting',\n *   monitor: () => srcSignal.get() ? 'active' : 'waiting',\n *   states: {\n *     active: {\n *       // entry: runs once on state entry; fn body is automatically untracked.\n *       entry: () => listen(el, 'play', handler),\n *       // effects: re-runs whenever tracked signals change.\n *       effects: () => { currentTimeSignal.get(); return cleanup; },\n *     },\n *     waiting: {},\n *   }\n * });\n */\nexport function createMachineReactor<State extends string>(\n  def: ReactorDefinition<State>\n): Reactor<State | 'destroying' | 'destroyed'> {\n  type FullState = State | 'destroying' | 'destroyed';\n\n  const { snapshotSignal, getState, transition } = createMachineCore<FullState, MachineSnapshot<FullState>>({\n    value: def.initial as FullState,\n  });\n\n  const effectDisposals: Array<() => void> = [];\n\n  const wrapResult = (result: ReturnType<ReactorEffectFn>) => {\n    if (!result) return undefined;\n    if (typeof result === 'function') return result;\n    return () => result.abort();\n  };\n\n  type EffectCall = () => ReturnType<ReactorEffectFn>;\n\n  type EffectDescriptor = {\n    fn: ReactorEffectFn;\n    shouldSkip: (snapshot: { value: FullState }) => boolean;\n    toFnCall?: (baseCall: EffectCall) => EffectCall;\n  };\n\n  const untracked: EffectDescriptor['toFnCall'] = (baseCall) => () => untrack(baseCall);\n\n  const isTerminal = (snapshot: { value: FullState }) =>\n    snapshot.value === 'destroying' || snapshot.value === 'destroyed';\n\n  // `monitor` descriptors are built first — the ordering guarantee ensures\n  // transitions they trigger take effect before per-state effects re-evaluate\n  // in the same flush. See the comment on effect registration order in the\n  // previous implementation for full details.\n  const descriptors: EffectDescriptor[] = [\n    ...toArray(def.monitor).map((fn) => ({\n      fn: () => {\n        const target = fn();\n        if (target !== (getState() as State)) transition(target as FullState);\n      },\n      shouldSkip: isTerminal,\n    })),\n    ...(Object.entries(def.states) as Array<[State, ReactorStateDefinition]>).flatMap(([state, stateDef]) => {\n      const isNotState = (snapshot: { value: FullState }) => snapshot.value !== state;\n      return [\n        ...toArray(stateDef.entry).map((fn) => ({ fn, shouldSkip: isNotState, toFnCall: untracked })),\n        ...toArray(stateDef.effects).map((fn) => ({ fn, shouldSkip: isNotState })),\n      ];\n    }),\n  ];\n\n  const toEffect = ({ fn, shouldSkip, toFnCall = (baseCall) => baseCall }: EffectDescriptor) =>\n    effect(() => {\n      const snapshot = snapshotSignal.get();\n      if (shouldSkip(snapshot)) return;\n      const baseCall = () => fn();\n      return wrapResult(toFnCall(baseCall)());\n    });\n\n  effectDisposals.push(...descriptors.map(toEffect));\n\n  return {\n    get snapshot() {\n      return snapshotSignal;\n    },\n\n    destroy(): void {\n      const state = getState();\n      if (state === 'destroying' || state === 'destroyed') return;\n      // Two-step teardown: transition through 'destroying' first to leave room\n      // for async teardown in a future extension, then immediately 'destroyed'\n      // for the synchronous base case. Active effect cleanups fire via disposal.\n      transition('destroying');\n      transition('destroyed');\n      for (const dispose of effectDisposals) dispose();\n    },\n  };\n}\n"],"mappings":";;;;AA+EA,MAAM,WAAc,MAAiC,MAAM,KAAA,IAAY,EAAE,GAAG,MAAM,QAAQ,EAAE,GAAG,IAAI,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCtG,SAAgB,qBACd,KAC6C;CAG7C,MAAM,EAAE,gBAAgB,UAAU,eAAe,kBAAyD,EACxG,OAAO,IAAI,SACZ,CAAC;CAEF,MAAM,kBAAqC,EAAE;CAE7C,MAAM,cAAc,WAAwC;AAC1D,MAAI,CAAC,OAAQ,QAAO,KAAA;AACpB,MAAI,OAAO,WAAW,WAAY,QAAO;AACzC,eAAa,OAAO,OAAO;;CAW7B,MAAM,aAA2C,mBAAmB,QAAQ,SAAS;CAErF,MAAM,cAAc,aAClB,SAAS,UAAU,gBAAgB,SAAS,UAAU;CAMxD,MAAM,cAAkC,CACtC,GAAG,QAAQ,IAAI,QAAQ,CAAC,KAAK,QAAQ;EACnC,UAAU;GACR,MAAM,SAAS,IAAI;AACnB,OAAI,WAAY,UAAU,CAAY,YAAW,OAAoB;;EAEvE,YAAY;EACb,EAAE,EACH,GAAI,OAAO,QAAQ,IAAI,OAAO,CAA4C,SAAS,CAAC,OAAO,cAAc;EACvG,MAAM,cAAc,aAAmC,SAAS,UAAU;AAC1E,SAAO,CACL,GAAG,QAAQ,SAAS,MAAM,CAAC,KAAK,QAAQ;GAAE;GAAI,YAAY;GAAY,UAAU;GAAW,EAAE,EAC7F,GAAG,QAAQ,SAAS,QAAQ,CAAC,KAAK,QAAQ;GAAE;GAAI,YAAY;GAAY,EAAE,CAC3E;GACD,CACH;CAED,MAAM,YAAY,EAAE,IAAI,YAAY,YAAY,aAAa,eAC3D,aAAa;AAEX,MAAI,WADa,eAAe,KAAK,CACb,CAAE;EAC1B,MAAM,iBAAiB,IAAI;AAC3B,SAAO,WAAW,SAAS,SAAS,EAAE,CAAC;GACvC;AAEJ,iBAAgB,KAAK,GAAG,YAAY,IAAI,SAAS,CAAC;AAElD,QAAO;EACL,IAAI,WAAW;AACb,UAAO;;EAGT,UAAgB;GACd,MAAM,QAAQ,UAAU;AACxB,OAAI,UAAU,gBAAgB,UAAU,YAAa;AAIrD,cAAW,aAAa;AACxB,cAAW,YAAY;AACvB,QAAK,MAAM,WAAW,gBAAiB,UAAS;;EAEnD"}

package/dist/dev/core/signals/primitives.d.ts

@@ -1,10 +1,47 @@
 import { Signal } from "signal-polyfill";
 
 //#region src/core/signals/primitives.d.ts
+/** Read a signal value without tracking it as a dependency. */
+declare const untrack: <T>(fn: () => T) => T;
 /** A writable reactive value (read + write). */
 type Signal$1<T> = Signal.State<T>;
+/** A derived reactive value that re-evaluates when its dependencies change (read-only). */
+type Computed<T> = Signal.Computed<T>;
 /** A read-only view of a reactive value. */
 type ReadonlySignal<T> = Omit<Signal.State<T>, 'set'>;
+interface SignalOptions<T> {
+  equals?: (t: T, t2: T) => boolean;
+}
+/** Create a writable reactive value. */
+declare function signal<T>(initialValue: T, options?: SignalOptions<T>): Signal$1<T>;
+/** Create a computed reactive value. */
+declare function computed<T>(fn: () => T, options?: SignalOptions<T>): Computed<T>;
+/**
+ * Update a writable signal. Two forms:
+ *
+ * - **Updater function** `(current) => next`. Works for any signal type,
+ *   including `Signal<T | undefined>` — handle undefined in the updater.
+ * - **Partial object** to merge into the current state. Requires
+ *   `T extends object`.
+ *
+ * @example
+ * update(state, { playbackRate: 2 });
+ * update(state, (s) => ({ ...s, count: s.count + 1 }));
+ * update(maybeUndefinedSignal, (current) => current ?? defaultValue);
+ */
+declare function update<T>(signal: Signal$1<T>, updater: (current: T) => T): void;
+declare function update<T extends object>(signal: Signal$1<T>, updater: Partial<T>): void;
+/**
+ * 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.
+ */
+declare function snapshot<M extends Record<string, ReadonlySignal<unknown>>>(map: M): { [K in keyof M]: M[K] extends {
+  get(): infer V;
+} ? V : never };
 //#endregion
-export { ReadonlySignal, Signal$1 as Signal };
+export { Computed, ReadonlySignal, Signal$1 as Signal, SignalOptions, computed, signal, snapshot, untrack, update };
 //# sourceMappingURL=primitives.d.ts.map

package/dist/dev/core/signals/primitives.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"primitives.d.ts","names":[],"sources":["../../../../src/core/signals/primitives.ts"],"mappings":";;;AAMA;AAAA,KAAY,QAAA,MAAY,MAAA,CAAS,KAAA,CAAM,CAAA;;KAM3B,cAAA,MAAoB,IAAA,CAAK,MAAA,CAAS,KAAA,CAAM,CAAA"}
+{"version":3,"file":"primitives.d.ts","names":[],"sources":["../../../../src/core/signals/primitives.ts"],"mappings":";;;;cAGa,OAAA,MAAa,EAAA,QAAU,CAAA,KAAM,CAAA;;KAqB9B,QAAA,MAAY,MAAA,CAAS,KAAA,CAAM,CAAA;;KAG3B,QAAA,MAAc,MAAA,CAAS,QAAA,CAAS,CAAA;;KAGhC,cAAA,MAAoB,IAAA,CAAK,MAAA,CAAS,KAAA,CAAM,CAAA;AAAA,UAEnC,aAAA;EACf,MAAA,IAAU,CAAA,EAAG,CAAA,EAAG,EAAA,EAAI,CAAA;AAAA;;iBAIN,MAAA,GAAA,CAAU,YAAA,EAAc,CAAA,EAAG,OAAA,GAAU,aAAA,CAAc,CAAA,IAAK,QAAA,CAAO,CAAA;;iBAK/D,QAAA,GAAA,CAAY,EAAA,QAAU,CAAA,EAAG,OAAA,GAAU,aAAA,CAAc,CAAA,IAAK,QAAA,CAAS,CAAA;AAZ/E;;;;;;;;;;;;;AAAA,iBA6BgB,MAAA,GAAA,CAAU,MAAA,EAAQ,QAAA,CAAO,CAAA,GAAI,OAAA,GAAU,OAAA,EAAS,CAAA,KAAM,CAAA;AAAA,iBACtD,MAAA,kBAAA,CAAyB,MAAA,EAAQ,QAAA,CAAO,CAAA,GAAI,OAAA,EAAS,OAAA,CAAQ,CAAA;;;;;;;;;iBAqC7D,QAAA,WAAmB,MAAA,SAAe,cAAA,WAAA,CAChD,GAAA,EAAK,CAAA,iBACU,CAAA,GAAI,CAAA,CAAE,CAAA;EAAa,GAAA;AAAA,IAAmB,CAAA"}

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

@@ -2,6 +2,23 @@ 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);
@@ -10,23 +27,28 @@ function signal(initialValue, options) {
 function computed(fn, options) {
 	return new Signal.Computed(fn, options);
 }
-/**
-* Update a writable signal. Accepts either a partial object to merge into the
-* current state, or an updater function that receives the current state and
-* returns the next state.
-*
-* @example
-* update(state, { playbackRate: 2 });
-* update(state, (s) => ({ ...s, count: s.count + 1 }));
-*/
 function update(signal, updater) {
 	const current = untrack(() => signal.get());
-	signal.set(typeof updater === "function" ? updater(current) : {
+	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, signal, untrack, update };
+export { computed, peek, signal, snapshot, untrack, update };
 
 //# sourceMappingURL=primitives.js.map

package/dist/dev/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/** 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. Accepts either a partial object to merge into the\n * current state, or an updater function that receives the current state and\n * returns the next state.\n *\n * @example\n * update(state, { playbackRate: 2 });\n * update(state, (s) => ({ ...s, count: s.count + 1 }));\n */\nexport function update<T extends object>(signal: Signal<T>, updater: Partial<T> | ((current: T) => T)): void {\n  const current = untrack(() => signal.get());\n  signal.set(typeof updater === 'function' ? updater(current) : { ...current, ...updater });\n}\n"],"mappings":";;;AAGA,MAAa,UAAiCA,OAAS,OAAO;;AAgB9D,SAAgB,OAAU,cAAiB,SAAuC;AAChF,QAAO,IAAIA,OAAS,MAAM,cAAc,QAA+B;;;AAIzE,SAAgB,SAAY,IAAa,SAAyC;AAChF,QAAO,IAAIA,OAAS,SAAS,IAAI,QAA+B;;;;;;;;;;;AAYlE,SAAgB,OAAyB,QAAmB,SAAiD;CAC3G,MAAM,UAAU,cAAc,OAAO,KAAK,CAAC;AAC3C,QAAO,IAAI,OAAO,YAAY,aAAa,QAAQ,QAAQ,GAAG;EAAE,GAAG;EAAS,GAAG;EAAS,CAAC"}
+{"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;AAChH,QAAO,cAAc,UAAU,OAAO,KAAK,CAAC,CAAC;;;AAiB/C,SAAgB,OAAU,cAAiB,SAAuC;AAChF,QAAO,IAAIA,OAAS,MAAM,cAAc,QAA+B;;;AAIzE,SAAgB,SAAY,IAAa,SAAyC;AAChF,QAAO,IAAIA,OAAS,SAAS,IAAI,QAA+B;;AAkBlE,SAAgB,OAAU,QAAmB,SAA6C;CACxF,MAAM,UAAU,cAAc,OAAO,KAAK,CAAC;AAC3C,KAAI,OAAO,YAAY,WACrB,QAAO,IAAK,QAA8B,QAAQ,CAAC;KAGnD,QAAO,IAAI;EAAE,GAAI;EAAoB,GAAG;EAAS,CAAM;;;;;;;;;;AA8B3D,SAAgB,SACd,KACiE;CACjE,MAAM,MAAM,EAAE;AACd,MAAK,MAAM,OAAO,IAChB,KAAI,OAAO,IAAI,KAAM,KAAK;AAE5B,QAAO"}

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

@@ -0,0 +1,115 @@
+//#region src/core/tasks/task.d.ts
+/** Recursively marks all properties as readonly. */
+type DeepReadonly<T> = T extends (infer U)[] ? ReadonlyArray<DeepReadonly<U>> : T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]> } : T;
+type TaskStatus = 'pending' | 'running' | 'done' | 'error';
+/**
+ * Configuration for a Task.
+ */
+interface TaskConfig {
+  /**
+   * Identifier for this task.
+   * - string: used as-is
+   * - () => string: called once at construction time
+   * - undefined: a unique ID is generated via generateId()
+   */
+  id?: string | (() => string);
+  /**
+   * Optional external AbortSignal to compose with the task's internal one.
+   * The task's work is aborted when either the internal controller (via abort())
+   * or this external signal fires — whichever comes first.
+   */
+  signal?: AbortSignal;
+}
+/**
+ * Minimal contract for a schedulable unit of async work.
+ */
+interface TaskLike<TValue = void, TError = unknown> {
+  readonly id: string;
+  readonly status: TaskStatus;
+  readonly value: DeepReadonly<TValue> | undefined;
+  readonly error: DeepReadonly<TError> | undefined;
+  run(): Promise<TValue>;
+  abort(): void;
+}
+/**
+ * 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.
+ *
+ * Ordering guarantee: `value` is written before `status` transitions to `'done'`;
+ * `error` is written before `status` transitions to `'error'`. Any reader
+ * observing `status === 'done'` is guaranteed `value` is already present.
+ */
+declare class Task<TValue = void, TError = unknown> implements TaskLike<TValue, TError> {
+  #private;
+  readonly id: string;
+  constructor(runFn: (signal: AbortSignal) => Promise<TValue>, config?: TaskConfig);
+  get status(): TaskStatus;
+  get value(): DeepReadonly<TValue> | undefined;
+  get error(): DeepReadonly<TError> | undefined;
+  run(): Promise<TValue>;
+  abort(): void;
+}
+/**
+ * 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).
+ */
+declare class ConcurrentRunner {
+  #private;
+  schedule<TValue = void, TError = unknown>(task: TaskLike<TValue, TError>): Promise<TValue>;
+  /**
+   * Registers a callback to fire when all currently in-flight tasks settle.
+   * If the runner is already idle, the callback is never called. If abortAll()
+   * is called before the batch settles, the callback is superseded and silently
+   * dropped — no stale callbacks, no generation token required by the caller.
+   */
+  whenSettled(callback: () => void): void;
+  abortAll(): void;
+  destroy(): void;
+}
+/**
+ * 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.
+ */
+declare class SerialRunner {
+  #private;
+  schedule<TValue = void, TError = unknown>(task: TaskLike<TValue, TError>): Promise<TValue>;
+  /**
+   * A promise that resolves when all currently-scheduled tasks have settled.
+   * Use the reference as a generation token: capture it after scheduling a
+   * batch, then check identity in the resolution callback to detect whether
+   * a subsequent abortAll() + new batch has superseded this one.
+   */
+  get settled(): Promise<void>;
+  /**
+   * Registers a callback to fire when all currently-pending tasks settle.
+   * If the runner is already idle (no pending or running tasks), the callback
+   * is never called. If new tasks are scheduled before the current batch
+   * settles, the callback is superseded and silently dropped — no stale
+   * callbacks, no generation token required by the caller.
+   */
+  whenSettled(callback: () => void): void;
+  /** Aborts and clears queued tasks without touching the in-flight task. */
+  abortPending(): void;
+  abortAll(): void;
+  destroy(): void;
+}
+//#endregion
+export { ConcurrentRunner, SerialRunner, Task, TaskConfig, TaskLike, TaskStatus };
+//# sourceMappingURL=task.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","names":[],"sources":["../../../../src/core/tasks/task.ts"],"mappings":";;KAQY,YAAA,MAAkB,CAAA,uBAC1B,aAAA,CAAc,YAAA,CAAa,CAAA,KAC3B,CAAA,yCACyB,CAAA,GAAI,YAAA,CAAa,CAAA,CAAE,CAAA,OAC1C,CAAA;AAAA,KAMM,UAAA;;;;UAKK,UAAA;EAZY;;;;;;EAmB3B,EAAA;EAtBuB;;;;;EA6BvB,MAAA,GAAS,WAAA;AAAA;;;;UAMM,QAAA;EAAA,SACN,EAAA;EAAA,SACA,MAAA,EAAQ,UAAA;EAAA,SACR,KAAA,EAAO,YAAA,CAAa,MAAA;EAAA,SACpB,KAAA,EAAO,YAAA,CAAa,MAAA;EAC7B,GAAA,IAAO,OAAA,CAAQ,MAAA;EACf,KAAA;AAAA;;;AA1BF;;;;;;;;;AAoBA;cAqBa,IAAA,6CAAiD,QAAA,CAAS,MAAA,EAAQ,MAAA;EAAA;WACpE,EAAA;EAST,WAAA,CAAY,KAAA,GAAQ,MAAA,EAAQ,WAAA,KAAgB,OAAA,CAAQ,MAAA,GAAS,MAAA,GAAS,UAAA;EAAA,IASlE,MAAA,CAAA,GAAU,UAAA;EAAA,IAIV,KAAA,CAAA,GAAS,YAAA,CAAa,MAAA;EAAA,IAItB,KAAA,CAAA,GAAS,YAAA,CAAa,MAAA;EAIpB,GAAA,CAAA,GAAO,OAAA,CAAQ,MAAA;EAcrB,KAAA,CAAA;AAAA;;;;;;;;cAgBW,gBAAA;EAAA;EAMX,QAAA,iCAAA,CAA0C,IAAA,EAAM,QAAA,CAAS,MAAA,EAAQ,MAAA,IAAU,OAAA,CAAQ,MAAA;EApFnE;;;;;;EAsHhB,WAAA,CAAY,QAAA;EAYZ,QAAA,CAAA;EAWA,OAAA,CAAA;AAAA;;;;;;;;;;;;;;;cAwBW,YAAA;EAAA;EAMX,QAAA,iCAAA,CAA0C,IAAA,EAAM,QAAA,CAAS,MAAA,EAAQ,MAAA,IAAU,OAAA,CAAQ,MAAA;EA1JnE;;;;;;EAAA,IAwLZ,OAAA,CAAA,GAAW,OAAA;EA9Kf;;;;;;;EAyLA,WAAA,CAAY,QAAA;EAhLR;EA6LJ,YAAA,CAAA;EAKA,QAAA,CAAA;EAKA,OAAA,CAAA;AAAA"}

package/dist/dev/core/{task.js → tasks/task.js}

@@ -1,6 +1,6 @@
-import { generateId } from "./utils/generate-id.js";
 import { anyAbortSignal } from "@videojs/utils/events";
-//#region src/core/task.ts
+import { generateId } from "@videojs/utils/string";
+//#region src/core/tasks/task.ts
 /**
 * Generic reusable task that wraps an async run function.
 *

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

@@ -0,0 +1 @@
+{"version":3,"file":"task.js","names":["#runFn","#abortController","#signal","#status","#value","#error","#pending","#destroyed","#settled","#resolveSettled","#chain","#current"],"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  run(): Promise<TValue>;\n  abort(): void;\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 * 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 #abortController = new AbortController();\n  readonly #signal: AbortSignal;\n\n  #status: TaskStatus = 'pending';\n  #value: TValue | undefined = undefined;\n  #error: TError | 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.#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  async run(): 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// =============================================================================\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"],"mappings":";;;;;;;;;;;;;;;AAgEA,IAAa,OAAb,MAAuF;CACrF;CACA;CACA,mBAA4B,IAAI,iBAAiB;CACjD;CAEA,UAAsB;CACtB,SAA6B,KAAA;CAC7B,SAA6B,KAAA;CAE7B,YAAY,OAAiD,QAAqB;AAChF,QAAA,QAAc;EACd,MAAM,QAAQ,QAAQ;AACtB,OAAK,KAAK,OAAO,UAAU,aAAa,OAAO,GAAI,SAAS,YAAY;AACxE,QAAA,SAAe,QAAQ,SACnB,eAAe,CAAC,MAAA,gBAAsB,QAAQ,OAAO,OAAO,CAAC,GAC7D,MAAA,gBAAsB;;CAG5B,IAAI,SAAqB;AACvB,SAAO,MAAA;;CAGT,IAAI,QAA0C;AAC5C,SAAO,MAAA;;CAGT,IAAI,QAA0C;AAC5C,SAAO,MAAA;;CAGT,MAAM,MAAuB;AAC3B,QAAA,SAAe;AACf,MAAI;GACF,MAAM,SAAS,MAAM,MAAA,MAAY,MAAA,OAAa;AAC9C,SAAA,QAAc;AACd,SAAA,SAAe;AACf,UAAO;WACA,GAAG;AACV,SAAA,QAAc;AACd,SAAA,SAAe;AACf,SAAM;;;CAIV,QAAc;AACZ,QAAA,gBAAsB,OAAO;;;;;;;;;;AAejC,IAAa,mBAAb,MAA8B;CAC5B,2BAAoB,IAAI,KAA8E;CACtG,WAA0B,QAAQ,SAAS;CAC3C,kBAAuC;CACvC,aAAa;CAEb,SAA0C,MAAiD;AACzF,MAAI,MAAA,UAAiB,QAAO,QAAQ,SAAS;EAC7C,MAAM,WAAW,MAAA,QAAc,IAAI,KAAK,GAAG;AAC3C,MAAI,SAAU,QAAO,SAAS;AAE9B,MAAI,MAAA,QAAc,SAAS,EACzB,OAAA,UAAgB,IAAI,SAAS,YAAY;AACvC,SAAA,iBAAuB;IACvB;EAGJ,MAAM,UAAU,KAAK,KAAK;AAE1B,UAAQ,YAAY,GAAG;EAEvB,MAAM,gBAAgB;AACpB,SAAA,QAAc,OAAO,KAAK,GAAG;AAC7B,OAAI,MAAA,QAAc,SAAS,GAAG;AAC5B,UAAA,kBAAwB;AACxB,UAAA,iBAAuB;;;AAG3B,UAAQ,KAAK,SAAS,QAAQ;AAE9B,QAAA,QAAc,IAAI,KAAK,IAAI;GAAQ;GAA6C;GAA6B,CAAC;AAC9G,SAAO;;;;;;;;CAST,YAAY,UAA4B;AACtC,MAAI,MAAA,QAAc,SAAS,EAAG;EAC9B,MAAM,WAAW,MAAA;AACjB,WAAS,WACD;AACJ,OAAI,MAAA,YAAkB,SAAU;AAChC,aAAU;WAEN,GACP;;CAGH,WAAiB;AACf,OAAK,MAAM,EAAE,UAAU,MAAA,QAAc,QAAQ,CAAE,MAAK,OAAO;AAC3D,QAAA,QAAc,OAAO;AAIrB,QAAA,kBAAwB;AACxB,QAAA,iBAAuB;AACvB,QAAA,UAAgB,QAAQ,SAAS;;CAGnC,UAAgB;AACd,QAAA,YAAkB;AAClB,OAAK,UAAU;;;;;;;;;;;;;;;;;AAsBnB,IAAa,eAAb,MAA0B;CACxB,SAA2B,QAAQ,SAAS;CAC5C,2BAAoB,IAAI,KAAiC;CACzD,WAA8C;CAC9C,aAAa;CAEb,SAA0C,MAAiD;AACzF,MAAI,MAAA,UAAiB,QAAO,QAAQ,SAAS;EAC7C,MAAM,IAAI;AACV,QAAA,QAAc,IAAI,EAAE;EAEpB,MAAM,SAAS,MAAA,MACZ,WAAW;AACV,SAAA,QAAc,OAAO,EAAE;AACvB,SAAA,UAAgB;AAChB,UAAO,KAAK,KAAK;IACjB,CACD,cAAc;AACb,SAAA,UAAgB;IAChB;AAGJ,QAAA,QAAc,OAAO,WACb,UACA,GACP;AAED,SAAO;;;;;;;;CAST,IAAI,UAAyB;AAC3B,SAAO,MAAA;;;;;;;;;CAUT,YAAY,UAA4B;AACtC,MAAI,MAAA,QAAc,SAAS,KAAK,MAAA,YAAkB,KAAM;EACxD,MAAM,eAAe,MAAA;AACrB,eAAa,WACL;AACJ,OAAI,MAAA,UAAgB,aAAc;AAClC,aAAU;WAEN,GACP;;;CAIH,eAAqB;AACnB,OAAK,MAAM,QAAQ,MAAA,QAAe,MAAK,OAAO;AAC9C,QAAA,QAAc,OAAO;;CAGvB,WAAiB;AACf,OAAK,cAAc;AACnB,QAAA,SAAe,OAAO;;CAGxB,UAAgB;AACd,QAAA,YAAkB;AAClB,OAAK,UAAU"}

package/dist/dev/dom.d.ts

@@ -1,10 +1,9 @@
-import { appendSegment } from "./dom/media/append-segment.js";
-import { loadSegments } from "./dom/features/load-segments.js";
-import { loadTextTrackCues } from "./dom/features/load-text-track-cues.js";
-import { CurrentTimeOwners, CurrentTimeState, trackCurrentTime } from "./dom/features/track-current-time.js";
-import { PlaybackInitiatedOwners, PlaybackInitiatedState, trackPlaybackInitiated } from "./dom/features/track-playback-initiated.js";
-import { PlaybackRateOwners, PlaybackRateState, trackPlaybackRate } from "./dom/features/track-playback-rate.js";
-import { flushBuffer } from "./dom/media/buffer-flusher.js";
-import { SpfMedia, SpfMediaAPI, SpfMediaMixin } from "./dom/playback-engine/adapter.js";
-import { destroyVttParser, parseVttSegment } from "./dom/text/parse-vtt-segment.js";
-export { type CurrentTimeOwners, type CurrentTimeState, type PlaybackInitiatedOwners, type PlaybackInitiatedState, type PlaybackRateOwners, type PlaybackRateState, SpfMedia, type SpfMediaAPI, SpfMediaMixin, appendSegment, destroyVttParser, flushBuffer, loadSegments, loadTextTrackCues, parseVttSegment, trackCurrentTime, trackPlaybackInitiated, trackPlaybackRate };
+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 { CurrentTimeContext, CurrentTimeState, trackCurrentTime } from "./playback/behaviors/dom/track-current-time.js";
+import { LoadTriggersContext, LoadTriggersState, trackLoadTriggers } from "./playback/behaviors/dom/track-load-triggers.js";
+import { PlaybackRateContext, PlaybackRateState, trackPlaybackRate } from "./playback/behaviors/dom/track-playback-rate.js";
+export { type CurrentTimeContext, type CurrentTimeState, type LoadTriggersContext, type LoadTriggersState, type PlaybackRateContext, type PlaybackRateState, appendSegment, destroyVttResolver, flushBuffer, loadAudioSegments, loadVideoSegments, resolveVttSegment, setupTextTrackActors, trackCurrentTime, trackLoadTriggers, trackPlaybackRate };

package/dist/dev/dom.js

@@ -1,10 +1,9 @@
-import { loadSegments } from "./dom/features/load-segments.js";
-import { destroyVttParser, parseVttSegment } from "./dom/text/parse-vtt-segment.js";
-import { loadTextTrackCues } from "./dom/features/load-text-track-cues.js";
-import { trackCurrentTime } from "./dom/features/track-current-time.js";
-import { trackPlaybackInitiated } from "./dom/features/track-playback-initiated.js";
-import { trackPlaybackRate } from "./dom/features/track-playback-rate.js";
-import { appendSegment } from "./dom/media/append-segment.js";
-import { flushBuffer } from "./dom/media/buffer-flusher.js";
-import { SpfMedia, SpfMediaMixin } from "./dom/playback-engine/adapter.js";
-export { SpfMedia, SpfMediaMixin, appendSegment, destroyVttParser, flushBuffer, loadSegments, loadTextTrackCues, parseVttSegment, trackCurrentTime, trackPlaybackInitiated, trackPlaybackRate };
+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/dev/hls.d.ts

@@ -0,0 +1,3 @@
+import { SimpleHlsEngineConfig, SimpleHlsEngineContext, SimpleHlsEngineSignals, SimpleHlsEngineState, createSimpleHlsEngine } from "./playback/engines/hls/engine.js";
+import { SimpleHlsMediaAPI, SimpleHlsMediaElement, SimpleHlsMediaMixin, SimpleHlsMediaProps, simpleHlsMediaDefaultProps } from "./playback/engines/hls/adapter.js";
+export { type SimpleHlsEngineConfig, type SimpleHlsEngineContext, type SimpleHlsEngineSignals, type SimpleHlsEngineState, type SimpleHlsMediaAPI, SimpleHlsMediaElement, SimpleHlsMediaMixin, type SimpleHlsMediaProps, createSimpleHlsEngine, simpleHlsMediaDefaultProps };

package/dist/dev/hls.js

@@ -0,0 +1,3 @@
+import { createSimpleHlsEngine } from "./playback/engines/hls/engine.js";
+import { SimpleHlsMediaElement, SimpleHlsMediaMixin, simpleHlsMediaDefaultProps } from "./playback/engines/hls/adapter.js";
+export { SimpleHlsMediaElement, SimpleHlsMediaMixin, createSimpleHlsEngine, simpleHlsMediaDefaultProps };

package/dist/dev/index.d.ts

@@ -1,13 +1,25 @@
+import { Computed, ReadonlySignal, Signal, SignalOptions, computed, signal, snapshot, untrack, update } from "./core/signals/primitives.js";
+import { Behavior, BehaviorCleanup, BehaviorDeps, Composition, CompositionOptions, ContextSignals, InferBehaviorConfig, InferBehaviorContext, InferBehaviorState, ResolveBehaviorConfig, ResolveBehaviorContext, ResolveBehaviorState, StateSignals, createComposition, defineBehavior } from "./core/composition/create-composition.js";
+import { ShareSignalsConfig, makeShareSignals } from "./core/composition/share-signals.js";
+import { effect } from "./core/signals/effect.js";
+import { ConcurrentRunner, SerialRunner, Task, TaskConfig, TaskLike, TaskStatus } from "./core/tasks/task.js";
+import { ActorSnapshot, CallbackActor, SignalActor } from "./core/actors/actor.js";
+import { ActorDefinition, ActorStateDefinition, HandlerContext, MessageActor, RunnerLike, createMachineActor } from "./core/actors/create-machine-actor.js";
+import { TransitionActor, createTransitionActor } from "./core/actors/create-transition-actor.js";
+import { Machine, MachineSnapshot } from "./core/machine.js";
+import { Reactor, ReactorDefinition, ReactorDeriveFn, ReactorEffectFn, ReactorStateDefinition, createMachineReactor } from "./core/reactors/create-machine-reactor.js";
+
 //#region src/index.d.ts
 /**
  * Stream Processing Framework (SPF) for Video.js 10
  *
- * Bundle size target: < 20KB (minified + gzipped)
- * Primary use case: CMAF HLS playback with Video.js v10
+ * The compositional primitives: createComposition, signals, tasks, actors,
+ * reactors. Media-domain helpers and the HLS playback engine live behind
+ * the `./dom` and `./hls` subpaths.
  *
  * @packageDocumentation
  */
 declare const VERSION = "0.1.0";
 //#endregion
-export { VERSION };
+export { type ActorDefinition, type ActorSnapshot, type ActorStateDefinition, type Behavior, type BehaviorCleanup, type BehaviorDeps, type CallbackActor, type Composition, type CompositionOptions, type Computed, ConcurrentRunner, type ContextSignals, type HandlerContext, type InferBehaviorConfig, type InferBehaviorContext, type InferBehaviorState, type Machine, type MachineSnapshot, type MessageActor, type Reactor, type ReactorDefinition, type ReactorDeriveFn, type ReactorEffectFn, type ReactorStateDefinition, type ReadonlySignal, type ResolveBehaviorConfig, type ResolveBehaviorContext, type ResolveBehaviorState, type RunnerLike, SerialRunner, type ShareSignalsConfig, type Signal, type SignalActor, type SignalOptions, type StateSignals, Task, type TaskConfig, type TaskLike, type TaskStatus, type TransitionActor, VERSION, computed, createComposition, createMachineActor, createMachineReactor, createTransitionActor, defineBehavior, effect, makeShareSignals, signal, snapshot, untrack, update };
 //# sourceMappingURL=index.d.ts.map

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

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

package/dist/dev/index.js

@@ -1,14 +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
 *
-* Bundle size target: < 20KB (minified + gzipped)
-* Primary use case: CMAF HLS playback with Video.js v10
+* 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 { VERSION };
+export { ConcurrentRunner, SerialRunner, Task, VERSION, computed, createComposition, createMachineActor, createMachineReactor, createTransitionActor, defineBehavior, effect, makeShareSignals, signal, snapshot, untrack, update };
 
 //# sourceMappingURL=index.js.map

package/dist/dev/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 * Bundle size target: < 20KB (minified + gzipped)\n * Primary use case: CMAF HLS playback with Video.js v10\n *\n * @packageDocumentation\n */\n\n// Public API exports will be added here as features are implemented\n\nexport const VERSION = '0.1.0';\n"],"mappings":";;;;;;;;;AAWA,MAAa,UAAU"}
+{"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/dev/media/abr/quality-selection.d.ts

@@ -0,0 +1,22 @@
+//#region src/media/abr/quality-selection.d.ts
+/**
+ * Quality selection configuration.
+ */
+interface QualityConfig {
+  /**
+   * Safety margin (0-1).
+   * To select a track, need: currentBandwidth >= track.bandwidth / safetyMargin.
+   * Default 0.85 means track must use ≤85% of available bandwidth (15% headroom).
+   */
+  safetyMargin: number;
+  /**
+   * Upgrade hysteresis ratio (>= 1). When `currentTrack` is supplied, an
+   * upgrade is applied only if `optimal.bandwidth >= currentTrack.bandwidth * upgradeMargin`.
+   * Downgrades are always applied. Default 1.15 means optimal must clear
+   * the current bandwidth by at least 15% to trigger an upgrade.
+   */
+  upgradeMargin: number;
+}
+//#endregion
+export { QualityConfig };
+//# sourceMappingURL=quality-selection.d.ts.map

package/dist/dev/media/abr/quality-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality-selection.d.ts","names":[],"sources":["../../../../src/media/abr/quality-selection.ts"],"mappings":";;;;UAiBiB,aAAA;;;;;;EAMf,YAAA;;;;;;;EAOA,aAAA;AAAA"}

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

@@ -0,0 +1,83 @@
+//#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
+};
+/**
+* Select the track to apply now, given current bandwidth, a current
+* selection (optional), and tuning. Returns:
+*
+* - The bandwidth-fitting optimal when no `currentTrack` is supplied.
+* - The optimal when it's a downgrade vs. `currentTrack` (downgrades
+*   apply immediately — no hysteresis).
+* - The optimal when it clears `currentTrack.bandwidth * upgradeMargin`
+*   (upgrade clears hysteresis).
+* - `currentTrack` itself when an upgrade doesn't clear the margin
+*   (stay put — caller checks identity to no-op).
+*
+* "Optimal" is the highest-bandwidth track where the available bandwidth
+* meets the safety requirement (`currentBandwidth >= track.bandwidth / safetyMargin`).
+* Falls back to the lowest-bandwidth track when nothing fits the safety
+* margin (preserves a definitive pick under under-bandwidth conditions).
+*
+* @example
+* const tracks = [low, mid, high];
+* selectQuality(tracks, 5_000_000, { currentTrack: low });
+* // Returns `high` if 5 Mbps clears safety AND high.bandwidth >= low.bandwidth * upgradeMargin.
+* // Returns `low` (no-op signal) otherwise.
+*/
+function selectQuality(tracks, currentBandwidth, opts = {}) {
+	if (tracks.length === 0) return;
+	const safetyMargin = opts.safetyMargin ?? DEFAULT_QUALITY_CONFIG.safetyMargin;
+	const upgradeMargin = opts.upgradeMargin ?? DEFAULT_QUALITY_CONFIG.upgradeMargin;
+	const { currentTrack } = opts;
+	const sortedTracks = tracks.slice().sort((a, b) => a.bandwidth - b.bandwidth);
+	let chosen;
+	for (const track of sortedTracks) if (currentBandwidth >= track.bandwidth / safetyMargin) {
+		if (!chosen || track.bandwidth > chosen.bandwidth || track.bandwidth === chosen.bandwidth && hasHigherResolution(track, chosen)) chosen = track;
+	}
+	const optimal = chosen ?? sortedTracks[0];
+	if (!optimal) return void 0;
+	if (!currentTrack) return optimal;
+	if (optimal.bandwidth < currentTrack.bandwidth) return optimal;
+	if (optimal.bandwidth >= currentTrack.bandwidth * upgradeMargin) return optimal;
+	return currentTrack;
+}
+/**
+* Select the lowest-bandwidth track from the candidate set.
+*
+* Used as a safety-net fallback by callers that need a definitive pick when
+* a primary selection algorithm declines to choose. Pairs naturally with
+* `selectQuality` — when ABR has no good answer (e.g., all candidates
+* exceed available bandwidth and the algorithm doesn't fall back
+* internally), the lowest bitrate is the safest default.
+*
+* @param tracks - Candidate tracks (can be unsorted)
+* @returns The lowest-bandwidth track, or `undefined` if `tracks` is empty
+*
+* @example
+* const fallback = selectLowestQuality(tracks);
+*/
+function selectLowestQuality(tracks) {
+	if (tracks.length === 0) return void 0;
+	return tracks.reduce((min, t) => t.bandwidth < min.bandwidth ? t : min);
+}
+/**
+* Check if track A has higher resolution than track B.
+* Compares by total pixel count (width × height).
+*
+* @param trackA - First track to compare
+* @param trackB - Second track to compare
+* @returns True if trackA has more pixels than trackB
+*/
+function hasHigherResolution(trackA, trackB) {
+	return (trackA.width ?? 0) * (trackA.height ?? 0) > (trackB.width ?? 0) * (trackB.height ?? 0);
+}
+//#endregion
+export { DEFAULT_QUALITY_CONFIG, selectLowestQuality, selectQuality };
+
+//# sourceMappingURL=quality-selection.js.map

package/dist/dev/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 * Options for `selectQuality`. Spread of `Partial<QualityConfig>` plus a\n * runtime-supplied `currentTrack` for upgrade-vs-downgrade decisions.\n */\nexport interface SelectQualityOpts extends Partial<QualityConfig> {\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?: PartiallyResolvedVideoTrack | VideoTrack;\n}\n\n/**\n * Select the track to apply now, given current bandwidth, a current\n * selection (optional), and tuning. 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 (`currentBandwidth >= 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, 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  currentBandwidth: number,\n  opts: SelectQualityOpts = {}\n): PartiallyResolvedVideoTrack | VideoTrack | undefined {\n  if (tracks.length === 0) {\n    return undefined;\n  }\n\n  const safetyMargin = opts.safetyMargin ?? DEFAULT_QUALITY_CONFIG.safetyMargin;\n  const upgradeMargin = opts.upgradeMargin ?? DEFAULT_QUALITY_CONFIG.upgradeMargin;\n  const { currentTrack } = opts;\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 * 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  const pixelsA = (trackA.width ?? 0) * (trackA.height ?? 0);\n  const pixelsB = (trackB.width ?? 0) * (trackB.height ?? 0);\n  return pixelsA > pixelsB;\n}\n"],"mappings":";;;;;AAqCA,MAAa,yBAAwC;CACnD,cAAc;CACd,eAAe;CAChB;;;;;;;;;;;;;;;;;;;;;;;;AAuCD,SAAgB,cACd,QACA,kBACA,OAA0B,EAAE,EAC0B;AACtD,KAAI,OAAO,WAAW,EACpB;CAGF,MAAM,eAAe,KAAK,gBAAgB,uBAAuB;CACjE,MAAM,gBAAgB,KAAK,iBAAiB,uBAAuB;CACnE,MAAM,EAAE,iBAAiB;CAGzB,MAAM,eAAe,OAAO,OAAO,CAAC,MAAM,GAAG,MAAM,EAAE,YAAY,EAAE,UAAU;CAG7E,IAAI;AAEJ,MAAK,MAAM,SAAS,aAKlB,KAAI,oBAFsB,MAAM,YAAY;MAKxC,CAAC,UACD,MAAM,YAAY,OAAO,aACxB,MAAM,cAAc,OAAO,aAAa,oBAAoB,OAAO,OAAO,CAE3E,UAAS;;CAMf,MAAM,UAAU,UAAU,aAAa;AACvC,KAAI,CAAC,QAAS,QAAO,KAAA;AAMrB,KAAI,CAAC,aAAc,QAAO;AAC1B,KAAI,QAAQ,YAAY,aAAa,UAAW,QAAO;AACvD,KAAI,QAAQ,aAAa,aAAa,YAAY,cAAe,QAAO;AACxE,QAAO;;;;;;;;;;;;;;;;;AAkBT,SAAgB,oBAAqD,QAAqC;AACxG,KAAI,OAAO,WAAW,EAAG,QAAO,KAAA;AAChC,QAAO,OAAO,QAAQ,KAAK,MAAO,EAAE,YAAY,IAAI,YAAY,IAAI,IAAK;;;;;;;;;;AAW3E,SAAS,oBACP,QACA,QACS;AAGT,SAFiB,OAAO,SAAS,MAAM,OAAO,UAAU,MACvC,OAAO,SAAS,MAAM,OAAO,UAAU"}

package/dist/dev/media/buffer/back-buffer.d.ts

@@ -0,0 +1,14 @@
+//#region src/media/buffer/back-buffer.d.ts
+/**
+ * Back buffer configuration.
+ */
+interface BackBufferConfig {
+  /**
+   * Number of segments to keep behind current playback position.
+   * Default: 2 segments.
+   */
+  keepSegments: number;
+}
+//#endregion
+export { BackBufferConfig };
+//# sourceMappingURL=back-buffer.d.ts.map

package/dist/dev/media/buffer/back-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"back-buffer.d.ts","names":[],"sources":["../../../../src/media/buffer/back-buffer.ts"],"mappings":";;;;UAYiB,gBAAA;;;;;EAKf,YAAA;AAAA"}