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

package/dist/dev/playback/behaviors/dom/setup-mediasource.js.map

@@ -1 +1 @@
-{"version":3,"file":"setup-mediasource.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/setup-mediasource.ts"],"sourcesContent":["/**\n * **Own the MediaSource lifecycle for the current source.** When a resolved\n * presentation and a mediaElement are both in scope, creates a MediaSource,\n * attaches it to the element, waits for `'open'`, and publishes it on\n * `context.mediaSource`. On source change or behavior destroy, detaches the\n * MediaSource and clears the slot so the next source starts fresh.\n *\n * Single-positive-state reactor (`'preconditions-unmet'` ↔ `'mediasource-attached'`):\n * state derivation gates on `mediaElement + isResolvedPresentation`. Riding the\n * resolver's resolved/unresolved lifecycle makes direct URL replacement\n * structural — `resolvePresentation` routes the presentation back through\n * unresolved on URL change, which drives this reactor through\n * `'preconditions-unmet'` so the entry's state-exit cleanup detaches the old\n * MediaSource before the new one is built.\n *\n * The entry resolves preconditions in sequence before publishing:\n *\n * 1. **Create + attach** — `createMediaSource` + `attachMediaSource` run\n *    synchronously on entry. The `detach` closure returned by\n *    `attachMediaSource` is captured for state-exit cleanup, so the cleanup\n *    is always bound to its setup even if the wait below is aborted.\n * 2. **Wait for `'open'`** — `waitForMediaSourceOpen` defers until the first\n *    `sourceopen` event (or any readyState transition out of `'closed'`).\n * 3. **Publish on `'open'`** — re-check `readyState === 'open'` after the\n *    await (covers `'ended'` / `'closed'` race) before writing to\n *    `context.mediaSource`. Downstream `setupVideoBufferActors` /\n *    `setupAudioBufferActors` call `addSourceBuffer` directly, which\n *    throws on non-open, so publish-only-when-open is the load-bearing\n *    contract.\n *\n * State-exit cleanup aborts the in-flight wait, detaches the MediaSource,\n * and clears `context.mediaSource`. Order: abort first (prevents a late\n * publish racing the slot clear), then detach, then clear.\n *\n * # Sourceclose recovery\n *\n * The behavior owns one **unclosed** MediaSource per source identity. The UA can\n * close the attached MediaSource out from under the engine (Safari on an\n * AirPlay handoff — see `setupAirPlay` — or a ManagedMediaSource evicted\n * under memory pressure), and a closed MediaSource can never reopen. The\n * `sourceclose` listener tears the attachment down synchronously; every\n * teardown records a local close-fact, which holds the machine out until\n * the fact is consumed — then the re-derive comes back in with a fresh\n * MediaSource for the *same* source. Cause-agnostic. Consumption honors an\n * observed `loadingSuspended` (attaching runs `element.load()` — new loading\n * work, e.g. resource selection under an active AirPlay receiver), and\n * happens only while the machine is out, so a suspension can never tear\n * down an existing attachment.\n *\n * Sole writer of `context.mediaSource`; other MSE behaviors\n * (`setupVideoBufferActors`, `setupAudioBufferActors`,\n * `updateMediaSourceDuration`, `endOfStream`, `loadVideoSegments`) only\n * read.\n */\nimport { listen } from '@videojs/utils/dom';\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, type ReadonlySignal, type Signal, signal } from '../../../core/signals/primitives';\nimport { attachMediaSource, createMediaSource, waitForMediaSourceOpen } from '../../../media/dom/mse/mediasource-setup';\nimport { isResolvedPresentation, type MaybeResolvedPresentation } from '../../../media/types';\n\n/**\n * State shape required for MediaSource setup.\n */\nexport interface MediaSourceState {\n  presentation?: MaybeResolvedPresentation;\n}\n\n/**\n * Context shape for MediaSource setup.\n */\nexport interface MediaSourceContext {\n  mediaElement?: HTMLMediaElement | undefined;\n  mediaSource?: MediaSource;\n}\n\n/**\n * Config for MediaSource setup.\n */\nexport interface MediaSourceSetupConfig {\n  /**\n   * Attach strategy — a composition-supplied implementation. Defaults to\n   * `attachMediaSource` (object URL on the `src` attribute). Compositions\n   * that pair MSE with sibling `<source>` alternatives wire\n   * `attachMediaSourceAsSourceElement` (e.g. the HLS engine, for\n   * `setupAirPlay`'s native fallback source).\n   */\n  attachMediaSource?: typeof attachMediaSource;\n}\n\ntype MediaSourceFsmState = 'preconditions-unmet' | 'mediasource-attached';\n\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaElement: HTMLMediaElement | undefined,\n  mediaSourceClosed: boolean\n): MediaSourceFsmState {\n  if (!mediaElement || !isResolvedPresentation(presentation)) return 'preconditions-unmet';\n  // The current attachment was torn down (typically a UA-fired\n  // `sourceclose`). The fact stands until the `'preconditions-unmet'`\n  // effects consume it (see below); the reset then re-derives into a fresh\n  // attach for the same source.\n  if (mediaSourceClosed) return 'preconditions-unmet';\n  return 'mediasource-attached';\n}\n\nfunction setupMediaSourceSetup({\n  state,\n  context,\n  config = {},\n}: {\n  state: {\n    presentation: ReadonlySignal<MediaSourceState['presentation']>;\n  };\n  context: {\n    mediaElement: ReadonlySignal<MediaSourceContext['mediaElement']>;\n    mediaSource: Signal<MediaSourceContext['mediaSource']>;\n  };\n  config?: MediaSourceSetupConfig;\n}): Reactor<MediaSourceFsmState | 'destroying' | 'destroyed'> {\n  const attach = config.attachMediaSource ?? attachMediaSource;\n  // `loadingSuspended` is observed, never declared: the slot exists only in\n  // compositions where a feature behavior (e.g. `setupAirPlay`) declares and\n  // writes it, so it lives behind a cast rather than in the typed param\n  // above — an optional param key would force declaring it in `stateKeys`,\n  // which is what materializes a slot. Shape redefined locally (canonical:\n  // `SegmentLoadingState['loadingSuspended']`) to avoid a load-segments\n  // module dependency.\n  const loadingSuspended = (state as { loadingSuspended?: ReadonlySignal<boolean | undefined> }).loadingSuspended;\n\n  // Close-fact for the currently-owned MediaSource, flipped by the\n  // entry's shared teardown. Consumed in `'preconditions-unmet'`.\n  const mediaSourceClosed = signal(false);\n\n  const derivedStateSignal = computed(() =>\n    deriveState(state.presentation.get(), context.mediaElement.get(), mediaSourceClosed.get())\n  );\n\n  return createMachineReactor<MediaSourceFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {\n        // Consume a recorded close once new loading work may initiate — the\n        // reset re-derives into `'mediasource-attached'`, rebuilding a fresh\n        // MediaSource for the same source. While an observed\n        // `loadingSuspended` holds, the fact stands and the rebuild waits:\n        // attaching runs `element.load()`, which is exactly the loading work\n        // the suspension forbids. Consuming only from this state means a\n        // suspension can never tear down an existing attachment — there is\n        // no code path from `loadingSuspended` to an exit.\n        effects: () => {\n          // `mediaSourceClosed` is tracked, not peeked: a new state's effects\n          // can run BEFORE the old state's exit cleanup (effects run in\n          // states-declaration order), so a teardown's fact-write can land\n          // after this effect's entry run — tracking re-fires the consume.\n          // Not suspended = slot absent (no writer composed) or value falsy.\n          if (mediaSourceClosed.get() && !loadingSuspended?.get()) mediaSourceClosed.set(false);\n        },\n      },\n\n      'mediasource-attached': {\n        // entry body is auto-untracked. deriveState handles source resets via\n        // the resolver's resolved/unresolved transitions; this entry creates\n        // and attaches the MediaSource, awaits `'open'`, publishes on\n        // context, and binds detach + slot clear to state exit + destroy.\n        entry: () => {\n          const mediaElement = context.mediaElement.get()!;\n          const controller = new AbortController();\n\n          const mediaSource = createMediaSource({ preferManaged: true });\n          // Sync attach: the returned `detach` closes over the element +\n          // object-URL captured at this moment, so state-exit cleanup tears\n          // down exactly this attachment regardless of how the wait below\n          // resolves.\n          const { detach } = attach(mediaSource, mediaElement);\n\n          // One complete teardown, shared by both triggers (the sourceclose\n          // listener below and the state-exit cleanup) — whichever fires\n          // first does the work; a re-run is harmless. Order matters:\n          //\n          // 1. Abort first — kills the open-wait and the listener, so a late\n          //    publish can't race the slot clear.\n          // 2. Clear the slot, which stops the downstream MSE pipeline and\n          //    dirties the effects of behaviors owning sibling `<source>`\n          //    children (`setupAirPlay`'s native-HLS fallback), queueing their\n          //    removal pass. Kept ahead of the detach so that queueing is\n          //    explicit: the `mediaSourceClosed` write above happens to queue\n          //    the same pass today, but depending on it would couple this to\n          //    an unrelated write.\n          // 3. Detach with `deferReset`, which queues detach's `load()` reset\n          //    behind that pass. A synchronous reset would run resource\n          //    selection while the fallback is still in the DOM and commit the\n          //    element to the outgoing manifest — starting native HLS playback\n          //    of the source being torn down. Removing our own `<source>`\n          //    doesn't re-run selection on its own, so nothing starts in the\n          //    gap. The ownership guard re-checks at fire time, so a re-attach\n          //    landing in between suppresses the reset.\n          const teardown = () => {\n            mediaSourceClosed.set(true);\n            controller.abort();\n            context.mediaSource.set(undefined);\n            detach({ deferReset: true });\n          };\n\n          // Sourceclose recovery: the UA closing this MediaSource (AirPlay\n          // handoff, MMS eviction) tears the attachment down synchronously —\n          // detach skips\n          // its `load()` reset for a closed MediaSource (see\n          // `attachMediaSource`), leaving the element as the session or\n          // eviction left it.\n          listen(mediaSource, 'sourceclose', teardown, { signal: controller.signal });\n\n          const publishWhenOpen = async () => {\n            await waitForMediaSourceOpen(mediaSource, controller.signal);\n            if (controller.signal.aborted) return;\n            // `waitForMediaSourceOpen` resolves on any readyState transition\n            // out of `'closed'`; if we landed in `'ended'` / `'closed'`\n            // instead of `'open'`, the attach window is gone and we leave\n            // the slot unpublished. The session is dead within this source\n            // either way — publishing wouldn't help because\n            // `setupVideoBufferActors` / `setupAudioBufferActors` calls\n            // `addSourceBuffer` which throws on non-open. The next\n            // source-reset re-enters this state with a fresh MediaSource\n            // and recovers. Warn so the case is at least diagnosable; in\n            // practice it requires the MediaSource to close/end before its\n            // very first `sourceopen`, which a freshly attached MS\n            // shouldn't do.\n            if (mediaSource.readyState !== 'open') {\n              console.warn(\n                `[setupMediaSource] MediaSource transitioned to '${mediaSource.readyState}' before first 'sourceopen' — slot left unpublished; recoverable on next source reset.`\n              );\n              return;\n            }\n            context.mediaSource.set(mediaSource);\n          };\n\n          publishWhenOpen().catch((err) => console.error('[setupMediaSource] failed to publish MediaSource:', err));\n\n          // State-exit cleanup — fires on source unload, element detach, or\n          // behavior destroy; a harmless re-run after a `sourceclose`\n          // already tore down.\n          return teardown;\n        },\n      },\n    },\n  });\n}\n\nexport const setupMediaSource = defineBehavior({\n  stateKeys: ['presentation'],\n  contextKeys: ['mediaElement', 'mediaSource'],\n  setup: setupMediaSourceSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6FA,SAAS,YACP,cACA,cACA,mBACqB;CACrB,IAAI,CAAC,gBAAgB,CAAC,uBAAuB,YAAY,GAAG,OAAO;CAKnE,IAAI,mBAAmB,OAAO;CAC9B,OAAO;AACT;AAEA,SAAS,sBAAsB,EAC7B,OACA,SACA,SAAS,CAAC,KAUkD;CAC5D,MAAM,SAAS,OAAO,qBAAqB;CAQ3C,MAAM,mBAAoB,MAAqE;CAI/F,MAAM,oBAAoB,OAAO,KAAK;CAEtC,MAAM,qBAAqB,eACzB,YAAY,MAAM,aAAa,IAAI,GAAG,QAAQ,aAAa,IAAI,GAAG,kBAAkB,IAAI,CAAC,CAC3F;CAEA,OAAO,qBAA0C;EAC/C,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,EASrB,eAAe;IAMb,IAAI,kBAAkB,IAAI,KAAK,CAAC,kBAAkB,IAAI,GAAG,kBAAkB,IAAI,KAAK;GACtF,EACF;GAEA,wBAAwB,EAKtB,aAAa;IACX,MAAM,eAAe,QAAQ,aAAa,IAAI;IAC9C,MAAM,aAAa,IAAI,gBAAgB;IAEvC,MAAM,cAAc,kBAAkB,EAAE,eAAe,KAAK,CAAC;IAK7D,MAAM,EAAE,WAAW,OAAO,aAAa,YAAY;IAuBnD,MAAM,iBAAiB;KACrB,kBAAkB,IAAI,IAAI;KAC1B,WAAW,MAAM;KACjB,QAAQ,YAAY,IAAI,KAAA,CAAS;KACjC,OAAO,EAAE,YAAY,KAAK,CAAC;IAC7B;IAQA,OAAO,aAAa,eAAe,UAAU,EAAE,QAAQ,WAAW,OAAO,CAAC;IAE1E,MAAM,kBAAkB,YAAY;KAClC,MAAM,uBAAuB,aAAa,WAAW,MAAM;KAC3D,IAAI,WAAW,OAAO,SAAS;KAa/B,IAAI,YAAY,eAAe,QAAQ;MACrC,QAAQ,KACN,mDAAmD,YAAY,WAAW,uFAC5E;MACA;KACF;KACA,QAAQ,YAAY,IAAI,WAAW;IACrC;IAEA,gBAAgB,CAAC,CAAC,OAAO,QAAQ,QAAQ,MAAM,qDAAqD,GAAG,CAAC;IAKxG,OAAO;GACT,EACF;EACF;CACF,CAAC;AACH;AAEA,MAAa,mBAAmB,eAAe;CAC7C,WAAW,CAAC,cAAc;CAC1B,aAAa,CAAC,gBAAgB,aAAa;CAC3C,OAAO;AACT,CAAC"}
+{"version":3,"file":"setup-mediasource.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/setup-mediasource.ts"],"sourcesContent":["/**\n * **Own the MediaSource lifecycle for the current source.** When a resolved presentation and a mediaElement are both in\n * scope, creates a MediaSource, attaches it to the element, waits for `'open'`, and publishes it on\n * `context.mediaSource`. On source change or behavior destroy, detaches the MediaSource and clears the slot so the next\n * source starts fresh.\n *\n * Single-positive-state reactor (`'preconditions-unmet'` ↔ `'mediasource-attached'`): state derivation gates on\n * `mediaElement + isResolvedPresentation`. Riding the resolver's resolved/unresolved lifecycle makes direct URL\n * replacement structural — `resolvePresentation` routes the presentation back through unresolved on URL change, which\n * drives this reactor through `'preconditions-unmet'` so the entry's state-exit cleanup detaches the old MediaSource\n * before the new one is built.\n *\n * The entry resolves preconditions in sequence before publishing:\n *\n * 1. **Create + attach** — `createMediaSource` + `attachMediaSource` run synchronously on entry. The `detach` closure\n *    returned by `attachMediaSource` is captured for state-exit cleanup, so the cleanup is always bound to its setup\n *    even if the wait below is aborted.\n * 2. **Wait for `'open'`** — `waitForMediaSourceOpen` defers until the first `sourceopen` event (or any readyState\n *    transition out of `'closed'`).\n * 3. **Publish on `'open'`** — re-check `readyState === 'open'` after the await (covers `'ended'` / `'closed'` race)\n *    before writing to `context.mediaSource`. Downstream `setupVideoBufferActors` / `setupAudioBufferActors` call\n *    `addSourceBuffer` directly, which throws on non-open, so publish-only-when-open is the load-bearing contract.\n *\n * State-exit cleanup aborts the in-flight wait, detaches the MediaSource, and clears `context.mediaSource`. Order:\n * abort first (prevents a late publish racing the slot clear), then detach, then clear.\n *\n * # Sourceclose recovery\n *\n * The behavior owns one **unclosed** MediaSource per source identity. The UA can close the attached MediaSource out\n * from under the engine (Safari on an AirPlay handoff — see `setupAirPlay` — or a ManagedMediaSource evicted under\n * memory pressure), and a closed MediaSource can never reopen. The `sourceclose` listener tears the attachment down\n * synchronously; every teardown records a local close-fact, which holds the machine out until the fact is consumed —\n * then the re-derive comes back in with a fresh MediaSource for the _same_ source. Cause-agnostic. Consumption honors\n * an observed `loadingSuspended` (attaching runs `element.load()` — new loading work, e.g. resource selection under an\n * active AirPlay receiver), and happens only while the machine is out, so a suspension can never tear down an existing\n * attachment.\n *\n * Sole writer of `context.mediaSource`; other MSE behaviors (`setupVideoBufferActors`, `setupAudioBufferActors`,\n * `updateMediaSourceDuration`, `endOfStream`, `loadVideoSegments`) only read.\n */\nimport { listen } from '@videojs/utils/dom';\n\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, type ReadonlySignal, type Signal, signal } from '../../../core/signals/primitives';\nimport { attachMediaSource, createMediaSource, waitForMediaSourceOpen } from '../../../media/dom/mse/mediasource-setup';\nimport { isResolvedPresentation, type MaybeResolvedPresentation } from '../../../media/types';\n\n/** State shape required for MediaSource setup. */\nexport interface MediaSourceState {\n  presentation?: MaybeResolvedPresentation;\n}\n\n/** Context shape for MediaSource setup. */\nexport interface MediaSourceContext {\n  mediaElement?: HTMLMediaElement | undefined;\n  mediaSource?: MediaSource;\n}\n\n/** Config for MediaSource setup. */\nexport interface MediaSourceSetupConfig {\n  /**\n   * Attach strategy — a composition-supplied implementation. Defaults to `attachMediaSource` (object URL on the `src`\n   * attribute). Compositions that pair MSE with sibling `<source>` alternatives wire `attachMediaSourceAsSourceElement`\n   * (e.g. the HLS engine, for `setupAirPlay`'s native fallback source).\n   */\n  attachMediaSource?: typeof attachMediaSource;\n}\n\ntype MediaSourceFsmState = 'preconditions-unmet' | 'mediasource-attached';\n\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaElement: HTMLMediaElement | undefined,\n  mediaSourceClosed: boolean\n): MediaSourceFsmState {\n  if (!mediaElement || !isResolvedPresentation(presentation)) return 'preconditions-unmet';\n\n  // The current attachment was torn down (typically a UA-fired\n  // `sourceclose`). The fact stands until the `'preconditions-unmet'`\n  // effects consume it (see below); the reset then re-derives into a fresh\n  // attach for the same source.\n  if (mediaSourceClosed) return 'preconditions-unmet';\n\n  return 'mediasource-attached';\n}\n\nfunction setupMediaSourceSetup({\n  state,\n  context,\n  config = {},\n}: {\n  state: {\n    presentation: ReadonlySignal<MediaSourceState['presentation']>;\n  };\n  context: {\n    mediaElement: ReadonlySignal<MediaSourceContext['mediaElement']>;\n    mediaSource: Signal<MediaSourceContext['mediaSource']>;\n  };\n  config?: MediaSourceSetupConfig;\n}): Reactor<MediaSourceFsmState | 'destroying' | 'destroyed'> {\n  const attach = config.attachMediaSource ?? attachMediaSource;\n  // `loadingSuspended` is observed, never declared: the slot exists only in\n  // compositions where a feature behavior (e.g. `setupAirPlay`) declares and\n  // writes it, so it lives behind a cast rather than in the typed param\n  // above — an optional param key would force declaring it in `stateKeys`,\n  // which is what materializes a slot. Shape redefined locally (canonical:\n  // `SegmentLoadingState['loadingSuspended']`) to avoid a load-segments\n  // module dependency.\n  const loadingSuspended = (state as { loadingSuspended?: ReadonlySignal<boolean | undefined> }).loadingSuspended;\n\n  // Close-fact for the currently-owned MediaSource, flipped by the\n  // entry's shared teardown. Consumed in `'preconditions-unmet'`.\n  const mediaSourceClosed = signal(false);\n\n  const derivedStateSignal = computed(() =>\n    deriveState(state.presentation.get(), context.mediaElement.get(), mediaSourceClosed.get())\n  );\n\n  return createMachineReactor<MediaSourceFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {\n        // Consume a recorded close once new loading work may initiate — the\n        // reset re-derives into `'mediasource-attached'`, rebuilding a fresh\n        // MediaSource for the same source. While an observed\n        // `loadingSuspended` holds, the fact stands and the rebuild waits:\n        // attaching runs `element.load()`, which is exactly the loading work\n        // the suspension forbids. Consuming only from this state means a\n        // suspension can never tear down an existing attachment — there is\n        // no code path from `loadingSuspended` to an exit.\n        effects: () => {\n          // `mediaSourceClosed` is tracked, not peeked: a new state's effects\n          // can run BEFORE the old state's exit cleanup (effects run in\n          // states-declaration order), so a teardown's fact-write can land\n          // after this effect's entry run — tracking re-fires the consume.\n          // Not suspended = slot absent (no writer composed) or value falsy.\n          if (mediaSourceClosed.get() && !loadingSuspended?.get()) mediaSourceClosed.set(false);\n        },\n      },\n\n      'mediasource-attached': {\n        // entry body is auto-untracked. deriveState handles source resets via\n        // the resolver's resolved/unresolved transitions; this entry creates\n        // and attaches the MediaSource, awaits `'open'`, publishes on\n        // context, and binds detach + slot clear to state exit + destroy.\n        entry: () => {\n          const mediaElement = context.mediaElement.get()!;\n          const controller = new AbortController();\n\n          const mediaSource = createMediaSource({ preferManaged: true });\n          // Sync attach: the returned `detach` closes over the element +\n          // object-URL captured at this moment, so state-exit cleanup tears\n          // down exactly this attachment regardless of how the wait below\n          // resolves.\n          const { detach } = attach(mediaSource, mediaElement);\n\n          // One complete teardown, shared by both triggers (the sourceclose\n          // listener below and the state-exit cleanup) — whichever fires\n          // first does the work; a re-run is harmless. Order matters:\n          //\n          // 1. Abort first — kills the open-wait and the listener, so a late\n          //    publish can't race the slot clear.\n          // 2. Clear the slot, which stops the downstream MSE pipeline and\n          //    dirties the effects of behaviors owning sibling `<source>`\n          //    children (`setupAirPlay`'s native-HLS fallback), queueing their\n          //    removal pass. Kept ahead of the detach so that queueing is\n          //    explicit: the `mediaSourceClosed` write above happens to queue\n          //    the same pass today, but depending on it would couple this to\n          //    an unrelated write.\n          // 3. Detach with `deferReset`, which queues detach's `load()` reset\n          //    behind that pass. A synchronous reset would run resource\n          //    selection while the fallback is still in the DOM and commit the\n          //    element to the outgoing manifest — starting native HLS playback\n          //    of the source being torn down. Removing our own `<source>`\n          //    doesn't re-run selection on its own, so nothing starts in the\n          //    gap. The ownership guard re-checks at fire time, so a re-attach\n          //    landing in between suppresses the reset.\n          const teardown = () => {\n            mediaSourceClosed.set(true);\n            controller.abort();\n            context.mediaSource.set(undefined);\n            detach({ deferReset: true });\n          };\n\n          // Sourceclose recovery: the UA closing this MediaSource (AirPlay\n          // handoff, MMS eviction) tears the attachment down synchronously —\n          // detach skips\n          // its `load()` reset for a closed MediaSource (see\n          // `attachMediaSource`), leaving the element as the session or\n          // eviction left it.\n          listen(mediaSource, 'sourceclose', teardown, { signal: controller.signal });\n\n          const publishWhenOpen = async () => {\n            await waitForMediaSourceOpen(mediaSource, controller.signal);\n\n            if (controller.signal.aborted) return;\n\n            // `waitForMediaSourceOpen` resolves on any readyState transition\n            // out of `'closed'`; if we landed in `'ended'` / `'closed'`\n            // instead of `'open'`, the attach window is gone and we leave\n            // the slot unpublished. The session is dead within this source\n            // either way — publishing wouldn't help because\n            // `setupVideoBufferActors` / `setupAudioBufferActors` calls\n            // `addSourceBuffer` which throws on non-open. The next\n            // source-reset re-enters this state with a fresh MediaSource\n            // and recovers. Warn so the case is at least diagnosable; in\n            // practice it requires the MediaSource to close/end before its\n            // very first `sourceopen`, which a freshly attached MS\n            // shouldn't do.\n            if (mediaSource.readyState !== 'open') {\n              console.warn(\n                `[setupMediaSource] MediaSource transitioned to '${mediaSource.readyState}' before first 'sourceopen' — slot left unpublished; recoverable on next source reset.`\n              );\n              return;\n            }\n\n            context.mediaSource.set(mediaSource);\n          };\n\n          publishWhenOpen().catch((err) => console.error('[setupMediaSource] failed to publish MediaSource:', err));\n\n          // State-exit cleanup — fires on source unload, element detach, or\n          // behavior destroy; a harmless re-run after a `sourceclose`\n          // already tore down.\n          return teardown;\n        },\n      },\n    },\n  });\n}\n\nexport const setupMediaSource = defineBehavior({\n  stateKeys: ['presentation'],\n  contextKeys: ['mediaElement', 'mediaSource'],\n  setup: setupMediaSourceSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEA,SAAS,YACP,cACA,cACA,mBACqB;CACrB,IAAI,CAAC,gBAAgB,CAAC,uBAAuB,YAAY,GAAG,OAAO;CAMnE,IAAI,mBAAmB,OAAO;CAE9B,OAAO;AACT;AAEA,SAAS,sBAAsB,EAC7B,OACA,SACA,SAAS,CAAC,KAUkD;CAC5D,MAAM,SAAS,OAAO,qBAAqB;CAQ3C,MAAM,mBAAoB,MAAqE;CAI/F,MAAM,oBAAoB,OAAO,KAAK;CAEtC,MAAM,qBAAqB,eACzB,YAAY,MAAM,aAAa,IAAI,GAAG,QAAQ,aAAa,IAAI,GAAG,kBAAkB,IAAI,CAAC,CAC3F;CAEA,OAAO,qBAA0C;EAC/C,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,EASrB,eAAe;IAMb,IAAI,kBAAkB,IAAI,KAAK,CAAC,kBAAkB,IAAI,GAAG,kBAAkB,IAAI,KAAK;GACtF,EACF;GAEA,wBAAwB,EAKtB,aAAa;IACX,MAAM,eAAe,QAAQ,aAAa,IAAI;IAC9C,MAAM,aAAa,IAAI,gBAAgB;IAEvC,MAAM,cAAc,kBAAkB,EAAE,eAAe,KAAK,CAAC;IAK7D,MAAM,EAAE,WAAW,OAAO,aAAa,YAAY;IAuBnD,MAAM,iBAAiB;KACrB,kBAAkB,IAAI,IAAI;KAC1B,WAAW,MAAM;KACjB,QAAQ,YAAY,IAAI,KAAA,CAAS;KACjC,OAAO,EAAE,YAAY,KAAK,CAAC;IAC7B;IAQA,OAAO,aAAa,eAAe,UAAU,EAAE,QAAQ,WAAW,OAAO,CAAC;IAE1E,MAAM,kBAAkB,YAAY;KAClC,MAAM,uBAAuB,aAAa,WAAW,MAAM;KAE3D,IAAI,WAAW,OAAO,SAAS;KAc/B,IAAI,YAAY,eAAe,QAAQ;MACrC,QAAQ,KACN,mDAAmD,YAAY,WAAW,uFAC5E;MACA;KACF;KAEA,QAAQ,YAAY,IAAI,WAAW;IACrC;IAEA,gBAAgB,CAAC,CAAC,OAAO,QAAQ,QAAQ,MAAM,qDAAqD,GAAG,CAAC;IAKxG,OAAO;GACT,EACF;EACF;CACF,CAAC;AACH;AAEA,MAAa,mBAAmB,eAAe;CAC7C,WAAW,CAAC,cAAc;CAC1B,aAAa,CAAC,gBAAgB,aAAa;CAC3C,OAAO;AACT,CAAC"}

