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

package/dist/dev/core/reactors/create-machine-reactor.d.ts

@@ -0,0 +1,93 @@
+import { Machine, MachineSnapshot } from "../machine.js";
+//#region src/core/reactors/create-machine-reactor.d.ts
+/**
+ * A reactive state-deriving function used in the `monitor` field.
+ *
+ * Returns the target state the reactor should be in. Any signals read inside
+ * the fn body create reactive dependencies — the framework re-evaluates it when
+ * those signals change and automatically calls `transition()` when the returned
+ * state differs from the current one.
+ */
+type ReactorDeriveFn<State extends string> = () => State;
+/**
+ * An effect function used in reactor `entry` and `effects` blocks.
+ *
+ * May return a cleanup function that runs before each re-evaluation and on
+ * state exit (including destroy).
+ */
+type ReactorEffectFn = () => (() => void) | {
+  abort(): void;
+} | void;
+/**
+ * Per-state effect grouping for a single reactor state.
+ *
+ * - `entry` effects run once on state entry. The fn body is automatically
+ *   untracked — no `untrack()` calls are needed inside. Use this for
+ *   one-time setup: reading current values, attaching event listeners, etc.
+ * - `effects` run on state entry and re-run whenever a signal read inside
+ *   the fn body changes. Use `untrack()` for reads you do not want to track.
+ *   Use this for work that must stay in sync with reactive state.
+ *
+ * Both are optional; pass `{}` for states with no effects.
+ */
+type ReactorStateDefinition = {
+  entry?: ReactorEffectFn | ReactorEffectFn[];
+  effects?: ReactorEffectFn | ReactorEffectFn[];
+};
+/**
+ * Full reactor definition passed to `createMachineReactor`.
+ *
+ * `State` is the set of domain-meaningful states. `'destroying'` and
+ * `'destroyed'` are always added by the framework as implicit terminal states —
+ * do not include them here.
+ */
+type ReactorDefinition<State extends string> = {
+  /** Initial state. */
+  initial: State;
+  /**
+   * Reactive state derivation. Registered before per-state effects — the
+   * ordering guarantee ensures transitions fired here take effect before
+   * per-state effects re-evaluate in the same flush.
+   */
+  monitor?: ReactorDeriveFn<State> | ReactorDeriveFn<State>[];
+  /**
+   * Per-state effect groupings. Every valid state must be declared — pass `{}`
+   * for states with no effects. `entry` and `effects` each become independent
+   * `effect()` calls gated on that state, with their own cleanup lifecycles.
+   */
+  states: Record<State, ReactorStateDefinition>;
+};
+/** Live reactor instance returned by `createMachineReactor`. */
+type Reactor<State extends string> = Machine<MachineSnapshot<State>>;
+/**
+ * Creates a reactive Reactor from a declarative definition.
+ *
+ * A Reactor is driven by subscriptions to external signals rather than
+ * imperative messages. Each state holds an array of effect functions —
+ * every element becomes one independent `effect()` call gated on that state,
+ * with its own dependency tracking and cleanup lifecycle.
+ *
+ * `'destroying'` and `'destroyed'` are always implicit terminal states.
+ * `destroy()` transitions through both in sequence: `'destroying'` first (for
+ * potential async teardown in a future extension), then immediately `'destroyed'`
+ * for the synchronous base case. Active effect cleanups fire via disposal.
+ *
+ * @example
+ * const reactor = createMachineReactor({
+ *   initial: 'waiting',
+ *   monitor: () => srcSignal.get() ? 'active' : 'waiting',
+ *   states: {
+ *     active: {
+ *       // entry: runs once on state entry; fn body is automatically untracked.
+ *       entry: () => listen(el, 'play', handler),
+ *       // effects: re-runs whenever tracked signals change.
+ *       effects: () => { currentTimeSignal.get(); return cleanup; },
+ *     },
+ *     waiting: {},
+ *   }
+ * });
+ */
+declare function createMachineReactor<State extends string>(def: ReactorDefinition<State>): Reactor<State | 'destroying' | 'destroyed'>;
+//#endregion
+export { Reactor, ReactorDefinition, ReactorDeriveFn, ReactorEffectFn, ReactorStateDefinition, createMachineReactor };
+//# sourceMappingURL=create-machine-reactor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-machine-reactor.d.ts","names":[],"sources":["../../../../src/core/reactors/create-machine-reactor.ts"],"mappings":";;;;;;;;;;KAiBY,gBAAgB,8BAA8B;;;;;;;KAQ9C;EAAyC;;;;;;;;;;;;;;KAczC;EACV,QAAQ,kBAAkB;EAC1B,UAAU,kBAAkB;;;;;;;;;KAUlB,kBAAkB;;EAE5B,SAAS;;;;;;EAMT,UAAU,gBAAgB,SAAS,gBAAgB;;;;;;EAMnD,QAAQ,OAAO,OAAO;;;KAQZ,QAAQ,wBAAwB,QAAQ,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwCpD,qBAAqB,sBACnC,KAAK,kBAAkB,SACtB,QAAQ"}

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

