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

package/dist/dev/core/machine.d.ts

@@ -2,15 +2,15 @@ import { ReadonlySignal } from "./signals/primitives.js";
 import "../index.js";
 //#region src/core/machine.d.ts
 /**
- * Base snapshot for all machine-like primitives (Actors and Reactors).
- * Carries only the finite state value. Actors extend this with `context`.
+ * Base snapshot for all machine-like primitives (Actors and Reactors). Carries only the finite state value. Actors
+ * extend this with `context`.
  */
 interface MachineSnapshot<State extends string> {
   value: State;
 }
 /**
- * Shared interface for all machine-like primitives.
- * Both Actors (message-driven) and Reactors (signal-driven) implement this.
+ * Shared interface for all machine-like primitives. Both Actors (message-driven) and Reactors (signal-driven) implement
+ * this.
  */
 interface Machine<Snapshot extends MachineSnapshot<string>> {
   readonly snapshot: ReadonlySignal<Snapshot>;

package/dist/dev/core/machine.js

@@ -1,11 +1,10 @@
 import { signal, untrack, update } from "./signals/primitives.js";
 //#region src/core/machine.ts
 /**
-* Provisions the shared mechanics for all machine-like primitives: a snapshot
-* signal, an untracked state reader, and a transition function.
+* Provisions the shared mechanics for all machine-like primitives: a snapshot signal, an untracked state reader, and a
+* transition function.
 *
-* Internal — consumed by `createMachineActor` and `createMachineReactor`. Not part of the
-* public API.
+* Internal — consumed by `createMachineActor` and `createMachineReactor`. Not part of the public API.
 */
 function createMachineCore(initialSnapshot) {
 	const snapshotSignal = signal(initialSnapshot);

package/dist/dev/core/machine.js.map

@@ -1 +1 @@
-{"version":3,"file":"machine.js","names":[],"sources":["../../../src/core/machine.ts"],"sourcesContent":["import type { ReadonlySignal } from './signals/primitives';\nimport { signal, untrack, update } from './signals/primitives';\n\n// =============================================================================\n// Shared snapshot type\n// =============================================================================\n\n/**\n * Base snapshot for all machine-like primitives (Actors and Reactors).\n * Carries only the finite state value. Actors extend this with `context`.\n */\nexport interface MachineSnapshot<State extends string> {\n  value: State;\n}\n\n// =============================================================================\n// Shared interface\n// =============================================================================\n\n/**\n * Shared interface for all machine-like primitives.\n * Both Actors (message-driven) and Reactors (signal-driven) implement this.\n */\nexport interface Machine<Snapshot extends MachineSnapshot<string>> {\n  readonly snapshot: ReadonlySignal<Snapshot>;\n  destroy(): void;\n}\n\n// =============================================================================\n// Shared core factory\n// =============================================================================\n\n/**\n * Provisions the shared mechanics for all machine-like primitives: a snapshot\n * signal, an untracked state reader, and a transition function.\n *\n * Internal — consumed by `createMachineActor` and `createMachineReactor`. Not part of the\n * public API.\n */\nexport function createMachineCore<FullState extends string, Snapshot extends MachineSnapshot<FullState>>(\n  initialSnapshot: Snapshot\n) {\n  const snapshotSignal = signal(initialSnapshot);\n  const getState = (): FullState => untrack(() => snapshotSignal.get().value);\n  const transition = (to: FullState): void => update(snapshotSignal, (current) => ({ ...current, value: to }));\n  return { snapshotSignal, getState, transition };\n}\n"],"mappings":";;;;;;;;;AAuCA,SAAgB,kBACd,iBACA;CACA,MAAM,iBAAiB,OAAO,eAAe;CAC7C,MAAM,iBAA4B,cAAc,eAAe,IAAI,CAAC,CAAC,KAAK;CAC1E,MAAM,cAAc,OAAwB,OAAO,iBAAiB,aAAa;EAAE,GAAG;EAAS,OAAO;CAAG,EAAE;CAC3G,OAAO;EAAE;EAAgB;EAAU;CAAW;AAChD"}
+{"version":3,"file":"machine.js","names":[],"sources":["../../../src/core/machine.ts"],"sourcesContent":["import type { ReadonlySignal } from './signals/primitives';\nimport { signal, untrack, update } from './signals/primitives';\n\n// =============================================================================\n// Shared snapshot type\n// =============================================================================\n\n/**\n * Base snapshot for all machine-like primitives (Actors and Reactors). Carries only the finite state value. Actors\n * extend this with `context`.\n */\nexport interface MachineSnapshot<State extends string> {\n  value: State;\n}\n\n// =============================================================================\n// Shared interface\n// =============================================================================\n\n/**\n * Shared interface for all machine-like primitives. Both Actors (message-driven) and Reactors (signal-driven) implement\n * this.\n */\nexport interface Machine<Snapshot extends MachineSnapshot<string>> {\n  readonly snapshot: ReadonlySignal<Snapshot>;\n  destroy(): void;\n}\n\n// =============================================================================\n// Shared core factory\n// =============================================================================\n\n/**\n * Provisions the shared mechanics for all machine-like primitives: a snapshot signal, an untracked state reader, and a\n * transition function.\n *\n * Internal — consumed by `createMachineActor` and `createMachineReactor`. Not part of the public API.\n */\nexport function createMachineCore<FullState extends string, Snapshot extends MachineSnapshot<FullState>>(\n  initialSnapshot: Snapshot\n) {\n  const snapshotSignal = signal(initialSnapshot);\n  const getState = (): FullState => untrack(() => snapshotSignal.get().value);\n  const transition = (to: FullState): void => update(snapshotSignal, (current) => ({ ...current, value: to }));\n\n  return { snapshotSignal, getState, transition };\n}\n"],"mappings":";;;;;;;;AAsCA,SAAgB,kBACd,iBACA;CACA,MAAM,iBAAiB,OAAO,eAAe;CAC7C,MAAM,iBAA4B,cAAc,eAAe,IAAI,CAAC,CAAC,KAAK;CAC1E,MAAM,cAAc,OAAwB,OAAO,iBAAiB,aAAa;EAAE,GAAG;EAAS,OAAO;CAAG,EAAE;CAE3G,OAAO;EAAE;EAAgB;EAAU;CAAW;AAChD"}

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

@@ -3,17 +3,15 @@ import { Machine, MachineSnapshot } from "../machine.js";
 /**
  * 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
+ * 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).
+ * May return a cleanup function that runs before each re-evaluation and on state exit (including destroy).
  */
 type ReactorEffectFn = () => (() => void) | {
   abort(): void;
@@ -21,12 +19,10 @@ type ReactorEffectFn = () => (() => 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.
+ * - `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.
  */
@@ -37,23 +33,20 @@ type ReactorStateDefinition = {
 /**
  * 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.
+ * `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.
+   * 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.
+   * 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>;
 };
@@ -62,30 +55,31 @@ 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.
+ * 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'`
+ * `'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; },
+ *   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: {},
  *     },
- *     waiting: {},
- *   }
- * });
+ *   });
  */
 declare function createMachineReactor<State extends string>(def: ReactorDefinition<State>): Reactor<State | 'destroying' | 'destroyed'>;
 //#endregion

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

@@ -1 +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"}
+{"version":3,"file":"create-machine-reactor.d.ts","names":[],"sources":["../../../../src/core/reactors/create-machine-reactor.ts"],"mappings":";;;;;;;;;KAgBY,gBAAgB,8BAA8B;;;;;;KAO9C;EAAyC;;;;;;;;;;;;KAYzC;EACV,QAAQ,kBAAkB;EAC1B,UAAU,kBAAkB;;;;;;;;KASlB,kBAAkB;;EAE5B,SAAS;;;;;EAKT,UAAU,gBAAgB,SAAS,gBAAgB;;;;;EAKnD,QAAQ,OAAO,OAAO;;;KAQZ,QAAQ,wBAAwB,QAAQ,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCpD,qBAAqB,sBACnC,KAAK,kBAAkB,SACtB,QAAQ"}

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

@@ -6,30 +6,31 @@ 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.
+* 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'`
+* `'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; },
+*   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: {},
 *     },
-*     waiting: {},
-*   }
-* });
+*   });
 */
 function createMachineReactor(def) {
 	const { snapshotSignal, getState, transition } = createMachineCore({ value: def.initial });

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

@@ -1 +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"}
+{"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 the fn body create reactive dependencies —\n * the framework re-evaluates it when 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 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 untracked — no `untrack()` calls are needed\n *   inside. Use this for one-time setup: reading current values, attaching event listeners, etc.\n * - `effects` run on state entry and re-run whenever a signal read inside the fn body changes. Use `untrack()` for reads\n *   you do not want to track. 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 `'destroyed'` are always added by the framework as\n * implicit terminal states — 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 ordering guarantee ensures transitions fired\n   * here take effect before 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 `{}` for states with no effects. `entry` and\n   * `effects` each become independent `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 imperative messages. Each state holds an array\n * of effect functions — every element becomes one independent `effect()` call gated on that state, with its own\n * dependency tracking and cleanup lifecycle.\n *\n * `'destroying'` and `'destroyed'` are always implicit terminal states. `destroy()` transitions through both in\n * sequence: `'destroying'` first (for 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: () => {\n *           currentTimeSignal.get();\n *           return cleanup;\n *         },\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\n    if (typeof result === 'function') return result;\n\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\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\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\n      const baseCall = () => fn();\n\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\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\n      for (const dispose of effectDisposals) dispose();\n    },\n  };\n}\n"],"mappings":";;;;AAwEA,MAAM,WAAc,MAAiC,MAAM,KAAA,IAAY,CAAC,IAAI,MAAM,QAAQ,CAAC,IAAI,IAAI,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCrG,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;EAEpB,IAAI,OAAO,WAAW,YAAY,OAAO;EAEzC,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;GAElB,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;EAE1E,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;EAE1B,MAAM,iBAAiB,GAAG;EAE1B,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;GAKrD,WAAW,YAAY;GACvB,WAAW,WAAW;GAEtB,KAAK,MAAM,WAAW,iBAAiB,QAAQ;EACjD;CACF;AACF"}

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

@@ -2,10 +2,9 @@
 /**
  * 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.
+ * 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.
  */

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

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

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

@@ -10,15 +10,34 @@ function runPending() {
 	for (const c of pending) {
 		pending.delete(c);
 		c.get();
+		revalidateSources(c);
 	}
 }
 /**
+* Recover an effect that wrote a signal one of its own dependencies reads.
+*
+* When an effect body writes a signal that an intermediate computed in its own dependency graph consumes (e.g. a
+* track-selection effect writing the selection slot a candidate-set computed consults), the graph can't tell the
+* effect: the write marks the intermediate dirty, but the effect is the in-flight consumer, so no watcher notification
+* fires — and the effect finishes the run _clean but stale_. Worse, every later external change routed through that
+* intermediate is deduped against its standing dirty flag, so the effect never hears about those either (the
+* lost-wakeup).
+*
+* Pulling each source once after the run closes the hole: a dirtied intermediate recomputes and its dirty flag clears,
+* so the _next_ change through it propagates and wakes the effect normally. The guarantee is liveness, not immediacy —
+* the effect is deliberately not re-run just because it wrote into its own graph (that would double-run every writing
+* effect); it catches up on the next genuine change. Sources that are clean, or whose recomputation is equals-gated to
+* the same value, cost a cached read and notify no one.
+*/
+function revalidateSources(c) {
+	for (const source of Signal.subtle.introspectSources(c)) source.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.
+* 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.
 */
@@ -30,6 +49,7 @@ function effect(fn) {
 	});
 	watcher.watch(c);
 	c.get();
+	revalidateSources(c);
 	return () => {
 		watcher.unwatch(c);
 		if (typeof cleanup === "function") cleanup();

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

@@ -1 +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"}
+{"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\n  watcher.watch(); // re-arm before running effects, in case they write signals\n\n  for (const c of pending) {\n    pending.delete(c);\n    c.get(); // re-run the effect body\n    revalidateSources(c);\n  }\n}\n\n/**\n * Recover an effect that wrote a signal one of its own dependencies reads.\n *\n * When an effect body writes a signal that an intermediate computed in its own dependency graph consumes (e.g. a\n * track-selection effect writing the selection slot a candidate-set computed consults), the graph can't tell the\n * effect: the write marks the intermediate dirty, but the effect is the in-flight consumer, so no watcher notification\n * fires — and the effect finishes the run _clean but stale_. Worse, every later external change routed through that\n * intermediate is deduped against its standing dirty flag, so the effect never hears about those either (the\n * lost-wakeup).\n *\n * Pulling each source once after the run closes the hole: a dirtied intermediate recomputes and its dirty flag clears,\n * so the _next_ change through it propagates and wakes the effect normally. The guarantee is liveness, not immediacy —\n * the effect is deliberately not re-run just because it wrote into its own graph (that would double-run every writing\n * effect); it catches up on the next genuine change. Sources that are clean, or whose recomputation is equals-gated to\n * the same value, cost a cached read and notify no one.\n */\nfunction revalidateSources(c: Signal.Computed<void>): void {\n  for (const source of Signal.subtle.introspectSources(c)) {\n    (source as Signal.State<unknown> | Signal.Computed<unknown>).get();\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 microtask after any dependency changes. If\n * the callback returns a function, it is called before each re-run and when the effect is stopped — the same cleanup\n * 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\n    cleanup = fn();\n  });\n\n  watcher.watch(c);\n  c.get(); // initial run\n  revalidateSources(c); // an initial run may self-write too — see the note\n  return () => {\n    watcher.unwatch(c);\n\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;CAGxC,QAAQ,MAAM;CAEd,KAAK,MAAM,KAAK,SAAS;EACvB,QAAQ,OAAO,CAAC;EAChB,EAAE,IAAI;EACN,kBAAkB,CAAC;CACrB;AACF;;;;;;;;;;;;;;;;;AAkBA,SAAS,kBAAkB,GAAgC;CACzD,KAAK,MAAM,UAAU,OAAO,OAAO,kBAAkB,CAAC,GACpD,OAA6D,IAAI;AAErE;;;;;;;;;;AAWA,SAAgB,OAAO,IAA2C;CAChE,IAAI;CACJ,MAAM,IAAI,IAAI,OAAO,eAAe;EAClC,IAAI,OAAO,YAAY,YAAY,QAAQ;EAE3C,UAAU,GAAG;CACf,CAAC;CAED,QAAQ,MAAM,CAAC;CACf,EAAE,IAAI;CACN,kBAAkB,CAAC;CACnB,aAAa;EACX,QAAQ,QAAQ,CAAC;EAEjB,IAAI,OAAO,YAAY,YAAY,QAAQ;CAC7C;AACF"}

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

@@ -18,25 +18,23 @@ declare function computed<T>(fn: () => T, options?: SignalOptions<T>): Computed<
 /**
  * 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`.
+ * - **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);
+ *   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.
+ * Read every signal in a map and return a plain object snapshot. Each read tracks in the surrounding Computed/Effect —
+ * equivalent to calling `.get()` on a single `Signal<S>` over the merged shape.
  *
- * Convenience for behaviors that pass whole state/context snapshots to pure
- * helpers; prefer per-field reads when only a few fields are needed.
+ * Convenience for behaviors that pass whole state/context snapshots to pure helpers; prefer per-field reads when only a
+ * few fields are needed.
  */
 declare function snapshot<M extends Record<string, ReadonlySignal<unknown>>>(map: M): { [K in keyof M]: M[K] extends {
   get(): infer V;

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":";;;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"}
+{"version":3,"file":"primitives.d.ts","names":[],"sources":["../../../../src/core/signals/primitives.ts"],"mappings":";;;cAGa,UAAU,GAAG,UAAU,MAAM;;KAkB9B,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;;;;;;;;;;;;;iBAgB/D,OAAO,GAAG,QAAQ,SAAO,IAAI,UAAU,SAAS,MAAM;iBACtD,OAAO,kBAAkB,QAAQ,SAAO,IAAI,SAAS,QAAQ;;;;;;;;iBAmC7D,SAAS,UAAU,eAAe,0BAChD,KAAK,OACD,WAAW,IAAI,EAAE;EAAa,aAAa;IAAM"}

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

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

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

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

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

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

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

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

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

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

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