package/dist/dev/playback/behaviors/dom/setup-text-track-actors.d.ts

@@ -12,9 +12,9 @@ interface TextTrackActorsContext {
 interface TextTrackActorsConfig extends Pick<TextTrackSegmentLoaderActorConfig<VTTCue>, 'forwardBuffer'> {
   resolveTextTrackSegment: TextTrackSegmentResolver<VTTCue>;
   /**
-   * Ordered text step pipeline, mapped to the loader's `messagePipelines`. Named
-   * with the `text` domain prefix to mirror the v/a `video`/`audioMessagePipelines`
-   * composition-config slots. Defaults (in the loader) to `resolveCues → dispatchCues`.
+   * Ordered text step pipeline, mapped to the loader's `messagePipelines`. Named with the `text` domain prefix to
+   * mirror the v/a `video`/`audioMessagePipelines` composition-config slots. Defaults (in the loader) to `resolveCues →
+   * dispatchCues`.
    */
   textMessagePipelines?: TextMessagePipelines<VTTCue>;
 }

package/dist/dev/playback/behaviors/dom/setup-text-track-actors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setup-text-track-actors.d.ts","names":[],"sources":["../../../../../src/playback/behaviors/dom/setup-text-track-actors.ts"],"mappings":";;;;;;UAgCiB;EACf,eAAe;EACf,kBAAkB,gBAAgB;EAClC,8BAA8B;;UAGf,8BAA8B,KAAK,kCAAkC;EACpF,yBAAyB,yBAAyB;;;;;;EAMlD,uBAAuB,qBAAqB;;cA8CjC,sBAAsB,SACjC;EAEE,cAAc,eAAe;EAC7B,iBAAiB,OAAO;EACxB,6BAA6B,OAAO;GAEtC"}
+{"version":3,"file":"setup-text-track-actors.d.ts","names":[],"sources":["../../../../../src/playback/behaviors/dom/setup-text-track-actors.ts"],"mappings":";;;;;;UA0BiB;EACf,eAAe;EACf,kBAAkB,gBAAgB;EAClC,8BAA8B;;UAGf,8BAA8B,KAAK,kCAAkC;EACpF,yBAAyB,yBAAyB;;;;;;EAMlD,uBAAuB,qBAAqB;;cA+CjC,sBAAsB,SACjC;EAEE,cAAc,eAAe;EAC7B,iBAAiB,OAAO;EACxB,6BAA6B,OAAO;GAEtC"}

package/dist/dev/playback/behaviors/dom/setup-text-track-actors.js.map

@@ -1 +1 @@
-{"version":3,"file":"setup-text-track-actors.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/setup-text-track-actors.ts"],"sourcesContent":["/**\n * **Own the TextTracks actor pair for the current `mediaElement`.** When a\n * `mediaElement` is in scope, creates the `TextTracksActor` (bound to the\n * element's `textTracks`) and the `TextTrackSegmentLoaderActor` (bound to\n * that actor + the injected cue resolver), and publishes both on\n * `context`. On element identity change or behavior destroy, destroys both\n * actors and clears the slots.\n *\n * Single-resource synchronous create/destroy driven by one signal — the\n * simple-effect form is the right shape (per `behaviors.md` → \"Where both\n * shapes are legitimate\": criterion 4b applies; sole writer of\n * `textTracksActor` / `textTrackSegmentLoaderActor`, the effect's cleanup\n * return handles destroy + slot clear structurally).\n *\n * Pairs with the `loadTextTrackSegments` behavior (a per-type variant of\n * `setupSegmentLoading` in `load-segments.ts`), which only reads\n * `textTrackSegmentLoaderActor`. The cue resolver is injected via\n * `config` so this behavior owns the DOM-bound part of the text-track\n * pipeline.\n */\nimport type { AnySlotMap, Behavior } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport type { ReadonlySignal, Signal } from '../../../core/signals/primitives';\nimport { createTextTracksActor } from '../../actors/dom/text-tracks';\nimport {\n  createTextTrackSegmentLoaderActor,\n  type TextTrackSegmentLoaderActor,\n  type TextTrackSegmentLoaderActorConfig,\n} from '../../actors/text-track-segment-loader';\nimport type { TextTracksActor } from '../../actors/text-tracks';\nimport type { TextMessagePipelines, TextTrackSegmentResolver } from '../../primitives/text-segment-load-pipeline';\n\nexport interface TextTrackActorsContext {\n  mediaElement?: HTMLMediaElement | undefined;\n  textTracksActor?: TextTracksActor<VTTCue> | undefined;\n  textTrackSegmentLoaderActor?: TextTrackSegmentLoaderActor | undefined;\n}\n\nexport interface TextTrackActorsConfig extends Pick<TextTrackSegmentLoaderActorConfig<VTTCue>, 'forwardBuffer'> {\n  resolveTextTrackSegment: TextTrackSegmentResolver<VTTCue>;\n  /**\n   * Ordered text step pipeline, mapped to the loader's `messagePipelines`. Named\n   * with the `text` domain prefix to mirror the v/a `video`/`audioMessagePipelines`\n   * composition-config slots. Defaults (in the loader) to `resolveCues → dispatchCues`.\n   */\n  textMessagePipelines?: TextMessagePipelines<VTTCue>;\n}\n\nfunction setupTextTrackActorsSetup({\n  state,\n  context,\n  config,\n}: {\n  // Forwarded opaquely into the loader's steps (relocation reads composition state);\n  // this behavior owns no state of its own (stateKeys: []).\n  state: AnySlotMap;\n  context: {\n    mediaElement: ReadonlySignal<TextTrackActorsContext['mediaElement']>;\n    textTracksActor: Signal<TextTrackActorsContext['textTracksActor']>;\n    textTrackSegmentLoaderActor: Signal<TextTrackActorsContext['textTrackSegmentLoaderActor']>;\n  };\n  config: TextTrackActorsConfig;\n}): () => void {\n  return effect(() => {\n    const mediaElement = context.mediaElement.get();\n    if (!mediaElement) return;\n\n    const textTracksActor = createTextTracksActor(mediaElement);\n    const textTrackSegmentLoaderActor = createTextTrackSegmentLoaderActor(\n      textTracksActor,\n      config.resolveTextTrackSegment,\n      { forwardBuffer: config.forwardBuffer, messagePipelines: config.textMessagePipelines },\n      // Composition deps forwarded into each step (relocation reads the primary A/V origin).\n      { state, context, config }\n    );\n    context.textTracksActor.set(textTracksActor);\n    context.textTrackSegmentLoaderActor.set(textTrackSegmentLoaderActor);\n\n    return () => {\n      textTracksActor.destroy();\n      textTrackSegmentLoaderActor.destroy();\n      context.textTracksActor.set(undefined);\n      context.textTrackSegmentLoaderActor.set(undefined);\n    };\n  });\n}\n\n// Manual `Behavior` literal (like `end-of-stream`): no state of its own\n// (`stateKeys: []`), but the setup forwards the composition `state` to the resolver\n// opaquely. A literal (not `defineBehavior`) so `stateKeys: []` can coexist with a\n// setup that reads `state`.\nexport const setupTextTrackActors: Behavior<\n  Record<never, never>,\n  {\n    mediaElement: ReadonlySignal<TextTrackActorsContext['mediaElement']>;\n    textTracksActor: Signal<TextTrackActorsContext['textTracksActor']>;\n    textTrackSegmentLoaderActor: Signal<TextTrackActorsContext['textTrackSegmentLoaderActor']>;\n  },\n  TextTrackActorsConfig\n> = {\n  stateKeys: [],\n  contextKeys: ['mediaElement', 'textTracksActor', 'textTrackSegmentLoaderActor'],\n  setup: setupTextTrackActorsSetup,\n};\n"],"mappings":";;;;AAgDA,SAAS,0BAA0B,EACjC,OACA,SACA,UAWa;CACb,OAAO,aAAa;EAClB,MAAM,eAAe,QAAQ,aAAa,IAAI;EAC9C,IAAI,CAAC,cAAc;EAEnB,MAAM,kBAAkB,sBAAsB,YAAY;EAC1D,MAAM,8BAA8B,kCAClC,iBACA,OAAO,yBACP;GAAE,eAAe,OAAO;GAAe,kBAAkB,OAAO;EAAqB,GAErF;GAAE;GAAO;GAAS;EAAO,CAC3B;EACA,QAAQ,gBAAgB,IAAI,eAAe;EAC3C,QAAQ,4BAA4B,IAAI,2BAA2B;EAEnE,aAAa;GACX,gBAAgB,QAAQ;GACxB,4BAA4B,QAAQ;GACpC,QAAQ,gBAAgB,IAAI,KAAA,CAAS;GACrC,QAAQ,4BAA4B,IAAI,KAAA,CAAS;EACnD;CACF,CAAC;AACH;AAMA,MAAa,uBAQT;CACF,WAAW,CAAC;CACZ,aAAa;EAAC;EAAgB;EAAmB;CAA6B;CAC9E,OAAO;AACT"}
+{"version":3,"file":"setup-text-track-actors.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/setup-text-track-actors.ts"],"sourcesContent":["/**\n * **Own the TextTracks actor pair for the current `mediaElement`.** When a `mediaElement` is in scope, creates the\n * `TextTracksActor` (bound to the element's `textTracks`) and the `TextTrackSegmentLoaderActor` (bound to that actor +\n * the injected cue resolver), and publishes both on `context`. On element identity change or behavior destroy, destroys\n * both actors and clears the slots.\n *\n * Single-resource synchronous create/destroy driven by one signal — the simple-effect form is the right shape (per\n * `behaviors.md` → \"Where both shapes are legitimate\": criterion 4b applies; sole writer of `textTracksActor` /\n * `textTrackSegmentLoaderActor`, the effect's cleanup return handles destroy + slot clear structurally).\n *\n * Pairs with the `loadTextTrackSegments` behavior (a per-type variant of `setupSegmentLoading` in `load-segments.ts`),\n * which only reads `textTrackSegmentLoaderActor`. The cue resolver is injected via `config` so this behavior owns the\n * DOM-bound part of the text-track pipeline.\n */\nimport type { AnySlotMap, Behavior } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport type { ReadonlySignal, Signal } from '../../../core/signals/primitives';\nimport { createTextTracksActor } from '../../actors/dom/text-tracks';\nimport {\n  createTextTrackSegmentLoaderActor,\n  type TextTrackSegmentLoaderActor,\n  type TextTrackSegmentLoaderActorConfig,\n} from '../../actors/text-track-segment-loader';\nimport type { TextTracksActor } from '../../actors/text-tracks';\nimport type { TextMessagePipelines, TextTrackSegmentResolver } from '../../primitives/text-segment-load-pipeline';\n\nexport interface TextTrackActorsContext {\n  mediaElement?: HTMLMediaElement | undefined;\n  textTracksActor?: TextTracksActor<VTTCue> | undefined;\n  textTrackSegmentLoaderActor?: TextTrackSegmentLoaderActor | undefined;\n}\n\nexport interface TextTrackActorsConfig extends Pick<TextTrackSegmentLoaderActorConfig<VTTCue>, 'forwardBuffer'> {\n  resolveTextTrackSegment: TextTrackSegmentResolver<VTTCue>;\n  /**\n   * Ordered text step pipeline, mapped to the loader's `messagePipelines`. Named with the `text` domain prefix to\n   * mirror the v/a `video`/`audioMessagePipelines` composition-config slots. Defaults (in the loader) to `resolveCues →\n   * dispatchCues`.\n   */\n  textMessagePipelines?: TextMessagePipelines<VTTCue>;\n}\n\nfunction setupTextTrackActorsSetup({\n  state,\n  context,\n  config,\n}: {\n  // Forwarded opaquely into the loader's steps (relocation reads composition state);\n  // this behavior owns no state of its own (stateKeys: []).\n  state: AnySlotMap;\n  context: {\n    mediaElement: ReadonlySignal<TextTrackActorsContext['mediaElement']>;\n    textTracksActor: Signal<TextTrackActorsContext['textTracksActor']>;\n    textTrackSegmentLoaderActor: Signal<TextTrackActorsContext['textTrackSegmentLoaderActor']>;\n  };\n  config: TextTrackActorsConfig;\n}): () => void {\n  return effect(() => {\n    const mediaElement = context.mediaElement.get();\n    if (!mediaElement) return;\n\n    const textTracksActor = createTextTracksActor(mediaElement);\n    const textTrackSegmentLoaderActor = createTextTrackSegmentLoaderActor(\n      textTracksActor,\n      config.resolveTextTrackSegment,\n      { forwardBuffer: config.forwardBuffer, messagePipelines: config.textMessagePipelines },\n      // Composition deps forwarded into each step (relocation reads the primary A/V origin).\n      { state, context, config }\n    );\n\n    context.textTracksActor.set(textTracksActor);\n    context.textTrackSegmentLoaderActor.set(textTrackSegmentLoaderActor);\n\n    return () => {\n      textTracksActor.destroy();\n      textTrackSegmentLoaderActor.destroy();\n      context.textTracksActor.set(undefined);\n      context.textTrackSegmentLoaderActor.set(undefined);\n    };\n  });\n}\n\n// Manual `Behavior` literal (like `end-of-stream`): no state of its own\n// (`stateKeys: []`), but the setup forwards the composition `state` to the resolver\n// opaquely. A literal (not `defineBehavior`) so `stateKeys: []` can coexist with a\n// setup that reads `state`.\nexport const setupTextTrackActors: Behavior<\n  Record<never, never>,\n  {\n    mediaElement: ReadonlySignal<TextTrackActorsContext['mediaElement']>;\n    textTracksActor: Signal<TextTrackActorsContext['textTracksActor']>;\n    textTrackSegmentLoaderActor: Signal<TextTrackActorsContext['textTrackSegmentLoaderActor']>;\n  },\n  TextTrackActorsConfig\n> = {\n  stateKeys: [],\n  contextKeys: ['mediaElement', 'textTracksActor', 'textTrackSegmentLoaderActor'],\n  setup: setupTextTrackActorsSetup,\n};\n"],"mappings":";;;;AA0CA,SAAS,0BAA0B,EACjC,OACA,SACA,UAWa;CACb,OAAO,aAAa;EAClB,MAAM,eAAe,QAAQ,aAAa,IAAI;EAC9C,IAAI,CAAC,cAAc;EAEnB,MAAM,kBAAkB,sBAAsB,YAAY;EAC1D,MAAM,8BAA8B,kCAClC,iBACA,OAAO,yBACP;GAAE,eAAe,OAAO;GAAe,kBAAkB,OAAO;EAAqB,GAErF;GAAE;GAAO;GAAS;EAAO,CAC3B;EAEA,QAAQ,gBAAgB,IAAI,eAAe;EAC3C,QAAQ,4BAA4B,IAAI,2BAA2B;EAEnE,aAAa;GACX,gBAAgB,QAAQ;GACxB,4BAA4B,QAAQ;GACpC,QAAQ,gBAAgB,IAAI,KAAA,CAAS;GACrC,QAAQ,4BAA4B,IAAI,KAAA,CAAS;EACnD;CACF,CAAC;AACH;AAMA,MAAa,uBAQT;CACF,WAAW,CAAC;CACZ,aAAa;EAAC;EAAgB;EAAmB;CAA6B;CAC9E,OAAO;AACT"}