@@ -0,0 +1,83 @@
+import { untrack } from "../signals/primitives.js";
+import { effect } from "../signals/effect.js";
+import { createMachineCore } from "../machine.js";
+//#region src/core/reactors/create-machine-reactor.ts
+const toArray = (x) => x === void 0 ? [] : Array.isArray(x) ? x : [x];
+/**
+* Creates a reactive Reactor from a declarative definition.
+*
+* A Reactor is driven by subscriptions to external signals rather than
+* imperative messages. Each state holds an array of effect functions —
+* every element becomes one independent `effect()` call gated on that state,
+* with its own dependency tracking and cleanup lifecycle.
+*
+* `'destroying'` and `'destroyed'` are always implicit terminal states.
+* `destroy()` transitions through both in sequence: `'destroying'` first (for
+* potential async teardown in a future extension), then immediately `'destroyed'`
+* for the synchronous base case. Active effect cleanups fire via disposal.
+*
+* @example
+* const reactor = createMachineReactor({
+*   initial: 'waiting',
+*   monitor: () => srcSignal.get() ? 'active' : 'waiting',
+*   states: {
+*     active: {
+*       // entry: runs once on state entry; fn body is automatically untracked.
+*       entry: () => listen(el, 'play', handler),
+*       // effects: re-runs whenever tracked signals change.
+*       effects: () => { currentTimeSignal.get(); return cleanup; },
+*     },
+*     waiting: {},
+*   }
+* });
+*/
+function createMachineReactor(def) {
+	const { snapshotSignal, getState, transition } = createMachineCore({ value: def.initial });
+	const effectDisposals = [];
+	const wrapResult = (result) => {
+		if (!result) return void 0;
+		if (typeof result === "function") return result;
+		return () => result.abort();
+	};
+	const untracked = (baseCall) => () => untrack(baseCall);
+	const isTerminal = (snapshot) => snapshot.value === "destroying" || snapshot.value === "destroyed";
+	const descriptors = [...toArray(def.monitor).map((fn) => ({
+		fn: () => {
+			const target = fn();
+			if (target !== getState()) transition(target);
+		},
+		shouldSkip: isTerminal
+	})), ...Object.entries(def.states).flatMap(([state, stateDef]) => {
+		const isNotState = (snapshot) => snapshot.value !== state;
+		return [...toArray(stateDef.entry).map((fn) => ({
+			fn,
+			shouldSkip: isNotState,
+			toFnCall: untracked
+		})), ...toArray(stateDef.effects).map((fn) => ({
+			fn,
+			shouldSkip: isNotState
+		}))];
+	})];
+	const toEffect = ({ fn, shouldSkip, toFnCall = (baseCall) => baseCall }) => effect(() => {
+		if (shouldSkip(snapshotSignal.get())) return;
+		const baseCall = () => fn();
+		return wrapResult(toFnCall(baseCall)());
+	});
+	effectDisposals.push(...descriptors.map(toEffect));
+	return {
+		get snapshot() {
+			return snapshotSignal;
+		},
+		destroy() {
+			const state = getState();
+			if (state === "destroying" || state === "destroyed") return;
+			transition("destroying");
+			transition("destroyed");
+			for (const dispose of effectDisposals) dispose();
+		}
+	};
+}
+//#endregion
+export { createMachineReactor };
+
+//# sourceMappingURL=create-machine-reactor.js.map

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,CAAC,IAAI,MAAM,QAAQ,CAAC,IAAI,IAAI,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCrG,SAAgB,qBACd,KAC6C;CAG7C,MAAM,EAAE,gBAAgB,UAAU,eAAe,kBAAyD,EACxG,OAAO,IAAI,QACb,CAAC;CAED,MAAM,kBAAqC,CAAC;CAE5C,MAAM,cAAc,WAAwC;EAC1D,IAAI,CAAC,QAAQ,OAAO,KAAA;EACpB,IAAI,OAAO,WAAW,YAAY,OAAO;EACzC,aAAa,OAAO,MAAM;CAC5B;CAUA,MAAM,aAA2C,mBAAmB,QAAQ,QAAQ;CAEpF,MAAM,cAAc,aAClB,SAAS,UAAU,gBAAgB,SAAS,UAAU;CAMxD,MAAM,cAAkC,CACtC,GAAG,QAAQ,IAAI,OAAO,CAAC,CAAC,KAAK,QAAQ;EACnC,UAAU;GACR,MAAM,SAAS,GAAG;GAClB,IAAI,WAAY,SAAS,GAAa,WAAW,MAAmB;EACtE;EACA,YAAY;CACd,EAAE,GACF,GAAI,OAAO,QAAQ,IAAI,MAAM,CAAC,CAA4C,SAAS,CAAC,OAAO,cAAc;EACvG,MAAM,cAAc,aAAmC,SAAS,UAAU;EAC1E,OAAO,CACL,GAAG,QAAQ,SAAS,KAAK,CAAC,CAAC,KAAK,QAAQ;GAAE;GAAI,YAAY;GAAY,UAAU;EAAU,EAAE,GAC5F,GAAG,QAAQ,SAAS,OAAO,CAAC,CAAC,KAAK,QAAQ;GAAE;GAAI,YAAY;EAAW,EAAE,CAC3E;CACF,CAAC,CACH;CAEA,MAAM,YAAY,EAAE,IAAI,YAAY,YAAY,aAAa,eAC3D,aAAa;EAEX,IAAI,WADa,eAAe,IACV,CAAC,GAAG;EAC1B,MAAM,iBAAiB,GAAG;EAC1B,OAAO,WAAW,SAAS,QAAQ,CAAC,CAAC,CAAC;CACxC,CAAC;CAEH,gBAAgB,KAAK,GAAG,YAAY,IAAI,QAAQ,CAAC;CAEjD,OAAO;EACL,IAAI,WAAW;GACb,OAAO;EACT;EAEA,UAAgB;GACd,MAAM,QAAQ,SAAS;GACvB,IAAI,UAAU,gBAAgB,UAAU,aAAa;GAIrD,WAAW,YAAY;GACvB,WAAW,WAAW;GACtB,KAAK,MAAM,WAAW,iBAAiB,QAAQ;EACjD;CACF;AACF"}

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

@@ -0,0 +1,15 @@
+//#region src/core/signals/effect.d.ts
+/**
+ * Run a side effect whenever its signal dependencies change.
+ *
+ * Executes immediately (synchronous initial run), then re-runs on the next
+ * microtask after any dependency changes. If the callback returns a function,
+ * it is called before each re-run and when the effect is stopped — the same
+ * cleanup contract as Preact Signals, Maverick Signals, and Svelte 5 $effect.
+ *
+ * Returns a cleanup function that stops the effect.
+ */
+declare function effect(fn: () => (() => void) | void): () => void;
+//#endregion
+export { effect };
+//# sourceMappingURL=effect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.ts","names":[],"sources":["../../../../src/core/signals/effect.ts"],"mappings":";;;;;;;;;;;iBA8BgB,OAAO"}

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

@@ -0,0 +1,41 @@
+import { Signal } from "signal-polyfill";
+//#region src/core/signals/effect.ts
+const pending = /* @__PURE__ */ new Set();
+const watcher = new Signal.subtle.Watcher(() => {
+	queueMicrotask(runPending);
+});
+function runPending() {
+	for (const c of watcher.getPending()) pending.add(c);
+	watcher.watch();
+	for (const c of pending) {
+		pending.delete(c);
+		c.get();
+	}
+}
+/**
+* Run a side effect whenever its signal dependencies change.
+*
+* Executes immediately (synchronous initial run), then re-runs on the next
+* microtask after any dependency changes. If the callback returns a function,
+* it is called before each re-run and when the effect is stopped — the same
+* cleanup contract as Preact Signals, Maverick Signals, and Svelte 5 $effect.
+*
+* Returns a cleanup function that stops the effect.
+*/
+function effect(fn) {
+	let cleanup;
+	const c = new Signal.Computed(() => {
+		if (typeof cleanup === "function") cleanup();
+		cleanup = fn();
+	});
+	watcher.watch(c);
+	c.get();
+	return () => {
+		watcher.unwatch(c);
+		if (typeof cleanup === "function") cleanup();
+	};
+}
+//#endregion
+export { effect };
+
+//# sourceMappingURL=effect.js.map