package/dist/dev/playback/behaviors/dom/sync-live-seekable-range.js

@@ -10,10 +10,9 @@ function syncLiveSeekableRangeSetup({ state, context }) {
 	});
 }
 /**
-* Manual `Behavior<>` literal (like `seekToLiveEdge`): declares only
-* `presentation` in stateKeys while reading `selectedVideoTrackId` /
-* `selectedAudioTrackId` defensively (contributed by the switch* behaviors), so
-* it composes without a stateKeys/type conflict.
+* Manual `Behavior<>` literal (like `seekToLiveEdge`): declares only `presentation` in stateKeys while reading
+* `selectedVideoTrackId` / `selectedAudioTrackId` defensively (contributed by the switch* behaviors), so it composes
+* without a stateKeys/type conflict.
 */
 const syncLiveSeekableRange = {
 	stateKeys: ["presentation"],

package/dist/dev/playback/behaviors/dom/sync-live-seekable-range.js.map

@@ -1 +1 @@
-{"version":3,"file":"sync-live-seekable-range.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/sync-live-seekable-range.ts"],"sourcesContent":["/**\n * Mirror the live window into the MediaSource's seekable range. On every\n * window update — **including while paused** (the seekable range must stay\n * current as the window slides, regardless of play state) — declare\n * `setLiveSeekableRange(start, end)` so the browser's `HTMLMediaElement.seekable`\n * reflects the live window (without it, `seekable` is empty under\n * `duration === Infinity`).\n *\n * The live window comes from `liveWindowFromState` (the shared derivation —\n * the intersection over the selected A/V tracks' windows); inert when it\n * returns `null` (VoD / ended live). Composed *before* `seekToLiveEdge`\n * so the range is declared before that behavior seeks the playhead into it (a\n * seek outside `seekable` is clamped).\n *\n * Duration is owned solely by `updateMediaSourceDuration`; this behavior only\n * declares the seekable range (`setLiveSeekableRange` requires only\n * `readyState === 'open'` per the W3C MSE spec, not a set `duration`).\n *\n * No `clearLiveSeekableRange()` on termination, by design: the MSE spec consults\n * the live seekable range *only* while `duration === Infinity`. When a live\n * stream ends, `endOfStream()` sets a finite duration and the UA derives\n * `seekable` from buffered + duration, ignoring the live range — so clearing is\n * unnecessary. Clearing on the `ENDLIST`→finite-`Track.duration` transition\n * (when the window goes `null`) would also be premature: `duration` is still\n * `Infinity` until `endOfStream`, so clearing would shrink `seekable` to\n * buffered-only while the stream is still effectively live.\n */\nimport type { Behavior } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport type { ReadonlySignal } from '../../../core/signals/primitives';\nimport type { MaybeResolvedPresentation } from '../../../media/types';\nimport { liveWindowFromState } from '../../primitives/live-window';\n\nexport interface SyncLiveSeekableRangeState {\n  presentation?: MaybeResolvedPresentation;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n}\n\nexport interface SyncLiveSeekableRangeContext {\n  mediaSource?: MediaSource;\n}\n\nfunction syncLiveSeekableRangeSetup({\n  state,\n  context,\n}: {\n  state: {\n    presentation: ReadonlySignal<SyncLiveSeekableRangeState['presentation']>;\n    selectedVideoTrackId?: ReadonlySignal<SyncLiveSeekableRangeState['selectedVideoTrackId']>;\n    selectedAudioTrackId?: ReadonlySignal<SyncLiveSeekableRangeState['selectedAudioTrackId']>;\n  };\n  context: {\n    mediaSource: ReadonlySignal<SyncLiveSeekableRangeContext['mediaSource']>;\n  };\n}): () => void {\n  return effect(() => {\n    const mediaSource = context.mediaSource.get();\n    const liveWindow = liveWindowFromState(state);\n    if (!mediaSource || !liveWindow) return;\n\n    // Re-declared as the window slides so seekable tracks the live window\n    // (the full DVR range remains seekable; seek-to-live-edge starts near the edge).\n    // No readyState check, no try/catch: `setLiveSeekableRange` throws only on a\n    // non-'open' readyState or an invalid range, and neither can occur here —\n    // `setupMediaSource` publishes `context.mediaSource` only while open, and a\n    // non-null live window means the timeline-bearing track is still `Infinity`\n    // (so `endOfStream` hasn't ended the MS); `liveWindowFromState` guarantees\n    // 0 ≤ start < end (the reference type's window starts ≥ 0, and the A/V\n    // intersection `max`-clamps a non-reference track's negative early start).\n    mediaSource.setLiveSeekableRange(liveWindow.start, liveWindow.end);\n  });\n}\n\n/**\n * Manual `Behavior<>` literal (like `seekToLiveEdge`): declares only\n * `presentation` in stateKeys while reading `selectedVideoTrackId` /\n * `selectedAudioTrackId` defensively (contributed by the switch* behaviors), so\n * it composes without a stateKeys/type conflict.\n */\nexport const syncLiveSeekableRange: Behavior<\n  { presentation: ReadonlySignal<SyncLiveSeekableRangeState['presentation']> },\n  { mediaSource: ReadonlySignal<SyncLiveSeekableRangeContext['mediaSource']> },\n  object\n> = {\n  stateKeys: ['presentation'],\n  contextKeys: ['mediaSource'],\n  setup: syncLiveSeekableRangeSetup,\n};\n"],"mappings":";;;AA2CA,SAAS,2BAA2B,EAClC,OACA,WAUa;CACb,OAAO,aAAa;EAClB,MAAM,cAAc,QAAQ,YAAY,IAAI;EAC5C,MAAM,aAAa,oBAAoB,KAAK;EAC5C,IAAI,CAAC,eAAe,CAAC,YAAY;EAWjC,YAAY,qBAAqB,WAAW,OAAO,WAAW,GAAG;CACnE,CAAC;AACH;;;;;;;AAQA,MAAa,wBAIT;CACF,WAAW,CAAC,cAAc;CAC1B,aAAa,CAAC,aAAa;CAC3B,OAAO;AACT"}
+{"version":3,"file":"sync-live-seekable-range.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/sync-live-seekable-range.ts"],"sourcesContent":["/**\n * Mirror the live window into the MediaSource's seekable range. On every window update — **including while paused**\n * (the seekable range must stay current as the window slides, regardless of play state) — declare\n * `setLiveSeekableRange(start, end)` so the browser's `HTMLMediaElement.seekable` reflects the live window (without it,\n * `seekable` is empty under `duration === Infinity`).\n *\n * The live window comes from `liveWindowFromState` (the shared derivation — the intersection over the selected A/V\n * tracks' windows); inert when it returns `null` (VoD / ended live). Composed _before_ `seekToLiveEdge` so the range is\n * declared before that behavior seeks the playhead into it (a seek outside `seekable` is clamped).\n *\n * Duration is owned solely by `updateMediaSourceDuration`; this behavior only declares the seekable range\n * (`setLiveSeekableRange` requires only `readyState === 'open'` per the W3C MSE spec, not a set `duration`).\n *\n * No `clearLiveSeekableRange()` on termination, by design: the MSE spec consults the live seekable range _only_ while\n * `duration === Infinity`. When a live stream ends, `endOfStream()` sets a finite duration and the UA derives\n * `seekable` from buffered + duration, ignoring the live range — so clearing is unnecessary. Clearing on the\n * `ENDLIST`→finite-`Track.duration` transition (when the window goes `null`) would also be premature: `duration` is\n * still `Infinity` until `endOfStream`, so clearing would shrink `seekable` to buffered-only while the stream is still\n * effectively live.\n */\nimport type { Behavior } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport type { ReadonlySignal } from '../../../core/signals/primitives';\nimport type { MaybeResolvedPresentation } from '../../../media/types';\nimport { liveWindowFromState } from '../../primitives/live-window';\n\nexport interface SyncLiveSeekableRangeState {\n  presentation?: MaybeResolvedPresentation;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n}\n\nexport interface SyncLiveSeekableRangeContext {\n  mediaSource?: MediaSource;\n}\n\nfunction syncLiveSeekableRangeSetup({\n  state,\n  context,\n}: {\n  state: {\n    presentation: ReadonlySignal<SyncLiveSeekableRangeState['presentation']>;\n    selectedVideoTrackId?: ReadonlySignal<SyncLiveSeekableRangeState['selectedVideoTrackId']>;\n    selectedAudioTrackId?: ReadonlySignal<SyncLiveSeekableRangeState['selectedAudioTrackId']>;\n  };\n  context: {\n    mediaSource: ReadonlySignal<SyncLiveSeekableRangeContext['mediaSource']>;\n  };\n}): () => void {\n  return effect(() => {\n    const mediaSource = context.mediaSource.get();\n    const liveWindow = liveWindowFromState(state);\n    if (!mediaSource || !liveWindow) return;\n\n    // Re-declared as the window slides so seekable tracks the live window\n    // (the full DVR range remains seekable; seek-to-live-edge starts near the edge).\n    // No readyState check, no try/catch: `setLiveSeekableRange` throws only on a\n    // non-'open' readyState or an invalid range, and neither can occur here —\n    // `setupMediaSource` publishes `context.mediaSource` only while open, and a\n    // non-null live window means the timeline-bearing track is still `Infinity`\n    // (so `endOfStream` hasn't ended the MS); `liveWindowFromState` guarantees\n    // 0 ≤ start < end (the reference type's window starts ≥ 0, and the A/V\n    // intersection `max`-clamps a non-reference track's negative early start).\n    mediaSource.setLiveSeekableRange(liveWindow.start, liveWindow.end);\n  });\n}\n\n/**\n * Manual `Behavior<>` literal (like `seekToLiveEdge`): declares only `presentation` in stateKeys while reading\n * `selectedVideoTrackId` / `selectedAudioTrackId` defensively (contributed by the switch* behaviors), so it composes\n * without a stateKeys/type conflict.\n */\nexport const syncLiveSeekableRange: Behavior<\n  { presentation: ReadonlySignal<SyncLiveSeekableRangeState['presentation']> },\n  { mediaSource: ReadonlySignal<SyncLiveSeekableRangeContext['mediaSource']> },\n  object\n> = {\n  stateKeys: ['presentation'],\n  contextKeys: ['mediaSource'],\n  setup: syncLiveSeekableRangeSetup,\n};\n"],"mappings":";;;AAoCA,SAAS,2BAA2B,EAClC,OACA,WAUa;CACb,OAAO,aAAa;EAClB,MAAM,cAAc,QAAQ,YAAY,IAAI;EAC5C,MAAM,aAAa,oBAAoB,KAAK;EAC5C,IAAI,CAAC,eAAe,CAAC,YAAY;EAWjC,YAAY,qBAAqB,WAAW,OAAO,WAAW,GAAG;CACnE,CAAC;AACH;;;;;;AAOA,MAAa,wBAIT;CACF,WAAW,CAAC,cAAc;CAC1B,aAAa,CAAC,aAAa;CAC3B,OAAO;AACT"}