package/dist/dev/core/signals/effect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.js","names":[],"sources":["../../../../src/core/signals/effect.ts"],"sourcesContent":["import { Signal } from 'signal-polyfill';\n\n// Computeds waiting to re-run after their dependencies changed.\nconst pending = new Set<Signal.Computed<void>>();\n\nconst watcher = new Signal.subtle.Watcher(() => {\n  queueMicrotask(runPending);\n});\n\nfunction runPending() {\n  for (const c of watcher.getPending()) {\n    pending.add(c as Signal.Computed<void>);\n  }\n  watcher.watch(); // re-arm before running effects, in case they write signals\n  for (const c of pending) {\n    pending.delete(c);\n    c.get(); // re-run the effect body\n  }\n}\n\n/**\n * Run a side effect whenever its signal dependencies change.\n *\n * Executes immediately (synchronous initial run), then re-runs on the next\n * microtask after any dependency changes. If the callback returns a function,\n * it is called before each re-run and when the effect is stopped — the same\n * cleanup contract as Preact Signals, Maverick Signals, and Svelte 5 $effect.\n *\n * Returns a cleanup function that stops the effect.\n */\nexport function effect(fn: () => (() => void) | void): () => void {\n  let cleanup: (() => void) | void;\n  const c = new Signal.Computed(() => {\n    if (typeof cleanup === 'function') cleanup();\n    cleanup = fn();\n  });\n  watcher.watch(c);\n  c.get(); // initial run\n  return () => {\n    watcher.unwatch(c);\n    if (typeof cleanup === 'function') cleanup();\n  };\n}\n"],"mappings":";;AAGA,MAAM,0BAAU,IAAI,IAA2B;AAE/C,MAAM,UAAU,IAAI,OAAO,OAAO,cAAc;CAC9C,eAAe,UAAU;AAC3B,CAAC;AAED,SAAS,aAAa;CACpB,KAAK,MAAM,KAAK,QAAQ,WAAW,GACjC,QAAQ,IAAI,CAA0B;CAExC,QAAQ,MAAM;CACd,KAAK,MAAM,KAAK,SAAS;EACvB,QAAQ,OAAO,CAAC;EAChB,EAAE,IAAI;CACR;AACF;;;;;;;;;;;AAYA,SAAgB,OAAO,IAA2C;CAChE,IAAI;CACJ,MAAM,IAAI,IAAI,OAAO,eAAe;EAClC,IAAI,OAAO,YAAY,YAAY,QAAQ;EAC3C,UAAU,GAAG;CACf,CAAC;CACD,QAAQ,MAAM,CAAC;CACf,EAAE,IAAI;CACN,aAAa;EACX,QAAQ,QAAQ,CAAC;EACjB,IAAI,OAAO,YAAY,YAAY,QAAQ;CAC7C;AACF"}

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