package/dist/dev/playback/behaviors/dom/sync-text-tracks.js

@@ -6,60 +6,44 @@ import { syncTextTrackModes } from "../../../media/dom/text/text-track-slots.js"
 import { listen } from "@videojs/utils/dom";
 //#region src/playback/behaviors/dom/sync-text-tracks.ts
 /**
-* **Own the text-track slots on the host media element, mirroring the SPF
-* model.** When a presentation is resolved and a media element is
-* available, allocate one slot in `mediaElement.textTracks` per model text
-* track — via creating `<track>` children, since that's the only spec
-* mechanism for adding *and* removing entries to `textTracks` (no
-* `removeTextTrack` API exists). Once slots are provisioned, mirror the
-* resolved `selectedTextTrackId` into their `mode`s (one-way: state → DOM),
-* and propagate user-initiated DOM `change` events back to
-* `userTextTrackSelection` — the standing *intent* (a language-based partial,
-* or `'off'`) that `switchTextTrack` resolves into `selectedTextTrackId`. So
-* non-SPF consumers (host-page captions buttons, browser native UI, video.js
-* store) drive selection by expressing intent, not by writing the resolved id.
+* **Own the text-track slots on the host media element, mirroring the SPF model.** When a presentation is resolved and
+* a media element is available, allocate one slot in `mediaElement.textTracks` per model text track — via creating
+* `<track>` children, since that's the only spec mechanism for adding _and_ removing entries to `textTracks` (no
+* `removeTextTrack` API exists). Once slots are provisioned, mirror the resolved `selectedTextTrackId` into their
+* `mode`s (one-way: state → DOM), and propagate user-initiated DOM `change` events back to `userTextTrackSelection` —
+* the standing _intent_ (a language-based partial, or `'off'`) that `switchTextTrack` resolves into
+* `selectedTextTrackId`. So non-SPF consumers (host-page captions buttons, browser native UI, video.js store) drive
+* selection by expressing intent, not by writing the resolved id.
 *
-* Single-positive-state reactor (`'preconditions-unmet'` ↔ `'sync-active'`):
-* the entry allocates the slots, applies the initial selection, attaches
-* the `change` listener, and opens a brief Chromium settling-window guard —
-* all transition-driven, fire-once on state entry, with paired cleanup on
-* state exit. A single `effects:` mirrors subsequent
-* `selectedTextTrackId` changes into `mode`s; that's the only
-* continuous-reactivity concern.
+* Single-positive-state reactor (`'preconditions-unmet'` ↔ `'sync-active'`): the entry allocates the slots, applies the
+* initial selection, attaches the `change` listener, and opens a brief Chromium settling-window guard — all
+* transition-driven, fire-once on state entry, with paired cleanup on state exit. A single `effects:` mirrors
+* subsequent `selectedTextTrackId` changes into `mode`s; that's the only continuous-reactivity concern.
 *
-* State-exit cleanup also sends a `'clear'` message to the
-* `TextTracksActor` so its cue+segment cache (keyed by trackId) is
-* dropped alongside the DOM `<track>` slots. The actor itself is owned
-* by `setupTextTrackActors` and bound to mediaElement, not presentation,
-* so it survives source resets; clearing its context here keeps the
-* cache consistent with the DOM. Without this, a subsequent
-* presentation reusing a trackId would have `getSegmentsToLoad` treat
-* its segments as already-buffered and skip loading them.
+* State-exit cleanup also sends a `'clear'` message to the `TextTracksActor` so its cue+segment cache (keyed by
+* trackId) is dropped alongside the DOM `<track>` slots. The actor itself is owned by `setupTextTrackActors` and bound
+* to mediaElement, not presentation, so it survives source resets; clearing its context here keeps the cache consistent
+* with the DOM. Without this, a subsequent presentation reusing a trackId would have `getSegmentsToLoad` treat its
+* segments as already-buffered and skip loading them.
 *
-* Single-writer separation: `selectedTextTrackId` is the resolved *output*
-* owned solely by `switchTextTrack`; this behavior only reads it (to mirror
-* modes). The write path here is `userTextTrackSelection` — the user-intent
-* *input* — so DOM action and the resolver never contend for one slot. The
-* intent isn't cleared on source unload (it's a standing preference, like
-* `userAudioTrackSelection`); `'off'` is written when the user disables all
-* tracks via native UI.
+* Single-writer separation: `selectedTextTrackId` is the resolved _output_ owned solely by `switchTextTrack`; this
+* behavior only reads it (to mirror modes). The write path here is `userTextTrackSelection` — the user-intent _input_ —
+* so DOM action and the resolver never contend for one slot. The intent isn't cleared on source unload (it's a standing
+* preference, like `userAudioTrackSelection`); `'off'` is written when the user disables all tracks via native UI.
 *
-* Echo guard: `selectedTextTrackId` is exactly the id this behavior last drove
-* into the DOM, so a `change` event still showing it is our own echo (or a
-* resolver-driven correction — e.g. the picked track's CDN failed and the
-* resolver disabled it) and is ignored, never written back as a spurious user
-* action. Only a showing id that *differs* from the resolved id is a real user
-* pick. The settling-window guard additionally swallows Chromium's init-time
-* auto-selection before the resolved selection has settled.
+* Echo guard: `selectedTextTrackId` is exactly the id this behavior last drove into the DOM, so a `change` event still
+* showing it is our own echo (or a resolver-driven correction — e.g. the picked track's CDN failed and the resolver
+* disabled it) and is ignored, never written back as a spurious user action. Only a showing id that _differs_ from the
+* resolved id is a real user pick. The settling-window guard additionally swallows Chromium's init-time auto-selection
+* before the resolved selection has settled.
 */
 function deriveState(presentation, mediaElement) {
 	if (!mediaElement || !presentation) return "preconditions-unmet";
 	return getTracksByType(presentation, "text").length > 0 ? "sync-active" : "preconditions-unmet";
 }
 /**
-* Map the DOM-showing track back to standing user intent. No showing track is an
-* explicit `'off'`. Otherwise prefer a language-based partial (so the pick
-* persists across source changes); fall back to `{ id }` for a track without a
+* Map the DOM-showing track back to standing user intent. No showing track is an explicit `'off'`. Otherwise prefer a
+* language-based partial (so the pick persists across source changes); fall back to `{ id }` for a track without a
 * language (precise within a source, just not portable).
 */
 function deriveTextTrackIntent(showingId, modelTextTracks) {
@@ -103,7 +87,8 @@ function syncTextTracksSetup({ state, context, config }) {
 					};
 				},
 				effects: () => {
-					syncTextTrackModes(peek(context.mediaElement).textTracks, state.selectedTextTrackId.get());
+					const mediaElement = peek(context.mediaElement);
+					syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());
 				}
 			}
 		}