@@ -0,0 +1,46 @@
+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 { 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

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.d.ts","names":[],"sources":["../../../../src/core/signals/primitives.ts"],"mappings":";;;cAGa,UAAU,GAAG,UAAU,MAAM;;KAqB9B,SAAO,KAAK,OAAS,MAAM;;KAG3B,SAAS,KAAK,OAAS,SAAS;;KAGhC,eAAe,KAAK,KAAK,OAAS,MAAM;UAEnC,cAAc;EAC7B,UAAU,GAAG,GAAG,IAAI;;;iBAIN,OAAO,GAAG,cAAc,GAAG,UAAU,cAAc,KAAK,SAAO;;iBAK/D,SAAS,GAAG,UAAU,GAAG,UAAU,cAAc,KAAK,SAAS;;;;;;;;;;;;;;iBAiB/D,OAAO,GAAG,QAAQ,SAAO,IAAI,UAAU,SAAS,MAAM;iBACtD,OAAO,kBAAkB,QAAQ,SAAO,IAAI,SAAS,QAAQ;;;;;;;;;iBAqC7D,SAAS,UAAU,eAAe,0BAChD,KAAK,OACD,WAAW,IAAI,EAAE;EAAa,aAAa;IAAM"}

package/dist/dev/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/dev/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/dev/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/dev/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/dev/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/dev/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/dev/core/tasks/task.d.ts

@@ -0,0 +1,166 @@
+//#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;
+  /**
+   * The last successful value carried forward from the run this was `clone()`d
+   * from — the prior cycle's result for a `RecurringRunner` (undefined for an
+   * original, or until the lineage has produced a success).
+   */
+  readonly previous: DeepReadonly<TValue> | undefined;
+  /**
+   * The signal this task's work runs under (its own abort composed with any
+   * external one). Aborting the task fires it — so a `reschedule` can wait on it
+   * to have its delay cancelled when the recurrence is aborted.
+   */
+  readonly signal: AbortSignal;
+  /** Run the work, memoized: repeated calls share one execution + result. */
+  run(): Promise<TValue>;
+  abort(): void;
+  /** A fresh, structurally identical task (same work + id) in a pending state — for re-running. */
+  clone(): TaskLike<TValue, TError>;
+}
+/**
+ * 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.
+ */
+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;
+  get previous(): DeepReadonly<TValue> | undefined;
+  get signal(): AbortSignal;
+  run(): Promise<TValue>;
+  abort(): void;
+  /**
+   * A fresh task with the same work, id, and external signal, in a pending state
+   * (its own AbortController, no memoized result) — so it can be run again. Used
+   * to re-run structurally identical work (e.g. `RecurringRunner` reloads).
+   *
+   * The clone inherits this run's value as its `previous` (or this run's own
+   * `previous` if it never produced one — e.g. it errored), so a recurrence's
+   * `previous` always tracks the last *successful* value across the lineage with
+   * no bookkeeping in the runner.
+   */
+  clone(): Task<TValue, TError>;
+}
+/**
+ * Runs tasks concurrently, deduplicated by task id.
+ *
+ * If a task with a given id is already in flight, subsequent schedule() calls
+ * for that id are silently ignored until the first completes. Tasks are stored
+ * so abortAll() can cancel any in-flight work (e.g. on engine cleanup).
+ */
+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;
+}
+/**
+ * Decides whether — and *when* — a {@link RecurringRunner} re-runs its task.
+ * Invoked **concurrently with the run** (so the inter-run interval can be
+ * measured from when the run *started*, not when it finished) with the single
+ * {@link TaskLike}, which carries everything a decision needs:
+ * - `task.run()` — the in-flight run, observable via this memoized call (does
+ *   not re-trigger work), e.g. to read its result for a cadence/stop decision.
+ * - `task.previous` — the prior successful run's value (`undefined` on the
+ *   first), for decisions that compare consecutive results.
+ * - `task.signal` — aborts the wait (and the recurrence) when the task is.
+ *
+ * Resolves `true` to re-run (after whatever delay it owns) or `false` to stop.
+ * The runner deals only in this awaitable verdict — *how* the delay is produced
+ * (a timer, a frame, an event) and *when* it's measured from live entirely in
+ * the reschedule function, so the runner itself knows nothing about time. See
+ * `delayedReschedule` for the common timer-based, start-anchored implementation.
+ */
+type Reschedule<TValue> = (task: TaskLike<TValue>) => PromiseLike<boolean>;
+//#endregion
+export { ConcurrentRunner, DeepReadonly, Reschedule, 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,aAAa,KAAK,iBAAiB,OAC3C,cAAc,aAAa,MAC3B,+BACc,WAAW,IAAI,aAAa,EAAE,SAC1C;KAMM;;;;UAKK;;;;;;;EAOf;;;;;;EAOA,SAAS;;;;;UAMM,SAAS,eAAe;WAC9B;WACA,QAAQ;WACR,OAAO,aAAa;WACpB,OAAO,aAAa;;;;;;WAMpB,UAAU,aAAa;;;;;;WAMvB,QAAQ;;EAEjB,OAAO,QAAQ;EACf;;EAEA,SAAS,SAAS,QAAQ;;;;;;;;;;;;;;;;;;;cAoBf,KAAK,eAAe,6BAA6B,SAAS,QAAQ;;WACpE;EAYT,YAAY,QAAQ,QAAQ,gBAAgB,QAAQ,SAAS,SAAS;MAUlE,UAAU;MAIV,SAAS,aAAa;MAItB,SAAS,aAAa;MAItB,YAAY,aAAa;MAIzB,UAAU;EAId,OAAO,QAAQ;EAuBf;;;;;;;;;;;EAcA,SAAS,KAAK,QAAQ;;;;;;;;;cAkBX;;EAMX,SAAS,eAAe,kBAAkB,MAAM,SAAS,QAAQ,UAAU,QAAQ;;;;;;;EAkCnF,YAAY;EAYZ;EAWA;;;;;;;;;;;;;;;;cAwBW;;EAMX,SAAS,eAAe,kBAAkB,MAAM,SAAS,QAAQ,UAAU,QAAQ;;;;;;;MA8B/E,WAAW;;;;;;;;EAWf,YAAY;;EAaZ;EAKA;EAKA;;;;;;;;;;;;;;;;;;;KA2BU,WAAW,WAAW,MAAM,SAAS,YAAY"}