package/dist/dev/playback/behaviors/dom/sync-text-tracks.js.map

@@ -1 +1 @@
-{"version":3,"file":"sync-text-tracks.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/sync-text-tracks.ts"],"sourcesContent":["/**\n * **Own the text-track slots on the host media element, mirroring the SPF\n * model.** When a presentation is resolved and a media element is\n * available, allocate one slot in `mediaElement.textTracks` per model text\n * track — via creating `<track>` children, since that's the only spec\n * mechanism for adding *and* removing entries to `textTracks` (no\n * `removeTextTrack` API exists). Once slots are provisioned, mirror the\n * resolved `selectedTextTrackId` into their `mode`s (one-way: state → DOM),\n * and propagate user-initiated DOM `change` events back to\n * `userTextTrackSelection` — the standing *intent* (a language-based partial,\n * or `'off'`) that `switchTextTrack` resolves into `selectedTextTrackId`. So\n * non-SPF consumers (host-page captions buttons, browser native UI, video.js\n * store) drive selection by expressing intent, not by writing the resolved id.\n *\n * Single-positive-state reactor (`'preconditions-unmet'` ↔ `'sync-active'`):\n * the entry allocates the slots, applies the initial selection, attaches\n * the `change` listener, and opens a brief Chromium settling-window guard —\n * all transition-driven, fire-once on state entry, with paired cleanup on\n * state exit. A single `effects:` mirrors subsequent\n * `selectedTextTrackId` changes into `mode`s; that's the only\n * continuous-reactivity concern.\n *\n * State-exit cleanup also sends a `'clear'` message to the\n * `TextTracksActor` so its cue+segment cache (keyed by trackId) is\n * dropped alongside the DOM `<track>` slots. The actor itself is owned\n * by `setupTextTrackActors` and bound to mediaElement, not presentation,\n * so it survives source resets; clearing its context here keeps the\n * cache consistent with the DOM. Without this, a subsequent\n * presentation reusing a trackId would have `getSegmentsToLoad` treat\n * its segments as already-buffered and skip loading them.\n *\n * Single-writer separation: `selectedTextTrackId` is the resolved *output*\n * owned solely by `switchTextTrack`; this behavior only reads it (to mirror\n * modes). The write path here is `userTextTrackSelection` — the user-intent\n * *input* — so DOM action and the resolver never contend for one slot. The\n * intent isn't cleared on source unload (it's a standing preference, like\n * `userAudioTrackSelection`); `'off'` is written when the user disables all\n * tracks via native UI.\n *\n * Echo guard: `selectedTextTrackId` is exactly the id this behavior last drove\n * into the DOM, so a `change` event still showing it is our own echo (or a\n * resolver-driven correction — e.g. the picked track's CDN failed and the\n * resolver disabled it) and is ignored, never written back as a spurious user\n * action. Only a showing id that *differs* from the resolved id is a real user\n * pick. The settling-window guard additionally swallows Chromium's init-time\n * auto-selection before the resolved selection has settled.\n */\n\nimport { listen } from '@videojs/utils/dom';\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, peek, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';\nimport { syncTextTrackModes } from '../../../media/dom/text/text-track-slots';\nimport type { MaybeResolvedPresentation, PartiallyResolvedTextTrack, TextTrack } from '../../../media/types';\nimport { getTracksByType } from '../../../media/utils/tracks';\nimport type { TextTracksActor } from '../../actors/text-tracks';\n\ntype SyncTextTracksFsmState = 'preconditions-unmet' | 'sync-active';\n\nexport interface SyncTextTracksConfig {\n  /**\n   * Create and append SPF-owned `<track>` slots on `mediaElement`, one per\n   * model text track. Implementation tags each element so the read/remove\n   * helpers can scope to SPF-owned slots. **Required** — the behavior is\n   * DOM-binding-neutral and the composing engine supplies the integration.\n   */\n  addSubtitlesTracksToMedia: (\n    mediaElement: HTMLMediaElement,\n    modelTextTracks: readonly (PartiallyResolvedTextTrack | TextTrack)[]\n  ) => void;\n  /**\n   * Return the SPF-owned subtitle/caption `TextTrack` currently in `'showing'`\n   * mode, or `undefined` if none. Used by the DOM `change` bridge to mirror\n   * native-UI selection back into `selectedTextTrackId`.\n   */\n  getShowingSubtitlesTrackFromMedia: (mediaElement: HTMLMediaElement) => globalThis.TextTrack | undefined;\n  /**\n   * Remove every SPF-owned `<track>` child from `mediaElement`. Called on\n   * state exit (source unload, behavior destroy) to evict slots.\n   */\n  removeAllSubtitlesTracksFromMedia: (mediaElement: HTMLMediaElement) => void;\n}\n\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaElement: HTMLMediaElement | undefined\n): SyncTextTracksFsmState {\n  if (!mediaElement || !presentation) return 'preconditions-unmet';\n  return getTracksByType(presentation, 'text').length > 0 ? 'sync-active' : 'preconditions-unmet';\n}\n\n/**\n * Map the DOM-showing track back to standing user intent. No showing track is an\n * explicit `'off'`. Otherwise prefer a language-based partial (so the pick\n * persists across source changes); fall back to `{ id }` for a track without a\n * language (precise within a source, just not portable).\n */\nfunction deriveTextTrackIntent(\n  showingId: string | undefined,\n  modelTextTracks: readonly (PartiallyResolvedTextTrack | TextTrack)[]\n): Partial<TextTrack> | 'off' {\n  if (!showingId) return 'off';\n  const language = modelTextTracks.find((track) => track.id === showingId)?.language;\n  return language ? { language } : { id: showingId };\n}\n\nfunction syncTextTracksSetup({\n  state,\n  context,\n  config,\n}: {\n  state: {\n    presentation: ReadonlySignal<MaybeResolvedPresentation | undefined>;\n    // Read-only here: the resolved output owned by `switchTextTrack`, mirrored\n    // into DOM modes and used as the echo-guard reference.\n    selectedTextTrackId: ReadonlySignal<string | undefined>;\n    // The write path: standing user intent the DOM bridge feeds.\n    userTextTrackSelection: Signal<Partial<TextTrack> | 'off' | undefined>;\n  };\n  context: {\n    mediaElement: ReadonlySignal<HTMLMediaElement | undefined>;\n    textTracksActor: ReadonlySignal<TextTracksActor<VTTCue> | undefined>;\n  };\n  config: SyncTextTracksConfig;\n}): Reactor<SyncTextTracksFsmState | 'destroying' | 'destroyed'> {\n  const { addSubtitlesTracksToMedia, getShowingSubtitlesTrackFromMedia, removeAllSubtitlesTracksFromMedia } = config;\n\n  const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaElement.get()));\n\n  return createMachineReactor<SyncTextTracksFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'sync-active': {\n        // Allocate slots, apply the initial selection, attach the change\n        // listener, and open the settling window — all transition-driven\n        // (fire once per state entry). Entry is auto-untracked, so `.get()`\n        // here doesn't subscribe; the returned cleanup detaches and evicts\n        // on state exit (src reset through 'preconditions-unmet') and on\n        // destroy.\n        entry: () => {\n          const mediaElement = context.mediaElement.get()!;\n          // `getTracksByType('text', ...)` returns text tracks only — the\n          // selection-set filter inside the helper ensures that — but its\n          // declared return is the wide track union. Mirror the cast\n          // pattern used by `track-switching` for the video branch.\n          const modelTextTracks = getTracksByType(state.presentation.get()!, 'text') as readonly (\n            | PartiallyResolvedTextTrack\n            | TextTrack\n          )[];\n\n          addSubtitlesTracksToMedia(mediaElement, modelTextTracks);\n          // Apply our selection synchronously so the change-event tasks\n          // these mode writes queue land in the macrotask queue *before*\n          // the settling-close `setTimeout(0)` queued below. This keeps\n          // the settling window open long enough to swallow Chromium's\n          // own auto-selection task (also scheduled in the next tick after\n          // `<track>` insertion); if the order flipped, our handler would\n          // treat Chromium's auto-pick as a user action. The `effects:`\n          // block below handles subsequent `selectedTextTrackId` changes.\n          syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());\n\n          // Chromium re-applies its own selection across the next task tick\n          // after `<track>` insertion (default-track auto-pick, language\n          // preference). During this window, the `change` event may fire\n          // with browser-chosen modes that don't reflect a real user action;\n          // re-apply our modes silently rather than writing them back.\n          let inSettlingWindow = true;\n          const settlingTimeout = setTimeout(() => {\n            inSettlingWindow = false;\n          }, 0);\n\n          const onChange = (): void => {\n            if (inSettlingWindow) {\n              syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());\n              return;\n            }\n            const showingTrack = getShowingSubtitlesTrackFromMedia(mediaElement);\n            // `showingTrack.id` matches the SPF id we set when the slot was\n            // allocated. Empty-string ids fall through to `undefined`.\n            const showingId = showingTrack?.id || undefined;\n            // Echo guard: selectedTextTrackId is the id we last drove into the\n            // DOM (mirror / resolver correction). A change still showing it is our\n            // own echo — ignore it rather than write spurious intent.\n            if (showingId === state.selectedTextTrackId.get()) return;\n            // Genuine user action → write intent (resolved into selectedTextTrackId\n            // by switchTextTrack), not the resolved id.\n            state.userTextTrackSelection.set(deriveTextTrackIntent(showingId, modelTextTracks));\n          };\n\n          const unlisten = listen(mediaElement.textTracks, 'change', onChange);\n\n          return () => {\n            unlisten();\n            clearTimeout(settlingTimeout);\n            removeAllSubtitlesTracksFromMedia(mediaElement);\n            // Clear the TextTracksActor's cue+segment cache, which is\n            // keyed by trackId. If we don't, a subsequent presentation\n            // reusing a trackId would have `getSegmentsToLoad` treat its\n            // segments as already-buffered. The DOM cleanup above\n            // already evicted the live cues; this drops the cache that\n            // tracked them. The actor itself is owned by\n            // `setupTextTrackActors` (mediaElement-bound lifecycle), so\n            // we send rather than destroy.\n            peek(context.textTracksActor)?.send({ type: 'clear' });\n          };\n        },\n\n        // Mirror selection changes into mode. The state machine handles\n        // mediaElement/presentation changes via 'preconditions-unmet'\n        // round-trips, so we peek mediaElement here.\n        effects: () => {\n          const mediaElement = peek(context.mediaElement)!;\n          syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());\n        },\n      },\n    },\n  });\n}\n\nexport const syncTextTracks = defineBehavior({\n  stateKeys: ['presentation', 'selectedTextTrackId', 'userTextTrackSelection'],\n  contextKeys: ['mediaElement', 'textTracksActor'],\n  setup: syncTextTracksSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoFA,SAAS,YACP,cACA,cACwB;CACxB,IAAI,CAAC,gBAAgB,CAAC,cAAc,OAAO;CAC3C,OAAO,gBAAgB,cAAc,MAAM,CAAC,CAAC,SAAS,IAAI,gBAAgB;AAC5E;;;;;;;AAQA,SAAS,sBACP,WACA,iBAC4B;CAC5B,IAAI,CAAC,WAAW,OAAO;CACvB,MAAM,WAAW,gBAAgB,MAAM,UAAU,MAAM,OAAO,SAAS,CAAC,EAAE;CAC1E,OAAO,WAAW,EAAE,SAAS,IAAI,EAAE,IAAI,UAAU;AACnD;AAEA,SAAS,oBAAoB,EAC3B,OACA,SACA,UAe+D;CAC/D,MAAM,EAAE,2BAA2B,mCAAmC,sCAAsC;CAE5G,MAAM,qBAAqB,eAAe,YAAY,MAAM,aAAa,IAAI,GAAG,QAAQ,aAAa,IAAI,CAAC,CAAC;CAE3G,OAAO,qBAA6C;EAClD,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,CAAC;GAExB,eAAe;IAOb,aAAa;KACX,MAAM,eAAe,QAAQ,aAAa,IAAI;KAK9C,MAAM,kBAAkB,gBAAgB,MAAM,aAAa,IAAI,GAAI,MAAM;KAKzE,0BAA0B,cAAc,eAAe;KASvD,mBAAmB,aAAa,YAAY,MAAM,oBAAoB,IAAI,CAAC;KAO3E,IAAI,mBAAmB;KACvB,MAAM,kBAAkB,iBAAiB;MACvC,mBAAmB;KACrB,GAAG,CAAC;KAEJ,MAAM,iBAAuB;MAC3B,IAAI,kBAAkB;OACpB,mBAAmB,aAAa,YAAY,MAAM,oBAAoB,IAAI,CAAC;OAC3E;MACF;MAIA,MAAM,YAHe,kCAAkC,YAG1B,CAAC,EAAE,MAAM,KAAA;MAItC,IAAI,cAAc,MAAM,oBAAoB,IAAI,GAAG;MAGnD,MAAM,uBAAuB,IAAI,sBAAsB,WAAW,eAAe,CAAC;KACpF;KAEA,MAAM,WAAW,OAAO,aAAa,YAAY,UAAU,QAAQ;KAEnE,aAAa;MACX,SAAS;MACT,aAAa,eAAe;MAC5B,kCAAkC,YAAY;MAS9C,KAAK,QAAQ,eAAe,CAAC,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;KACvD;IACF;IAKA,eAAe;KAEb,mBADqB,KAAK,QAAQ,YACJ,CAAC,CAAC,YAAY,MAAM,oBAAoB,IAAI,CAAC;IAC7E;GACF;EACF;CACF,CAAC;AACH;AAEA,MAAa,iBAAiB,eAAe;CAC3C,WAAW;EAAC;EAAgB;EAAuB;CAAwB;CAC3E,aAAa,CAAC,gBAAgB,iBAAiB;CAC/C,OAAO;AACT,CAAC"}
+{"version":3,"file":"sync-text-tracks.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/sync-text-tracks.ts"],"sourcesContent":["/**\n * **Own the text-track slots on the host media element, mirroring the SPF model.** When a presentation is resolved and\n * a media element is available, allocate one slot in `mediaElement.textTracks` per model text track — via creating\n * `<track>` children, since that's the only spec mechanism for adding _and_ removing entries to `textTracks` (no\n * `removeTextTrack` API exists). Once slots are provisioned, mirror the resolved `selectedTextTrackId` into their\n * `mode`s (one-way: state → DOM), and propagate user-initiated DOM `change` events back to `userTextTrackSelection` —\n * the standing _intent_ (a language-based partial, or `'off'`) that `switchTextTrack` resolves into\n * `selectedTextTrackId`. So non-SPF consumers (host-page captions buttons, browser native UI, video.js store) drive\n * selection by expressing intent, not by writing the resolved id.\n *\n * Single-positive-state reactor (`'preconditions-unmet'` ↔ `'sync-active'`): the entry allocates the slots, applies the\n * initial selection, attaches the `change` listener, and opens a brief Chromium settling-window guard — all\n * transition-driven, fire-once on state entry, with paired cleanup on state exit. A single `effects:` mirrors\n * subsequent `selectedTextTrackId` changes into `mode`s; that's the only continuous-reactivity concern.\n *\n * State-exit cleanup also sends a `'clear'` message to the `TextTracksActor` so its cue+segment cache (keyed by\n * trackId) is dropped alongside the DOM `<track>` slots. The actor itself is owned by `setupTextTrackActors` and bound\n * to mediaElement, not presentation, so it survives source resets; clearing its context here keeps the cache consistent\n * with the DOM. Without this, a subsequent presentation reusing a trackId would have `getSegmentsToLoad` treat its\n * segments as already-buffered and skip loading them.\n *\n * Single-writer separation: `selectedTextTrackId` is the resolved _output_ owned solely by `switchTextTrack`; this\n * behavior only reads it (to mirror modes). The write path here is `userTextTrackSelection` — the user-intent _input_ —\n * so DOM action and the resolver never contend for one slot. The intent isn't cleared on source unload (it's a standing\n * preference, like `userAudioTrackSelection`); `'off'` is written when the user disables all tracks via native UI.\n *\n * Echo guard: `selectedTextTrackId` is exactly the id this behavior last drove into the DOM, so a `change` event still\n * showing it is our own echo (or a resolver-driven correction — e.g. the picked track's CDN failed and the resolver\n * disabled it) and is ignored, never written back as a spurious user action. Only a showing id that _differs_ from the\n * resolved id is a real user pick. The settling-window guard additionally swallows Chromium's init-time auto-selection\n * before the resolved selection has settled.\n */\n\nimport { listen } from '@videojs/utils/dom';\n\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, peek, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';\nimport { syncTextTrackModes } from '../../../media/dom/text/text-track-slots';\nimport type { MaybeResolvedPresentation, PartiallyResolvedTextTrack, TextTrack } from '../../../media/types';\nimport { getTracksByType } from '../../../media/utils/tracks';\nimport type { TextTracksActor } from '../../actors/text-tracks';\n\ntype SyncTextTracksFsmState = 'preconditions-unmet' | 'sync-active';\n\nexport interface SyncTextTracksConfig {\n  /**\n   * Create and append SPF-owned `<track>` slots on `mediaElement`, one per model text track. Implementation tags each\n   * element so the read/remove helpers can scope to SPF-owned slots. **Required** — the behavior is DOM-binding-neutral\n   * and the composing engine supplies the integration.\n   */\n  addSubtitlesTracksToMedia: (\n    mediaElement: HTMLMediaElement,\n    modelTextTracks: readonly (PartiallyResolvedTextTrack | TextTrack)[]\n  ) => void;\n  /**\n   * Return the SPF-owned subtitle/caption `TextTrack` currently in `'showing'` mode, or `undefined` if none. Used by\n   * the DOM `change` bridge to mirror native-UI selection back into `selectedTextTrackId`.\n   */\n  getShowingSubtitlesTrackFromMedia: (mediaElement: HTMLMediaElement) => globalThis.TextTrack | undefined;\n  /**\n   * Remove every SPF-owned `<track>` child from `mediaElement`. Called on state exit (source unload, behavior destroy)\n   * to evict slots.\n   */\n  removeAllSubtitlesTracksFromMedia: (mediaElement: HTMLMediaElement) => void;\n}\n\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaElement: HTMLMediaElement | undefined\n): SyncTextTracksFsmState {\n  if (!mediaElement || !presentation) return 'preconditions-unmet';\n\n  return getTracksByType(presentation, 'text').length > 0 ? 'sync-active' : 'preconditions-unmet';\n}\n\n/**\n * Map the DOM-showing track back to standing user intent. No showing track is an explicit `'off'`. Otherwise prefer a\n * language-based partial (so the pick persists across source changes); fall back to `{ id }` for a track without a\n * language (precise within a source, just not portable).\n */\nfunction deriveTextTrackIntent(\n  showingId: string | undefined,\n  modelTextTracks: readonly (PartiallyResolvedTextTrack | TextTrack)[]\n): Partial<TextTrack> | 'off' {\n  if (!showingId) return 'off';\n\n  const language = modelTextTracks.find((track) => track.id === showingId)?.language;\n\n  return language ? { language } : { id: showingId };\n}\n\nfunction syncTextTracksSetup({\n  state,\n  context,\n  config,\n}: {\n  state: {\n    presentation: ReadonlySignal<MaybeResolvedPresentation | undefined>;\n    // Read-only here: the resolved output owned by `switchTextTrack`, mirrored\n    // into DOM modes and used as the echo-guard reference.\n    selectedTextTrackId: ReadonlySignal<string | undefined>;\n    // The write path: standing user intent the DOM bridge feeds.\n    userTextTrackSelection: Signal<Partial<TextTrack> | 'off' | undefined>;\n  };\n  context: {\n    mediaElement: ReadonlySignal<HTMLMediaElement | undefined>;\n    textTracksActor: ReadonlySignal<TextTracksActor<VTTCue> | undefined>;\n  };\n  config: SyncTextTracksConfig;\n}): Reactor<SyncTextTracksFsmState | 'destroying' | 'destroyed'> {\n  const { addSubtitlesTracksToMedia, getShowingSubtitlesTrackFromMedia, removeAllSubtitlesTracksFromMedia } = config;\n\n  const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaElement.get()));\n\n  return createMachineReactor<SyncTextTracksFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'sync-active': {\n        // Allocate slots, apply the initial selection, attach the change\n        // listener, and open the settling window — all transition-driven\n        // (fire once per state entry). Entry is auto-untracked, so `.get()`\n        // here doesn't subscribe; the returned cleanup detaches and evicts\n        // on state exit (src reset through 'preconditions-unmet') and on\n        // destroy.\n        entry: () => {\n          const mediaElement = context.mediaElement.get()!;\n          // `getTracksByType('text', ...)` returns text tracks only — the\n          // selection-set filter inside the helper ensures that — but its\n          // declared return is the wide track union. Mirror the cast\n          // pattern used by `track-switching` for the video branch.\n          const modelTextTracks = getTracksByType(state.presentation.get()!, 'text') as readonly (\n            | PartiallyResolvedTextTrack\n            | TextTrack\n          )[];\n\n          addSubtitlesTracksToMedia(mediaElement, modelTextTracks);\n          // Apply our selection synchronously so the change-event tasks\n          // these mode writes queue land in the macrotask queue *before*\n          // the settling-close `setTimeout(0)` queued below. This keeps\n          // the settling window open long enough to swallow Chromium's\n          // own auto-selection task (also scheduled in the next tick after\n          // `<track>` insertion); if the order flipped, our handler would\n          // treat Chromium's auto-pick as a user action. The `effects:`\n          // block below handles subsequent `selectedTextTrackId` changes.\n          syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());\n\n          // Chromium re-applies its own selection across the next task tick\n          // after `<track>` insertion (default-track auto-pick, language\n          // preference). During this window, the `change` event may fire\n          // with browser-chosen modes that don't reflect a real user action;\n          // re-apply our modes silently rather than writing them back.\n          let inSettlingWindow = true;\n          const settlingTimeout = setTimeout(() => {\n            inSettlingWindow = false;\n          }, 0);\n\n          const onChange = (): void => {\n            if (inSettlingWindow) {\n              syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());\n              return;\n            }\n\n            const showingTrack = getShowingSubtitlesTrackFromMedia(mediaElement);\n            // `showingTrack.id` matches the SPF id we set when the slot was\n            // allocated. Empty-string ids fall through to `undefined`.\n            const showingId = showingTrack?.id || undefined;\n            // Echo guard: selectedTextTrackId is the id we last drove into the\n            // DOM (mirror / resolver correction). A change still showing it is our\n            // own echo — ignore it rather than write spurious intent.\n            if (showingId === state.selectedTextTrackId.get()) return;\n\n            // Genuine user action → write intent (resolved into selectedTextTrackId\n            // by switchTextTrack), not the resolved id.\n            state.userTextTrackSelection.set(deriveTextTrackIntent(showingId, modelTextTracks));\n          };\n\n          const unlisten = listen(mediaElement.textTracks, 'change', onChange);\n\n          return () => {\n            unlisten();\n            clearTimeout(settlingTimeout);\n            removeAllSubtitlesTracksFromMedia(mediaElement);\n            // Clear the TextTracksActor's cue+segment cache, which is\n            // keyed by trackId. If we don't, a subsequent presentation\n            // reusing a trackId would have `getSegmentsToLoad` treat its\n            // segments as already-buffered. The DOM cleanup above\n            // already evicted the live cues; this drops the cache that\n            // tracked them. The actor itself is owned by\n            // `setupTextTrackActors` (mediaElement-bound lifecycle), so\n            // we send rather than destroy.\n            peek(context.textTracksActor)?.send({ type: 'clear' });\n          };\n        },\n\n        // Mirror selection changes into mode. The state machine handles\n        // mediaElement/presentation changes via 'preconditions-unmet'\n        // round-trips, so we peek mediaElement here.\n        effects: () => {\n          const mediaElement = peek(context.mediaElement)!;\n\n          syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());\n        },\n      },\n    },\n  });\n}\n\nexport const syncTextTracks = defineBehavior({\n  stateKeys: ['presentation', 'selectedTextTrackId', 'userTextTrackSelection'],\n  contextKeys: ['mediaElement', 'textTracksActor'],\n  setup: syncTextTracksSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEA,SAAS,YACP,cACA,cACwB;CACxB,IAAI,CAAC,gBAAgB,CAAC,cAAc,OAAO;CAE3C,OAAO,gBAAgB,cAAc,MAAM,CAAC,CAAC,SAAS,IAAI,gBAAgB;AAC5E;;;;;;AAOA,SAAS,sBACP,WACA,iBAC4B;CAC5B,IAAI,CAAC,WAAW,OAAO;CAEvB,MAAM,WAAW,gBAAgB,MAAM,UAAU,MAAM,OAAO,SAAS,CAAC,EAAE;CAE1E,OAAO,WAAW,EAAE,SAAS,IAAI,EAAE,IAAI,UAAU;AACnD;AAEA,SAAS,oBAAoB,EAC3B,OACA,SACA,UAe+D;CAC/D,MAAM,EAAE,2BAA2B,mCAAmC,sCAAsC;CAE5G,MAAM,qBAAqB,eAAe,YAAY,MAAM,aAAa,IAAI,GAAG,QAAQ,aAAa,IAAI,CAAC,CAAC;CAE3G,OAAO,qBAA6C;EAClD,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,CAAC;GAExB,eAAe;IAOb,aAAa;KACX,MAAM,eAAe,QAAQ,aAAa,IAAI;KAK9C,MAAM,kBAAkB,gBAAgB,MAAM,aAAa,IAAI,GAAI,MAAM;KAKzE,0BAA0B,cAAc,eAAe;KASvD,mBAAmB,aAAa,YAAY,MAAM,oBAAoB,IAAI,CAAC;KAO3E,IAAI,mBAAmB;KACvB,MAAM,kBAAkB,iBAAiB;MACvC,mBAAmB;KACrB,GAAG,CAAC;KAEJ,MAAM,iBAAuB;MAC3B,IAAI,kBAAkB;OACpB,mBAAmB,aAAa,YAAY,MAAM,oBAAoB,IAAI,CAAC;OAC3E;MACF;MAKA,MAAM,YAHe,kCAAkC,YAG1B,CAAC,EAAE,MAAM,KAAA;MAItC,IAAI,cAAc,MAAM,oBAAoB,IAAI,GAAG;MAInD,MAAM,uBAAuB,IAAI,sBAAsB,WAAW,eAAe,CAAC;KACpF;KAEA,MAAM,WAAW,OAAO,aAAa,YAAY,UAAU,QAAQ;KAEnE,aAAa;MACX,SAAS;MACT,aAAa,eAAe;MAC5B,kCAAkC,YAAY;MAS9C,KAAK,QAAQ,eAAe,CAAC,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;KACvD;IACF;IAKA,eAAe;KACb,MAAM,eAAe,KAAK,QAAQ,YAAY;KAE9C,mBAAmB,aAAa,YAAY,MAAM,oBAAoB,IAAI,CAAC;IAC7E;GACF;EACF;CACF,CAAC;AACH;AAEA,MAAa,iBAAiB,eAAe;CAC3C,WAAW;EAAC;EAAgB;EAAuB;CAAwB;CAC3E,aAAa,CAAC,gBAAgB,iBAAiB;CAC/C,OAAO;AACT,CAAC"}

package/dist/dev/playback/behaviors/dom/track-current-time.d.ts

@@ -8,8 +8,8 @@ interface CurrentTimeContext {
 }
 interface TrackCurrentTimeConfig {
   /**
-   * Value written to `state.currentTime` when no media element is attached.
-   * Defaults to `0` — the HTMLMediaElement spec default.
+   * Value written to `state.currentTime` when no media element is attached. Defaults to `0` — the HTMLMediaElement spec
+   * default.
    */
   defaultCurrentTime?: number;
 }

package/dist/dev/playback/behaviors/dom/track-current-time.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"track-current-time.d.ts","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-current-time.ts"],"mappings":";;UAwBiB;EACf;;UAGe;EACf,eAAe;;UAGA;;;;;EAKf;;cAkCW;;;;;MA1BW,aAAA,OAAO;;;;MACJ,cAAA,eAAe"}
+{"version":3,"file":"track-current-time.d.ts","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-current-time.ts"],"mappings":";;UAuBiB;EACf;;UAGe;EACf,eAAe;;UAGA;;;;;EAKf;;cAsCW;;;;;MA9BW,aAAA,OAAO;;;;MACJ,cAAA,eAAe"}

package/dist/dev/playback/behaviors/dom/track-current-time.js

@@ -4,21 +4,19 @@ import { listen } from "@videojs/utils/dom";
 //#region src/playback/behaviors/dom/track-current-time.ts
 /**
 * Mirror `mediaElement.currentTime` into reactive state. Listens for:
+*
 * - `timeupdate` — fires during playback (~4 Hz)
-* - `seeking` — fires when a seek begins; per spec, `currentTime` is already
-*   at the new position when this event dispatches, so buffer management can
-*   react immediately rather than waiting for `timeupdate`, which does not
-*   fire while paused.
-* - `emptied` — fires when the resource selection algorithm tears down the
-*   current media (e.g. a new `src` is set on the same element). Re-syncs so
-*   downstream state doesn't retain the stale playback position from the
-*   previous source when the engine is reused across src changes.
+* - `seeking` — fires when a seek begins; per spec, `currentTime` is already at the new position when this event
+*   dispatches, so buffer management can react immediately rather than waiting for `timeupdate`, which does not fire
+*   while paused.
+* - `emptied` — fires when the resource selection algorithm tears down the current media (e.g. a new `src` is set on the
+*   same element). Re-syncs so downstream state doesn't retain the stale playback position from the previous source
+*   when the engine is reused across src changes.
 *
 * Also syncs immediately when a media element becomes available.
 *
-* When no media element is attached, writes `config.defaultCurrentTime`
-* (default-default `0`, matching the HTMLMediaElement spec) so consumers
-* always see a defined position. Read-only mirror; does not push
+* When no media element is attached, writes `config.defaultCurrentTime` (default-default `0`, matching the
+* HTMLMediaElement spec) so consumers always see a defined position. Read-only mirror; does not push
 * `state.currentTime` back to the element.
 */
 function trackCurrentTimeSetup({ state, context, config }) {

package/dist/dev/playback/behaviors/dom/track-current-time.js.map

@@ -1 +1 @@
-{"version":3,"file":"track-current-time.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-current-time.ts"],"sourcesContent":["/**\n * Mirror `mediaElement.currentTime` into reactive state. Listens for:\n * - `timeupdate` — fires during playback (~4 Hz)\n * - `seeking` — fires when a seek begins; per spec, `currentTime` is already\n *   at the new position when this event dispatches, so buffer management can\n *   react immediately rather than waiting for `timeupdate`, which does not\n *   fire while paused.\n * - `emptied` — fires when the resource selection algorithm tears down the\n *   current media (e.g. a new `src` is set on the same element). Re-syncs so\n *   downstream state doesn't retain the stale playback position from the\n *   previous source when the engine is reused across src changes.\n *\n * Also syncs immediately when a media element becomes available.\n *\n * When no media element is attached, writes `config.defaultCurrentTime`\n * (default-default `0`, matching the HTMLMediaElement spec) so consumers\n * always see a defined position. Read-only mirror; does not push\n * `state.currentTime` back to the element.\n */\nimport { listen } from '@videojs/utils/dom';\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport type { ReadonlySignal, Signal } from '../../../core/signals/primitives';\n\nexport interface CurrentTimeState {\n  currentTime?: number;\n}\n\nexport interface CurrentTimeContext {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\nexport interface TrackCurrentTimeConfig {\n  /**\n   * Value written to `state.currentTime` when no media element is attached.\n   * Defaults to `0` — the HTMLMediaElement spec default.\n   */\n  defaultCurrentTime?: number;\n}\n\nfunction trackCurrentTimeSetup({\n  state,\n  context,\n  config,\n}: {\n  state: { currentTime: Signal<CurrentTimeState['currentTime']> };\n  context: { mediaElement: ReadonlySignal<CurrentTimeContext['mediaElement']> };\n  config?: TrackCurrentTimeConfig;\n}): () => void {\n  const defaultCurrentTime = config?.defaultCurrentTime ?? 0;\n\n  return effect(() => {\n    const mediaElement = context.mediaElement.get();\n    if (!mediaElement) {\n      state.currentTime.set(defaultCurrentTime);\n      return;\n    }\n\n    const sync = () => state.currentTime.set(mediaElement.currentTime);\n    sync();\n    const removeEmptied = listen(mediaElement, 'emptied', sync);\n    const removeTimeupdate = listen(mediaElement, 'timeupdate', sync);\n    const removeSeeking = listen(mediaElement, 'seeking', sync);\n    return () => {\n      removeEmptied();\n      removeTimeupdate();\n      removeSeeking();\n    };\n  });\n}\n\nexport const trackCurrentTime = defineBehavior({\n  stateKeys: ['currentTime'],\n  contextKeys: ['mediaElement'],\n  setup: trackCurrentTimeSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAS,sBAAsB,EAC7B,OACA,SACA,UAKa;CACb,MAAM,qBAAqB,QAAQ,sBAAsB;CAEzD,OAAO,aAAa;EAClB,MAAM,eAAe,QAAQ,aAAa,IAAI;EAC9C,IAAI,CAAC,cAAc;GACjB,MAAM,YAAY,IAAI,kBAAkB;GACxC;EACF;EAEA,MAAM,aAAa,MAAM,YAAY,IAAI,aAAa,WAAW;EACjE,KAAK;EACL,MAAM,gBAAgB,OAAO,cAAc,WAAW,IAAI;EAC1D,MAAM,mBAAmB,OAAO,cAAc,cAAc,IAAI;EAChE,MAAM,gBAAgB,OAAO,cAAc,WAAW,IAAI;EAC1D,aAAa;GACX,cAAc;GACd,iBAAiB;GACjB,cAAc;EAChB;CACF,CAAC;AACH;AAEA,MAAa,mBAAmB,eAAe;CAC7C,WAAW,CAAC,aAAa;CACzB,aAAa,CAAC,cAAc;CAC5B,OAAO;AACT,CAAC"}
+{"version":3,"file":"track-current-time.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-current-time.ts"],"sourcesContent":["/**\n * Mirror `mediaElement.currentTime` into reactive state. Listens for:\n *\n * - `timeupdate` — fires during playback (~4 Hz)\n * - `seeking` — fires when a seek begins; per spec, `currentTime` is already at the new position when this event\n *   dispatches, so buffer management can react immediately rather than waiting for `timeupdate`, which does not fire\n *   while paused.\n * - `emptied` — fires when the resource selection algorithm tears down the current media (e.g. a new `src` is set on the\n *   same element). Re-syncs so downstream state doesn't retain the stale playback position from the previous source\n *   when the engine is reused across src changes.\n *\n * Also syncs immediately when a media element becomes available.\n *\n * When no media element is attached, writes `config.defaultCurrentTime` (default-default `0`, matching the\n * HTMLMediaElement spec) so consumers always see a defined position. Read-only mirror; does not push\n * `state.currentTime` back to the element.\n */\nimport { listen } from '@videojs/utils/dom';\n\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport type { ReadonlySignal, Signal } from '../../../core/signals/primitives';\n\nexport interface CurrentTimeState {\n  currentTime?: number;\n}\n\nexport interface CurrentTimeContext {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\nexport interface TrackCurrentTimeConfig {\n  /**\n   * Value written to `state.currentTime` when no media element is attached. Defaults to `0` — the HTMLMediaElement spec\n   * default.\n   */\n  defaultCurrentTime?: number;\n}\n\nfunction trackCurrentTimeSetup({\n  state,\n  context,\n  config,\n}: {\n  state: { currentTime: Signal<CurrentTimeState['currentTime']> };\n  context: { mediaElement: ReadonlySignal<CurrentTimeContext['mediaElement']> };\n  config?: TrackCurrentTimeConfig;\n}): () => void {\n  const defaultCurrentTime = config?.defaultCurrentTime ?? 0;\n\n  return effect(() => {\n    const mediaElement = context.mediaElement.get();\n\n    if (!mediaElement) {\n      state.currentTime.set(defaultCurrentTime);\n      return;\n    }\n\n    const sync = () => state.currentTime.set(mediaElement.currentTime);\n\n    sync();\n\n    const removeEmptied = listen(mediaElement, 'emptied', sync);\n    const removeTimeupdate = listen(mediaElement, 'timeupdate', sync);\n    const removeSeeking = listen(mediaElement, 'seeking', sync);\n\n    return () => {\n      removeEmptied();\n      removeTimeupdate();\n      removeSeeking();\n    };\n  });\n}\n\nexport const trackCurrentTime = defineBehavior({\n  stateKeys: ['currentTime'],\n  contextKeys: ['mediaElement'],\n  setup: trackCurrentTimeSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAuCA,SAAS,sBAAsB,EAC7B,OACA,SACA,UAKa;CACb,MAAM,qBAAqB,QAAQ,sBAAsB;CAEzD,OAAO,aAAa;EAClB,MAAM,eAAe,QAAQ,aAAa,IAAI;EAE9C,IAAI,CAAC,cAAc;GACjB,MAAM,YAAY,IAAI,kBAAkB;GACxC;EACF;EAEA,MAAM,aAAa,MAAM,YAAY,IAAI,aAAa,WAAW;EAEjE,KAAK;EAEL,MAAM,gBAAgB,OAAO,cAAc,WAAW,IAAI;EAC1D,MAAM,mBAAmB,OAAO,cAAc,cAAc,IAAI;EAChE,MAAM,gBAAgB,OAAO,cAAc,WAAW,IAAI;EAE1D,aAAa;GACX,cAAc;GACd,iBAAiB;GACjB,cAAc;EAChB;CACF,CAAC;AACH;AAEA,MAAa,mBAAmB,eAAe;CAC7C,WAAW,CAAC,aAAa;CACzB,aAAa,CAAC,cAAc;CAC5B,OAAO;AACT,CAAC"}

package/dist/dev/playback/behaviors/dom/track-load-triggers.d.ts

@@ -2,26 +2,20 @@ import { MaybeResolvedPresentation } from "../../../media/types/index.js";
 import { ReadonlySignal, Signal } from "../../../core/signals/primitives.js";
 import { Reactor } from "../../../core/reactors/create-machine-reactor.js";
 //#region src/playback/behaviors/dom/track-load-triggers.d.ts
-/**
- * State shape for load-trigger tracking.
- */
+/** State shape for load-trigger tracking. */
 interface LoadTriggersState {
   /**
-   * Sticky-true per source. Flips to `true` the first time an event occurs
-   * that should switch loading behavior from preload-based to standard load
-   * (currently DOM `play` / `seeking`). Reset to `false` on source change.
+   * Sticky-true per source. Flips to `true` the first time an event occurs that should switch loading behavior from
+   * preload-based to standard load (currently DOM `play` / `seeking`). Reset to `false` on source change.
    *
-   * Read by `resolvePresentation` and `loadVideoSegments` / `loadAudioSegments`
-   * to mirror native `HTMLMediaElement` preload semantics — only meaningful
-   * when `preload !== 'auto'`, which already loads fully regardless.
+   * Read by `resolvePresentation` and `loadVideoSegments` / `loadAudioSegments` to mirror native `HTMLMediaElement`
+   * preload semantics — only meaningful when `preload !== 'auto'`, which already loads fully regardless.
    */
   loadActivated?: boolean;
   /** Current presentation — URL is used to detect source changes. */
   presentation?: MaybeResolvedPresentation;
 }
-/**
- * Context shape for load-trigger tracking.
- */
+/** Context shape for load-trigger tracking. */
 interface LoadTriggersContext {
   mediaElement?: HTMLMediaElement | undefined;
 }

package/dist/dev/playback/behaviors/dom/track-load-triggers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"track-load-triggers.d.ts","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-load-triggers.ts"],"mappings":";;;;;;;UAUiB;;;;;;;;;;EAUf;;EAEA,eAAe;;;;;UAMA;EACf,eAAe;;KAGZ;cA6HQ;;;;;MA/DM,eAAA,OAAO;MACR,cAAA,eAAe;;;;MAEN,cAAA,eAAe"}
+{"version":3,"file":"track-load-triggers.d.ts","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-load-triggers.ts"],"mappings":";;;;;UASiB;;;;;;;;EAQf;;EAEA,eAAe;;;UAIA;EACf,eAAe;;KAGZ;cA0HQ;;;;;MAlEM,eAAA,OAAO;MACR,cAAA,eAAe;;;;MAEN,cAAA,eAAe"}

package/dist/dev/playback/behaviors/dom/track-load-triggers.js

@@ -4,23 +4,20 @@ import { createMachineReactor } from "../../../core/reactors/create-machine-reac
 import { listen } from "@videojs/utils/dom";
 //#region src/playback/behaviors/dom/track-load-triggers.ts
 /**
-* Slot-driven FSM. The slot `loadActivated` is the canonical externally-
-* observable state; `deriveState` reads it (and the preconditions) to
-* derive the local FSM state. The slot is *both* the state and the data —
-* no separate internal bookkeeping.
+* Slot-driven FSM. The slot `loadActivated` is the canonical externally- observable state; `deriveState` reads it (and
+* the preconditions) to derive the local FSM state. The slot is _both_ the state and the data — no separate internal
+* bookkeeping.
 *
-* ```
-* 'preconditions-unmet' ⟷ 'monitoring' ⟷ 'load-active'
+*     'preconditions-unmet' ⟷ 'monitoring' ⟷ 'load-active'
 *
-* preconditions-unmet → monitoring        element + URL appear
-* monitoring          → load-active       slot flips true (listener fires
-*                                         or external write)
-* load-active         → monitoring        within-state cleanup resets slot
-*                                         (URL or element identity change)
-* any                 → preconditions-unmet  element or URL → undefined
+*     preconditions-unmet → monitoring        element + URL appear
+*     monitoring          → load-active       slot flips true (listener fires
+*                                             or external write)
+*     load-active         → monitoring        within-state cleanup resets slot
+*                                             (URL or element identity change)
+*     any                 → preconditions-unmet  element or URL → undefined
 *
-* any state → destroying → destroyed       on destroy()
-* ```
+*     any state → destroying → destroyed       on destroy()
 */
 function deriveState(presentation, mediaElement, loadActivated) {
 	if (!mediaElement || !presentation?.url) return "preconditions-unmet";
@@ -30,28 +27,23 @@ function deriveState(presentation, mediaElement, loadActivated) {
 /**
 * Track preload-overriding events per source.
 *
-* Writes `state.loadActivated = true` the first time a `play` or `seeking`
-* event fires on the attached media element for the current source — or
-* immediately on entry if the element is already committed to loading
-* (`el.autoplay`, `!el.paused`, or `el.seeking`), covering autoplay,
-* native-controls, and direct-DOM-`play()` scenarios.
+* Writes `state.loadActivated = true` the first time a `play` or `seeking` event fires on the attached media element
+* for the current source — or immediately on entry if the element is already committed to loading (`el.autoplay`,
+* `!el.paused`, or `el.seeking`), covering autoplay, native-controls, and direct-DOM-`play()` scenarios.
 *
-* Sticky-true *within a source identity*: subsequent play/pause/seek
-* cycles don't flip back. Source identity = (mediaElement, presentation
-* URL). Either changing — including direct in-place swap with no
-* `undefined` intermediate — resets the slot to `false`.
+* Sticky-true _within a source identity_: subsequent play/pause/seek cycles don't flip back. Source identity =
+* (mediaElement, presentation URL). Either changing — including direct in-place swap with no `undefined` intermediate —
+* resets the slot to `false`.
 *
-* Multi-writer with `hls/adapter.ts:play()` (which writes `true` directly
-* on programmatic play) is intentional — different domains. The adapter
-* records programmatic intent; this behavior is the DOM-side observer.
-* Pre-existing `true` writes are honored because `deriveState` reads the
-* slot — a `true` value routes directly to `'load-active'` without
-* entering `'monitoring'`.
+* Multi-writer with `hls/adapter.ts:play()` (which writes `true` directly on programmatic play) is intentional —
+* different domains. The adapter records programmatic intent; this behavior is the DOM-side observer. Pre-existing
+* `true` writes are honored because `deriveState` reads the slot — a `true` value routes directly to `'load-active'`
+* without entering `'monitoring'`.
 *
 * @example
-* const reactor = trackLoadTriggers.setup({ state, context });
-* // later:
-* reactor.destroy();
+*   const reactor = trackLoadTriggers.setup({ state, context });
+*   // later:
+*   reactor.destroy();
 */
 function trackLoadTriggersSetup({ state, context }) {
 	const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaElement.get(), state.loadActivated.get()));

package/dist/dev/playback/behaviors/dom/track-load-triggers.js.map

@@ -1 +1 @@
-{"version":3,"file":"track-load-triggers.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-load-triggers.ts"],"sourcesContent":["import { listen } from '@videojs/utils/dom';\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';\nimport type { MaybeResolvedPresentation } from '../../../media/types';\n\n/**\n * State shape for load-trigger tracking.\n */\nexport interface LoadTriggersState {\n  /**\n   * Sticky-true per source. Flips to `true` the first time an event occurs\n   * that should switch loading behavior from preload-based to standard load\n   * (currently DOM `play` / `seeking`). Reset to `false` on source change.\n   *\n   * Read by `resolvePresentation` and `loadVideoSegments` / `loadAudioSegments`\n   * to mirror native `HTMLMediaElement` preload semantics — only meaningful\n   * when `preload !== 'auto'`, which already loads fully regardless.\n   */\n  loadActivated?: boolean;\n  /** Current presentation — URL is used to detect source changes. */\n  presentation?: MaybeResolvedPresentation;\n}\n\n/**\n * Context shape for load-trigger tracking.\n */\nexport interface LoadTriggersContext {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\ntype LoadTriggersFsmState = 'preconditions-unmet' | 'monitoring' | 'load-active';\n\n/**\n * Slot-driven FSM. The slot `loadActivated` is the canonical externally-\n * observable state; `deriveState` reads it (and the preconditions) to\n * derive the local FSM state. The slot is *both* the state and the data —\n * no separate internal bookkeeping.\n *\n * ```\n * 'preconditions-unmet' ⟷ 'monitoring' ⟷ 'load-active'\n *\n * preconditions-unmet → monitoring        element + URL appear\n * monitoring          → load-active       slot flips true (listener fires\n *                                         or external write)\n * load-active         → monitoring        within-state cleanup resets slot\n *                                         (URL or element identity change)\n * any                 → preconditions-unmet  element or URL → undefined\n *\n * any state → destroying → destroyed       on destroy()\n * ```\n */\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaElement: HTMLMediaElement | undefined,\n  loadActivated: boolean | undefined\n): LoadTriggersFsmState {\n  if (!mediaElement || !presentation?.url) return 'preconditions-unmet';\n  if (loadActivated) return 'load-active';\n  return 'monitoring';\n}\n\n/**\n * Track preload-overriding events per source.\n *\n * Writes `state.loadActivated = true` the first time a `play` or `seeking`\n * event fires on the attached media element for the current source — or\n * immediately on entry if the element is already committed to loading\n * (`el.autoplay`, `!el.paused`, or `el.seeking`), covering autoplay,\n * native-controls, and direct-DOM-`play()` scenarios.\n *\n * Sticky-true *within a source identity*: subsequent play/pause/seek\n * cycles don't flip back. Source identity = (mediaElement, presentation\n * URL). Either changing — including direct in-place swap with no\n * `undefined` intermediate — resets the slot to `false`.\n *\n * Multi-writer with `hls/adapter.ts:play()` (which writes `true` directly\n * on programmatic play) is intentional — different domains. The adapter\n * records programmatic intent; this behavior is the DOM-side observer.\n * Pre-existing `true` writes are honored because `deriveState` reads the\n * slot — a `true` value routes directly to `'load-active'` without\n * entering `'monitoring'`.\n *\n * @example\n * const reactor = trackLoadTriggers.setup({ state, context });\n * // later:\n * reactor.destroy();\n */\nfunction trackLoadTriggersSetup({\n  state,\n  context,\n}: {\n  state: {\n    loadActivated: Signal<LoadTriggersState['loadActivated']>;\n    presentation: ReadonlySignal<LoadTriggersState['presentation']>;\n  };\n  context: { mediaElement: ReadonlySignal<LoadTriggersContext['mediaElement']> };\n}): Reactor<LoadTriggersFsmState | 'destroying' | 'destroyed'> {\n  const derivedStateSignal = computed(() =>\n    deriveState(state.presentation.get(), context.mediaElement.get(), state.loadActivated.get())\n  );\n  // Sparse-firing source-URL signal. Emits whenever `presentation?.url`\n  // resolves to a different value — covering both URL string changes\n  // (url_a → url_b) and transitions where the URL becomes defined or\n  // undefined (presentation set, cleared, or replaced without a URL\n  // field). Does NOT emit when `state.presentation` is rewritten with\n  // the same URL: manifest parsing, duration calc, track resolution,\n  // and other enrichment paths re-write the presentation object\n  // frequently — tracking raw `state.presentation` here would spuriously\n  // reset the 'load-active' slot.\n  const urlSignal = computed(() => state.presentation.get()?.url);\n\n  return createMachineReactor<LoadTriggersFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      monitoring: {\n        // effects (not entry) so element-identity change within this state\n        // re-fires and re-attaches listeners to the new element. The monitor\n        // guarantees mediaElement is truthy while we're in this state.\n        effects: () => {\n          const el = context.mediaElement.get()!;\n\n          const setLoadActivated = () => state.loadActivated.set(true);\n          if (el.autoplay || !el.paused || el.seeking) {\n            setLoadActivated();\n            return;\n          }\n          const cleanupPlay = listen(el, 'play', setLoadActivated);\n          const cleanupSeeking = listen(el, 'seeking', setLoadActivated);\n          return () => {\n            cleanupPlay();\n            cleanupSeeking();\n          };\n        },\n      },\n\n      'load-active': {\n        // effects-based cleanup (not entry) because the cleanup must fire on\n        // BOTH state exit AND within-state identity change (url_a → url_b,\n        // element_a → element_b — both truthy, no state transition).\n        // Re-firing tracked reads → cleanup writes loadActivated=false →\n        // deriveState (which reads loadActivated) returns 'monitoring' →\n        // state transitions → fresh listeners attached for the new source.\n        effects: () => {\n          context.mediaElement.get();\n          urlSignal.get();\n          return () => state.loadActivated.set(false);\n        },\n      },\n    },\n  });\n}\n\nexport const trackLoadTriggers = defineBehavior({\n  stateKeys: ['loadActivated', 'presentation'],\n  contextKeys: ['mediaElement'],\n  setup: trackLoadTriggersSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAqDA,SAAS,YACP,cACA,cACA,eACsB;CACtB,IAAI,CAAC,gBAAgB,CAAC,cAAc,KAAK,OAAO;CAChD,IAAI,eAAe,OAAO;CAC1B,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAS,uBAAuB,EAC9B,OACA,WAO6D;CAC7D,MAAM,qBAAqB,eACzB,YAAY,MAAM,aAAa,IAAI,GAAG,QAAQ,aAAa,IAAI,GAAG,MAAM,cAAc,IAAI,CAAC,CAC7F;CAUA,MAAM,YAAY,eAAe,MAAM,aAAa,IAAI,CAAC,EAAE,GAAG;CAE9D,OAAO,qBAA2C;EAChD,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,CAAC;GAExB,YAAY,EAIV,eAAe;IACb,MAAM,KAAK,QAAQ,aAAa,IAAI;IAEpC,MAAM,yBAAyB,MAAM,cAAc,IAAI,IAAI;IAC3D,IAAI,GAAG,YAAY,CAAC,GAAG,UAAU,GAAG,SAAS;KAC3C,iBAAiB;KACjB;IACF;IACA,MAAM,cAAc,OAAO,IAAI,QAAQ,gBAAgB;IACvD,MAAM,iBAAiB,OAAO,IAAI,WAAW,gBAAgB;IAC7D,aAAa;KACX,YAAY;KACZ,eAAe;IACjB;GACF,EACF;GAEA,eAAe,EAOb,eAAe;IACb,QAAQ,aAAa,IAAI;IACzB,UAAU,IAAI;IACd,aAAa,MAAM,cAAc,IAAI,KAAK;GAC5C,EACF;EACF;CACF,CAAC;AACH;AAEA,MAAa,oBAAoB,eAAe;CAC9C,WAAW,CAAC,iBAAiB,cAAc;CAC3C,aAAa,CAAC,cAAc;CAC5B,OAAO;AACT,CAAC"}
+{"version":3,"file":"track-load-triggers.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-load-triggers.ts"],"sourcesContent":["import { listen } from '@videojs/utils/dom';\n\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';\nimport type { MaybeResolvedPresentation } from '../../../media/types';\n\n/** State shape for load-trigger tracking. */\nexport interface LoadTriggersState {\n  /**\n   * Sticky-true per source. Flips to `true` the first time an event occurs that should switch loading behavior from\n   * preload-based to standard load (currently DOM `play` / `seeking`). Reset to `false` on source change.\n   *\n   * Read by `resolvePresentation` and `loadVideoSegments` / `loadAudioSegments` to mirror native `HTMLMediaElement`\n   * preload semantics — only meaningful when `preload !== 'auto'`, which already loads fully regardless.\n   */\n  loadActivated?: boolean;\n  /** Current presentation — URL is used to detect source changes. */\n  presentation?: MaybeResolvedPresentation;\n}\n\n/** Context shape for load-trigger tracking. */\nexport interface LoadTriggersContext {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\ntype LoadTriggersFsmState = 'preconditions-unmet' | 'monitoring' | 'load-active';\n\n/**\n * Slot-driven FSM. The slot `loadActivated` is the canonical externally- observable state; `deriveState` reads it (and\n * the preconditions) to derive the local FSM state. The slot is _both_ the state and the data — no separate internal\n * bookkeeping.\n *\n *     'preconditions-unmet' ⟷ 'monitoring' ⟷ 'load-active'\n *\n *     preconditions-unmet → monitoring        element + URL appear\n *     monitoring          → load-active       slot flips true (listener fires\n *                                             or external write)\n *     load-active         → monitoring        within-state cleanup resets slot\n *                                             (URL or element identity change)\n *     any                 → preconditions-unmet  element or URL → undefined\n *\n *     any state → destroying → destroyed       on destroy()\n */\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaElement: HTMLMediaElement | undefined,\n  loadActivated: boolean | undefined\n): LoadTriggersFsmState {\n  if (!mediaElement || !presentation?.url) return 'preconditions-unmet';\n\n  if (loadActivated) return 'load-active';\n\n  return 'monitoring';\n}\n\n/**\n * Track preload-overriding events per source.\n *\n * Writes `state.loadActivated = true` the first time a `play` or `seeking` event fires on the attached media element\n * for the current source — or immediately on entry if the element is already committed to loading (`el.autoplay`,\n * `!el.paused`, or `el.seeking`), covering autoplay, native-controls, and direct-DOM-`play()` scenarios.\n *\n * Sticky-true _within a source identity_: subsequent play/pause/seek cycles don't flip back. Source identity =\n * (mediaElement, presentation URL). Either changing — including direct in-place swap with no `undefined` intermediate —\n * resets the slot to `false`.\n *\n * Multi-writer with `hls/adapter.ts:play()` (which writes `true` directly on programmatic play) is intentional —\n * different domains. The adapter records programmatic intent; this behavior is the DOM-side observer. Pre-existing\n * `true` writes are honored because `deriveState` reads the slot — a `true` value routes directly to `'load-active'`\n * without entering `'monitoring'`.\n *\n * @example\n *   const reactor = trackLoadTriggers.setup({ state, context });\n *   // later:\n *   reactor.destroy();\n */\nfunction trackLoadTriggersSetup({\n  state,\n  context,\n}: {\n  state: {\n    loadActivated: Signal<LoadTriggersState['loadActivated']>;\n    presentation: ReadonlySignal<LoadTriggersState['presentation']>;\n  };\n  context: { mediaElement: ReadonlySignal<LoadTriggersContext['mediaElement']> };\n}): Reactor<LoadTriggersFsmState | 'destroying' | 'destroyed'> {\n  const derivedStateSignal = computed(() =>\n    deriveState(state.presentation.get(), context.mediaElement.get(), state.loadActivated.get())\n  );\n  // Sparse-firing source-URL signal. Emits whenever `presentation?.url`\n  // resolves to a different value — covering both URL string changes\n  // (url_a → url_b) and transitions where the URL becomes defined or\n  // undefined (presentation set, cleared, or replaced without a URL\n  // field). Does NOT emit when `state.presentation` is rewritten with\n  // the same URL: manifest parsing, duration calc, track resolution,\n  // and other enrichment paths re-write the presentation object\n  // frequently — tracking raw `state.presentation` here would spuriously\n  // reset the 'load-active' slot.\n  const urlSignal = computed(() => state.presentation.get()?.url);\n\n  return createMachineReactor<LoadTriggersFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      monitoring: {\n        // effects (not entry) so element-identity change within this state\n        // re-fires and re-attaches listeners to the new element. The monitor\n        // guarantees mediaElement is truthy while we're in this state.\n        effects: () => {\n          const el = context.mediaElement.get()!;\n\n          const setLoadActivated = () => state.loadActivated.set(true);\n\n          if (el.autoplay || !el.paused || el.seeking) {\n            setLoadActivated();\n            return;\n          }\n\n          const cleanupPlay = listen(el, 'play', setLoadActivated);\n          const cleanupSeeking = listen(el, 'seeking', setLoadActivated);\n\n          return () => {\n            cleanupPlay();\n            cleanupSeeking();\n          };\n        },\n      },\n\n      'load-active': {\n        // effects-based cleanup (not entry) because the cleanup must fire on\n        // BOTH state exit AND within-state identity change (url_a → url_b,\n        // element_a → element_b — both truthy, no state transition).\n        // Re-firing tracked reads → cleanup writes loadActivated=false →\n        // deriveState (which reads loadActivated) returns 'monitoring' →\n        // state transitions → fresh listeners attached for the new source.\n        effects: () => {\n          context.mediaElement.get();\n          urlSignal.get();\n          return () => state.loadActivated.set(false);\n        },\n      },\n    },\n  });\n}\n\nexport const trackLoadTriggers = defineBehavior({\n  stateKeys: ['loadActivated', 'presentation'],\n  contextKeys: ['mediaElement'],\n  setup: trackLoadTriggersSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA6CA,SAAS,YACP,cACA,cACA,eACsB;CACtB,IAAI,CAAC,gBAAgB,CAAC,cAAc,KAAK,OAAO;CAEhD,IAAI,eAAe,OAAO;CAE1B,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAS,uBAAuB,EAC9B,OACA,WAO6D;CAC7D,MAAM,qBAAqB,eACzB,YAAY,MAAM,aAAa,IAAI,GAAG,QAAQ,aAAa,IAAI,GAAG,MAAM,cAAc,IAAI,CAAC,CAC7F;CAUA,MAAM,YAAY,eAAe,MAAM,aAAa,IAAI,CAAC,EAAE,GAAG;CAE9D,OAAO,qBAA2C;EAChD,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,CAAC;GAExB,YAAY,EAIV,eAAe;IACb,MAAM,KAAK,QAAQ,aAAa,IAAI;IAEpC,MAAM,yBAAyB,MAAM,cAAc,IAAI,IAAI;IAE3D,IAAI,GAAG,YAAY,CAAC,GAAG,UAAU,GAAG,SAAS;KAC3C,iBAAiB;KACjB;IACF;IAEA,MAAM,cAAc,OAAO,IAAI,QAAQ,gBAAgB;IACvD,MAAM,iBAAiB,OAAO,IAAI,WAAW,gBAAgB;IAE7D,aAAa;KACX,YAAY;KACZ,eAAe;IACjB;GACF,EACF;GAEA,eAAe,EAOb,eAAe;IACb,QAAQ,aAAa,IAAI;IACzB,UAAU,IAAI;IACd,aAAa,MAAM,cAAc,IAAI,KAAK;GAC5C,EACF;EACF;CACF,CAAC;AACH;AAEA,MAAa,oBAAoB,eAAe;CAC9C,WAAW,CAAC,iBAAiB,cAAc;CAC3C,aAAa,CAAC,cAAc;CAC5B,OAAO;AACT,CAAC"}