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

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

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

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

@@ -0,0 +1,52 @@
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { effect } from "../../../core/signals/effect.js";
+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.
+*
+* 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
+* `state.currentTime` back to the element.
+*/
+function trackCurrentTimeSetup({ state, context, config }) {
+	const defaultCurrentTime = config?.defaultCurrentTime ?? 0;
+	return effect(() => {
+		const mediaElement = context.mediaElement.get();
+		if (!mediaElement) {
+			state.currentTime.set(defaultCurrentTime);
+			return;
+		}
+		const sync = () => state.currentTime.set(mediaElement.currentTime);
+		sync();
+		const removeEmptied = listen(mediaElement, "emptied", sync);
+		const removeTimeupdate = listen(mediaElement, "timeupdate", sync);
+		const removeSeeking = listen(mediaElement, "seeking", sync);
+		return () => {
+			removeEmptied();
+			removeTimeupdate();
+			removeSeeking();
+		};
+	});
+}
+const trackCurrentTime = defineBehavior({
+	stateKeys: ["currentTime"],
+	contextKeys: ["mediaElement"],
+	setup: trackCurrentTimeSetup
+});
+//#endregion
+export { trackCurrentTime };
+
+//# sourceMappingURL=track-current-time.js.map

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

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

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

@@ -0,0 +1,94 @@
+import { computed } from "../../../core/signals/primitives.js";
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { createMachineReactor } from "../../../core/reactors/create-machine-reactor.js";
+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.
+*
+* ```
+* '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
+*
+* any state → destroying → destroyed       on destroy()
+* ```
+*/
+function deriveState(presentation, mediaElement, loadActivated) {
+	if (!mediaElement || !presentation?.url) return "preconditions-unmet";
+	if (loadActivated) return "load-active";
+	return "monitoring";
+}
+/**
+* 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.
+*
+* 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'`.
+*
+* @example
+* 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()));
+	const urlSignal = computed(() => state.presentation.get()?.url);
+	return createMachineReactor({
+		initial: "preconditions-unmet",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"preconditions-unmet": {},
+			monitoring: { effects: () => {
+				const el = context.mediaElement.get();
+				const setLoadActivated = () => state.loadActivated.set(true);
+				if (el.autoplay || !el.paused || el.seeking) {
+					setLoadActivated();
+					return;
+				}
+				const cleanupPlay = listen(el, "play", setLoadActivated);
+				const cleanupSeeking = listen(el, "seeking", setLoadActivated);
+				return () => {
+					cleanupPlay();
+					cleanupSeeking();
+				};
+			} },
+			"load-active": { effects: () => {
+				context.mediaElement.get();
+				urlSignal.get();
+				return () => state.loadActivated.set(false);
+			} }
+		}
+	});
+}
+const trackLoadTriggers = defineBehavior({
+	stateKeys: ["loadActivated", "presentation"],
+	contextKeys: ["mediaElement"],
+	setup: trackLoadTriggersSetup
+});
+//#endregion
+export { trackLoadTriggers };
+
+//# sourceMappingURL=track-load-triggers.js.map

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

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

package/dist/default/playback/behaviors/dom/track-playback-rate.js

@@ -0,0 +1,37 @@
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { effect } from "../../../core/signals/effect.js";
+import { listen } from "@videojs/utils/dom";
+//#region src/playback/behaviors/dom/track-playback-rate.ts
+/**
+* Mirror `mediaElement.playbackRate` into reactive state. On each `ratechange`
+* event, write the new value to `state.playbackRate`. Also syncs immediately
+* when a media element becomes available so consumers don't wait for the first
+* event.
+*
+* When no media element is attached, writes `config.defaultPlaybackRate`
+* (default-default `1`, matching the HTMLMediaElement spec) so consumers
+* always see the rate a freshly attached element would have. Read-only mirror;
+* does not push `state.playbackRate` back to the element.
+*/
+function trackPlaybackRateSetup({ state, context, config }) {
+	const defaultPlaybackRate = config?.defaultPlaybackRate ?? 1;
+	return effect(() => {
+		const mediaElement = context.mediaElement.get();
+		if (!mediaElement) {
+			state.playbackRate.set(defaultPlaybackRate);
+			return;
+		}
+		const sync = () => state.playbackRate.set(mediaElement.playbackRate);
+		sync();
+		return listen(mediaElement, "ratechange", sync);
+	});
+}
+const trackPlaybackRate = defineBehavior({
+	stateKeys: ["playbackRate"],
+	contextKeys: ["mediaElement"],
+	setup: trackPlaybackRateSetup
+});
+//#endregion
+export { trackPlaybackRate };
+
+//# sourceMappingURL=track-playback-rate.js.map

package/dist/default/playback/behaviors/dom/track-playback-rate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-playback-rate.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-playback-rate.ts"],"sourcesContent":["/**\n * Mirror `mediaElement.playbackRate` into reactive state. On each `ratechange`\n * event, write the new value to `state.playbackRate`. Also syncs immediately\n * when a media element becomes available so consumers don't wait for the first\n * event.\n *\n * When no media element is attached, writes `config.defaultPlaybackRate`\n * (default-default `1`, matching the HTMLMediaElement spec) so consumers\n * always see the rate a freshly attached element would have. Read-only mirror;\n * does not push `state.playbackRate` 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 PlaybackRateState {\n  playbackRate?: number;\n}\n\nexport interface PlaybackRateContext {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\nexport interface TrackPlaybackRateConfig {\n  /**\n   * Value written to `state.playbackRate` when no media element is attached.\n   * Defaults to `1` — the HTMLMediaElement spec default.\n   */\n  defaultPlaybackRate?: number;\n}\n\nfunction trackPlaybackRateSetup({\n  state,\n  context,\n  config,\n}: {\n  state: { playbackRate: Signal<PlaybackRateState['playbackRate']> };\n  context: { mediaElement: ReadonlySignal<PlaybackRateContext['mediaElement']> };\n  config?: TrackPlaybackRateConfig;\n}): () => void {\n  const defaultPlaybackRate = config?.defaultPlaybackRate ?? 1;\n\n  return effect(() => {\n    const mediaElement = context.mediaElement.get();\n    if (!mediaElement) {\n      state.playbackRate.set(defaultPlaybackRate);\n      return;\n    }\n\n    const sync = () => state.playbackRate.set(mediaElement.playbackRate);\n    sync();\n    return listen(mediaElement, 'ratechange', sync);\n  });\n}\n\nexport const trackPlaybackRate = defineBehavior({\n  stateKeys: ['playbackRate'],\n  contextKeys: ['mediaElement'],\n  setup: trackPlaybackRateSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;AAgCA,SAAS,uBAAuB,EAC9B,OACA,SACA,UAKa;CACb,MAAM,sBAAsB,QAAQ,uBAAuB;CAE3D,OAAO,aAAa;EAClB,MAAM,eAAe,QAAQ,aAAa,IAAI;EAC9C,IAAI,CAAC,cAAc;GACjB,MAAM,aAAa,IAAI,mBAAmB;GAC1C;EACF;EAEA,MAAM,aAAa,MAAM,aAAa,IAAI,aAAa,YAAY;EACnE,KAAK;EACL,OAAO,OAAO,cAAc,cAAc,IAAI;CAChD,CAAC;AACH;AAEA,MAAa,oBAAoB,eAAe;CAC9C,WAAW,CAAC,cAAc;CAC1B,aAAa,CAAC,cAAc;CAC5B,OAAO;AACT,CAAC"}

package/dist/default/playback/behaviors/dom/track-player-resolution.js

@@ -0,0 +1,57 @@
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { effect } from "../../../core/signals/effect.js";
+import { scaleResolution } from "../../../media/primitives/resolution.js";
+import { observeElementSize, observeRenderedSize } from "@videojs/utils/dom";
+import { shallowEqual } from "@videojs/utils/object";
+//#region src/playback/behaviors/dom/track-player-resolution.ts
+/**
+* Mirror the player element's rendered pixel dimensions into reactive state, so
+* a rendition cap can narrow candidates to what the element can actually show
+* without reading the DOM at pick time — which would make the picker impure, and
+* would never re-pick when the element resized.
+*
+* The player-element half of the caps in
+* `internal/design/spf/features/rendition-selection-caps.md`, and the tighter
+* half: a small embed on a large display is capped by its own box rather than by
+* the screen behind it (`trackScreenResolution`).
+*
+* Reported as a width and a height in device pixels — the same units, and for the
+* same reason, as `media/dom/screen`'s reading: the cap compares against real
+* track dimensions, and a `"720p"`-style tier only describes a track once you
+* assume its aspect ratio.
+*
+* `undefined` where there is nothing to measure — no element attached, or one
+* that isn't being rendered (detached, `display: none`, not yet laid out) — which
+* is the value the cap reads as "don't cap".
+*/
+function trackPlayerResolutionSetup({ state, context, config = {} }) {
+	const { capRenditionToPlayerSize = true, useDevicePixelRatio = true } = config;
+	return effect(() => {
+		const mediaElement = context.mediaElement.get();
+		let current;
+		state.playerResolution.set(current);
+		if (!capRenditionToPlayerSize || !mediaElement) return;
+		const write = (size) => {
+			const next = scaleResolution(size, size.scale);
+			if (shallowEqual(current, next)) return;
+			current = next;
+			state.playerResolution.set(next);
+		};
+		return useDevicePixelRatio ? observeRenderedSize(mediaElement, write) : observeElementSize(mediaElement, write);
+	});
+}
+/**
+* Track the player element's rendered resolution in `state.playerResolution`.
+*
+* @example
+* const cleanup = trackPlayerResolution.setup({ state, context });
+*/
+const trackPlayerResolution = defineBehavior({
+	stateKeys: ["playerResolution"],
+	contextKeys: ["mediaElement"],
+	setup: trackPlayerResolutionSetup
+});
+//#endregion
+export { trackPlayerResolution };
+
+//# sourceMappingURL=track-player-resolution.js.map

package/dist/default/playback/behaviors/dom/track-player-resolution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-player-resolution.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-player-resolution.ts"],"sourcesContent":["/**\n * Mirror the player element's rendered pixel dimensions into reactive state, so\n * a rendition cap can narrow candidates to what the element can actually show\n * without reading the DOM at pick time — which would make the picker impure, and\n * would never re-pick when the element resized.\n *\n * The player-element half of the caps in\n * `internal/design/spf/features/rendition-selection-caps.md`, and the tighter\n * half: a small embed on a large display is capped by its own box rather than by\n * the screen behind it (`trackScreenResolution`).\n *\n * Reported as a width and a height in device pixels — the same units, and for the\n * same reason, as `media/dom/screen`'s reading: the cap compares against real\n * track dimensions, and a `\"720p\"`-style tier only describes a track once you\n * assume its aspect ratio.\n *\n * `undefined` where there is nothing to measure — no element attached, or one\n * that isn't being rendered (detached, `display: none`, not yet laid out) — which\n * is the value the cap reads as \"don't cap\".\n */\n\nimport { type ElementSize, observeElementSize, observeRenderedSize } from '@videojs/utils/dom';\nimport { shallowEqual } from '@videojs/utils/object';\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport type { ReadonlySignal, Signal } from '../../../core/signals/primitives';\nimport { type Resolution, scaleResolution } from '../../../media/primitives/resolution';\n\n/** A player element's rendered pixel dimensions. */\nexport type PlayerResolution = Resolution;\n\nexport interface PlayerResolutionState {\n  playerResolution?: PlayerResolution;\n}\n\nexport interface PlayerResolutionContext {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\nexport interface TrackPlayerResolutionConfig {\n  /**\n   * Whether to cap renditions to the player's rendered size at all. `false`\n   * measures nothing, which leaves `state.playerResolution` unset and the cap\n   * inert. Defaults to `true`.\n   *\n   * Named for the policy rather than the measurement because it is the public\n   * switch for the feature — the same one hls.js spells `capLevelToPlayerSize`\n   * and the Mux Video element spells `cap-rendition-to-player-size`.\n   */\n  capRenditionToPlayerSize?: boolean;\n  /**\n   * Whether the reading is scaled into device pixels. Defaults to `true` — see\n   * `ScreenResolutionOptions.useDevicePixelRatio` in `media/dom/screen.ts`,\n   * including its note on page zoom being folded into the ratio outside WebKit.\n   */\n  useDevicePixelRatio?: boolean;\n}\n\nfunction trackPlayerResolutionSetup({\n  state,\n  context,\n  config = {},\n}: {\n  state: { playerResolution: Signal<PlayerResolutionState['playerResolution']> };\n  context: { mediaElement: ReadonlySignal<PlayerResolutionContext['mediaElement']> };\n  config?: TrackPlayerResolutionConfig;\n}): () => void {\n  const { capRenditionToPlayerSize = true, useDevicePixelRatio = true } = config;\n\n  return effect(() => {\n    const mediaElement = context.mediaElement.get();\n    // Clear before (re-)observing so the previous element's measurement can't\n    // stand while the new one's first observation is in flight.\n    let current: PlayerResolution | undefined;\n    state.playerResolution.set(current);\n    if (!capRenditionToPlayerSize || !mediaElement) return;\n\n    // Compared rather than written straight through, since the slot holds an\n    // object and would otherwise notify on identity alone: a resize that rounds\n    // to the same device pixels is not a change worth re-running selection for.\n    // Same reason `watchScreenResolution` compares its readings.\n    const write = (size: ElementSize & { scale?: number }) => {\n      const next = scaleResolution(size, size.scale);\n      if (shallowEqual(current, next)) return;\n\n      current = next;\n      state.playerResolution.set(next);\n    };\n\n    return useDevicePixelRatio ? observeRenderedSize(mediaElement, write) : observeElementSize(mediaElement, write);\n  });\n}\n\n/**\n * Track the player element's rendered resolution in `state.playerResolution`.\n *\n * @example\n * const cleanup = trackPlayerResolution.setup({ state, context });\n */\nexport const trackPlayerResolution = defineBehavior({\n  stateKeys: ['playerResolution'],\n  contextKeys: ['mediaElement'],\n  setup: trackPlayerResolutionSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,SAAS,2BAA2B,EAClC,OACA,SACA,SAAS,CAAC,KAKG;CACb,MAAM,EAAE,2BAA2B,MAAM,sBAAsB,SAAS;CAExE,OAAO,aAAa;EAClB,MAAM,eAAe,QAAQ,aAAa,IAAI;EAG9C,IAAI;EACJ,MAAM,iBAAiB,IAAI,OAAO;EAClC,IAAI,CAAC,4BAA4B,CAAC,cAAc;EAMhD,MAAM,SAAS,SAA2C;GACxD,MAAM,OAAO,gBAAgB,MAAM,KAAK,KAAK;GAC7C,IAAI,aAAa,SAAS,IAAI,GAAG;GAEjC,UAAU;GACV,MAAM,iBAAiB,IAAI,IAAI;EACjC;EAEA,OAAO,sBAAsB,oBAAoB,cAAc,KAAK,IAAI,mBAAmB,cAAc,KAAK;CAChH,CAAC;AACH;;;;;;;AAQA,MAAa,wBAAwB,eAAe;CAClD,WAAW,CAAC,kBAAkB;CAC9B,aAAa,CAAC,cAAc;CAC5B,OAAO;AACT,CAAC"}

package/dist/default/playback/behaviors/dom/track-screen-resolution.js

@@ -0,0 +1,29 @@
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { watchScreenResolution } from "../../../media/dom/screen.js";
+//#region src/playback/behaviors/dom/track-screen-resolution.ts
+/**
+* Mirror the screen's pixel dimensions into reactive state, so a rendition cap
+* can narrow candidates to what the screen can actually show without reading the
+* environment at pick time — which would make the picker impure, and would never
+* re-pick when the screen changed.
+*
+* Populated at setup rather than on the first change: `watchScreenResolution`
+* reports its starting value, so nothing downstream waits on a screen that may
+* never move. `undefined` where there is no screen to read, which is the value a
+* cap reads as "no cap" — see `getScreenResolution` on why that beats a zero.
+*
+* Reads no other slot, and has no source-identity reset: the screen is
+* independent of the presentation, so a new `src` doesn't invalidate the reading.
+*/
+function trackScreenResolutionSetup({ state, config }) {
+	return watchScreenResolution((resolution) => state.screenResolution.set(resolution), { useDevicePixelRatio: config?.useDevicePixelRatio ?? true });
+}
+const trackScreenResolution = defineBehavior({
+	stateKeys: ["screenResolution"],
+	contextKeys: [],
+	setup: trackScreenResolutionSetup
+});
+//#endregion
+export { trackScreenResolution };
+
+//# sourceMappingURL=track-screen-resolution.js.map

package/dist/default/playback/behaviors/dom/track-screen-resolution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-screen-resolution.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-screen-resolution.ts"],"sourcesContent":["/**\n * Mirror the screen's pixel dimensions into reactive state, so a rendition cap\n * can narrow candidates to what the screen can actually show without reading the\n * environment at pick time — which would make the picker impure, and would never\n * re-pick when the screen changed.\n *\n * Populated at setup rather than on the first change: `watchScreenResolution`\n * reports its starting value, so nothing downstream waits on a screen that may\n * never move. `undefined` where there is no screen to read, which is the value a\n * cap reads as \"no cap\" — see `getScreenResolution` on why that beats a zero.\n *\n * Reads no other slot, and has no source-identity reset: the screen is\n * independent of the presentation, so a new `src` doesn't invalidate the reading.\n */\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Signal } from '../../../core/signals/primitives';\nimport { type ScreenResolution, watchScreenResolution } from '../../../media/dom/screen';\n\nexport interface ScreenResolutionState {\n  screenResolution?: ScreenResolution;\n}\n\nexport interface TrackScreenResolutionConfig {\n  /**\n   * Whether the reading is scaled into device pixels. Defaults to `true` — see\n   * `ScreenResolutionOptions.useDevicePixelRatio`, including its note on page\n   * zoom being folded into the ratio outside WebKit.\n   */\n  useDevicePixelRatio?: boolean;\n}\n\nfunction trackScreenResolutionSetup({\n  state,\n  config,\n}: {\n  state: { screenResolution: Signal<ScreenResolutionState['screenResolution']> };\n  config?: TrackScreenResolutionConfig;\n}): () => void {\n  const useDevicePixelRatio = config?.useDevicePixelRatio ?? true;\n\n  // No `effect` wrapper, unlike its `track*` siblings: they re-subscribe when\n  // `context.mediaElement` changes, and this behavior has no reactive dependency\n  // to re-run on. The watcher's own teardown is the whole cleanup.\n  return watchScreenResolution((resolution) => state.screenResolution.set(resolution), { useDevicePixelRatio });\n}\n\nexport const trackScreenResolution = defineBehavior({\n  stateKeys: ['screenResolution'],\n  contextKeys: [],\n  setup: trackScreenResolutionSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;AA+BA,SAAS,2BAA2B,EAClC,OACA,UAIa;CAMb,OAAO,uBAAuB,eAAe,MAAM,iBAAiB,IAAI,UAAU,GAAG,EAAE,qBAL3D,QAAQ,uBAAuB,KAKgD,CAAC;AAC9G;AAEA,MAAa,wBAAwB,eAAe;CAClD,WAAW,CAAC,kBAAkB;CAC9B,aAAa,CAAC;CACd,OAAO;AACT,CAAC"}

package/dist/default/playback/behaviors/dom/update-mediasource-duration.js

@@ -0,0 +1,113 @@
+import { computed } from "../../../core/signals/primitives.js";
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { createMachineReactor } from "../../../core/reactors/create-machine-reactor.js";
+import { waitForMediaSourceOpen } from "../../../media/dom/mse/mediasource-setup.js";
+import { getMaxBufferedEnd, shouldUpdateDuration, waitForSourceBuffersReady } from "../../../media/dom/mse/duration.js";
+//#region src/playback/behaviors/dom/update-mediasource-duration.ts
+/**
+* **Propagate `presentation.duration` to `mediaSource.duration` — exactly
+* once per MediaSource.**
+*
+* Two paths, by whether the presentation is live:
+*
+* - **Live** (`presentation.duration === Infinity`): write `Infinity` once the
+*   MediaSource is open and no SourceBuffer is mid-append. No buffered clamp is
+*   needed (`Infinity` ≥ any range) and — unlike the finite case — it needn't
+*   precede the first append: `Infinity` overrides whatever finite live-edge
+*   value an append may have pinned (a finite duration would otherwise stall
+*   the stream once the window slides past it). The wait-for-idle is required
+*   because the MSE spec forbids setting `duration` while a buffer is
+*   `updating`; both waits resolve immediately when already open / idle.
+*
+* - **VoD** (finite): the value is written once, after `mediaSource` is open and
+*   all SourceBuffers are idle, clamped to be ≥ the highest buffered range (MSE
+*   spec). Written only while `mediaSource.duration` is still `NaN`; once any
+*   non-NaN value is present (us on a prior entry, or `endOfStream` from the
+*   buffered end), the property is left alone — re-syncing would race
+*   concurrent `appendBuffer()` calls.
+*
+* The entry resolves three async preconditions in order before writing:
+*
+* 1. **MediaSource open** — `waitForMediaSourceOpen` defers until the first
+*    `sourceopen` event (or any readyState transition, since `'ended'` /
+*    `'closed'` mean we've missed the window and should bail).
+* 2. **All SourceBuffers idle** — `waitForSourceBuffersReady` defers per
+*    the MSE-spec rule that `duration` cannot be set while any buffer has
+*    `updating === true`.
+* 3. **Buffered-range clamp** — `getMaxBufferedEnd` ensures the written
+*    duration is at least the highest buffered end (MSE spec disallows
+*    a smaller `duration` than any buffered range).
+*
+* The buffer-set helpers operate across `mediaSource.sourceBuffers` (the
+* canonical aggregate), so the behavior composes uniformly across
+* audio-only, video-only, and mixed configurations.
+*
+* Single-positive-state reactor (`'preconditions-unmet'` ↔ `'duration-writable'`):
+* state derivation is purely signal-driven (presentation validity +
+* mediaSource existence). MediaSource lifecycle state (`readyState`) and
+* the `duration` itself are non-signal DOM properties resolved inside the
+* entry's async sequence. The state-exit cleanup aborts the in-flight
+* wait, so source resets and behavior destroy structurally cancel the
+* pending write. A post-await re-check of `mediaSource.readyState ===
+* 'open'` covers the narrow race where `endOfStream()` synchronously
+* transitions readyState to `'ended'` between our `waitForMediaSourceOpen`
+* resolution and the `mediaSource.duration` write.
+*
+* Downstream of `calculatePresentationDuration` (which writes
+* `presentation.duration`); concurrent with `endOfStream` (which may later
+* write `mediaSource.duration` — the "exactly once" contract keeps us out
+* of that path).
+*/
+function deriveState(presentation, mediaSource) {
+	return shouldUpdateDuration(presentation, mediaSource) ? "duration-writable" : "preconditions-unmet";
+}
+function updateMediaSourceDurationSetup({ state, context }) {
+	const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaSource.get()));
+	return createMachineReactor({
+		initial: "preconditions-unmet",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"preconditions-unmet": {},
+			"duration-writable": { entry: () => {
+				const presentation = state.presentation.get();
+				const mediaSource = context.mediaSource.get();
+				if (presentation.duration === Number.POSITIVE_INFINITY) {
+					if (mediaSource.duration === Number.POSITIVE_INFINITY) return;
+					const controller = new AbortController();
+					(async () => {
+						await waitForMediaSourceOpen(mediaSource, controller.signal);
+						if (controller.signal.aborted || mediaSource.readyState !== "open") return;
+						await waitForSourceBuffersReady(mediaSource.sourceBuffers, controller.signal);
+						if (controller.signal.aborted || mediaSource.readyState !== "open") return;
+						if (mediaSource.duration !== Number.POSITIVE_INFINITY) mediaSource.duration = Number.POSITIVE_INFINITY;
+					})();
+					return () => controller.abort();
+				}
+				if (!Number.isNaN(mediaSource.duration)) return;
+				const controller = new AbortController();
+				const writeWhenReady = async () => {
+					await waitForMediaSourceOpen(mediaSource, controller.signal);
+					if (controller.signal.aborted) return;
+					if (mediaSource.readyState !== "open") return;
+					await waitForSourceBuffersReady(mediaSource.sourceBuffers, controller.signal);
+					if (controller.signal.aborted) return;
+					if (mediaSource.readyState !== "open") return;
+					const maxBufferedEnd = getMaxBufferedEnd(mediaSource.sourceBuffers);
+					const duration = maxBufferedEnd > presentation.duration ? maxBufferedEnd : presentation.duration;
+					mediaSource.duration = duration;
+				};
+				writeWhenReady();
+				return () => controller.abort();
+			} }
+		}
+	});
+}
+const updateMediaSourceDuration = defineBehavior({
+	stateKeys: ["presentation"],
+	contextKeys: ["mediaSource"],
+	setup: updateMediaSourceDurationSetup
+});
+//#endregion
+export { updateMediaSourceDuration };
+
+//# sourceMappingURL=update-mediasource-duration.js.map

package/dist/default/playback/behaviors/dom/update-mediasource-duration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-mediasource-duration.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/update-mediasource-duration.ts"],"sourcesContent":["/**\n * **Propagate `presentation.duration` to `mediaSource.duration` — exactly\n * once per MediaSource.**\n *\n * Two paths, by whether the presentation is live:\n *\n * - **Live** (`presentation.duration === Infinity`): write `Infinity` once the\n *   MediaSource is open and no SourceBuffer is mid-append. No buffered clamp is\n *   needed (`Infinity` ≥ any range) and — unlike the finite case — it needn't\n *   precede the first append: `Infinity` overrides whatever finite live-edge\n *   value an append may have pinned (a finite duration would otherwise stall\n *   the stream once the window slides past it). The wait-for-idle is required\n *   because the MSE spec forbids setting `duration` while a buffer is\n *   `updating`; both waits resolve immediately when already open / idle.\n *\n * - **VoD** (finite): the value is written once, after `mediaSource` is open and\n *   all SourceBuffers are idle, clamped to be ≥ the highest buffered range (MSE\n *   spec). Written only while `mediaSource.duration` is still `NaN`; once any\n *   non-NaN value is present (us on a prior entry, or `endOfStream` from the\n *   buffered end), the property is left alone — re-syncing would race\n *   concurrent `appendBuffer()` calls.\n *\n * The entry resolves three async preconditions in order before writing:\n *\n * 1. **MediaSource open** — `waitForMediaSourceOpen` defers until the first\n *    `sourceopen` event (or any readyState transition, since `'ended'` /\n *    `'closed'` mean we've missed the window and should bail).\n * 2. **All SourceBuffers idle** — `waitForSourceBuffersReady` defers per\n *    the MSE-spec rule that `duration` cannot be set while any buffer has\n *    `updating === true`.\n * 3. **Buffered-range clamp** — `getMaxBufferedEnd` ensures the written\n *    duration is at least the highest buffered end (MSE spec disallows\n *    a smaller `duration` than any buffered range).\n *\n * The buffer-set helpers operate across `mediaSource.sourceBuffers` (the\n * canonical aggregate), so the behavior composes uniformly across\n * audio-only, video-only, and mixed configurations.\n *\n * Single-positive-state reactor (`'preconditions-unmet'` ↔ `'duration-writable'`):\n * state derivation is purely signal-driven (presentation validity +\n * mediaSource existence). MediaSource lifecycle state (`readyState`) and\n * the `duration` itself are non-signal DOM properties resolved inside the\n * entry's async sequence. The state-exit cleanup aborts the in-flight\n * wait, so source resets and behavior destroy structurally cancel the\n * pending write. A post-await re-check of `mediaSource.readyState ===\n * 'open'` covers the narrow race where `endOfStream()` synchronously\n * transitions readyState to `'ended'` between our `waitForMediaSourceOpen`\n * resolution and the `mediaSource.duration` write.\n *\n * Downstream of `calculatePresentationDuration` (which writes\n * `presentation.duration`); concurrent with `endOfStream` (which may later\n * write `mediaSource.duration` — the \"exactly once\" contract keeps us out\n * of that path).\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 } from '../../../core/signals/primitives';\nimport { getMaxBufferedEnd, shouldUpdateDuration, waitForSourceBuffersReady } from '../../../media/dom/mse/duration';\nimport { waitForMediaSourceOpen } from '../../../media/dom/mse/mediasource-setup';\nimport type { MaybeResolvedPresentation } from '../../../media/types';\n\ntype DurationFsmState = 'preconditions-unmet' | 'duration-writable';\n\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined\n): DurationFsmState {\n  return shouldUpdateDuration(presentation, mediaSource) ? 'duration-writable' : 'preconditions-unmet';\n}\n\nfunction updateMediaSourceDurationSetup({\n  state,\n  context,\n}: {\n  state: { presentation: ReadonlySignal<MaybeResolvedPresentation | undefined> };\n  context: { mediaSource: ReadonlySignal<MediaSource | undefined> };\n}): Reactor<DurationFsmState | 'destroying' | 'destroyed'> {\n  // Purely signal-driven derivation: only `presentation` validity and\n  // `mediaSource` existence. MediaSource lifecycle (`readyState`),\n  // its attached `sourceBuffers`, and `mediaSource.duration` itself are\n  // non-signal DOM properties consumed inside the entry — none of them\n  // sneak into `computed(...)`.\n  const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaSource.get()));\n\n  return createMachineReactor<DurationFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'duration-writable': {\n        // entry body is auto-untracked. The state machine handles source\n        // resets via deriveState; this entry resolves the MediaSource\n        // lifecycle preconditions in sequence and binds its cleanup\n        // (abort) to state exit + destroy.\n        entry: () => {\n          const presentation = state.presentation.get()!;\n          const mediaSource = context.mediaSource.get()!;\n\n          // Live: write Infinity once the MediaSource is open and no buffer is\n          // mid-append (the MSE spec forbids setting `duration` while a\n          // SourceBuffer is `updating`, and racing an in-flight append throws).\n          // No `NaN` guard, unlike the VoD path below — Infinity must override\n          // whatever finite live-edge value an append may have pinned.\n          if (presentation.duration === Number.POSITIVE_INFINITY) {\n            if (mediaSource.duration === Number.POSITIVE_INFINITY) return;\n            const controller = new AbortController();\n            void (async () => {\n              await waitForMediaSourceOpen(mediaSource, controller.signal);\n              if (controller.signal.aborted || mediaSource.readyState !== 'open') return;\n              await waitForSourceBuffersReady(mediaSource.sourceBuffers, controller.signal);\n              if (controller.signal.aborted || mediaSource.readyState !== 'open') return;\n              if (mediaSource.duration !== Number.POSITIVE_INFINITY) {\n                mediaSource.duration = Number.POSITIVE_INFINITY;\n              }\n            })();\n            return () => controller.abort();\n          }\n\n          // VoD idempotency: someone (us on a prior entry, or concurrent\n          // `endOfStream`) has already written. No-op and leave the state\n          // alone — the next source-reset transition will produce a fresh\n          // entry against the new MediaSource (whose `duration` starts at\n          // `NaN` again).\n          if (!Number.isNaN(mediaSource.duration)) return;\n\n          const controller = new AbortController();\n\n          const writeWhenReady = 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' instead of\n            // 'open', the write window is gone.\n            if (mediaSource.readyState !== 'open') return;\n\n            await waitForSourceBuffersReady(mediaSource.sourceBuffers, controller.signal);\n            if (controller.signal.aborted) return;\n\n            // Narrow race: `endOfStream()` synchronously transitions\n            // readyState to 'ended' AND writes `mediaSource.duration`\n            // between our `waitForMediaSourceOpen` resolution and here.\n            // Re-read the DOM property to catch this window.\n            if (mediaSource.readyState !== 'open') return;\n\n            // MSE spec: duration cannot be less than any buffered range.\n            // Re-read sourceBuffers after the await so any buffer added\n            // during the wait is included in the clamp.\n            const maxBufferedEnd = getMaxBufferedEnd(mediaSource.sourceBuffers);\n            const duration = maxBufferedEnd > presentation.duration! ? maxBufferedEnd : presentation.duration!;\n            mediaSource.duration = duration;\n          };\n\n          writeWhenReady();\n\n          return () => controller.abort();\n        },\n      },\n    },\n  });\n}\n\nexport const updateMediaSourceDuration = defineBehavior({\n  stateKeys: ['presentation'],\n  contextKeys: ['mediaSource'],\n  setup: updateMediaSourceDurationSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgEA,SAAS,YACP,cACA,aACkB;CAClB,OAAO,qBAAqB,cAAc,WAAW,IAAI,sBAAsB;AACjF;AAEA,SAAS,+BAA+B,EACtC,OACA,WAIyD;CAMzD,MAAM,qBAAqB,eAAe,YAAY,MAAM,aAAa,IAAI,GAAG,QAAQ,YAAY,IAAI,CAAC,CAAC;CAE1G,OAAO,qBAAuC;EAC5C,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,CAAC;GAExB,qBAAqB,EAKnB,aAAa;IACX,MAAM,eAAe,MAAM,aAAa,IAAI;IAC5C,MAAM,cAAc,QAAQ,YAAY,IAAI;IAO5C,IAAI,aAAa,aAAa,OAAO,mBAAmB;KACtD,IAAI,YAAY,aAAa,OAAO,mBAAmB;KACvD,MAAM,aAAa,IAAI,gBAAgB;KACvC,CAAM,YAAY;MAChB,MAAM,uBAAuB,aAAa,WAAW,MAAM;MAC3D,IAAI,WAAW,OAAO,WAAW,YAAY,eAAe,QAAQ;MACpE,MAAM,0BAA0B,YAAY,eAAe,WAAW,MAAM;MAC5E,IAAI,WAAW,OAAO,WAAW,YAAY,eAAe,QAAQ;MACpE,IAAI,YAAY,aAAa,OAAO,mBAClC,YAAY,WAAW,OAAO;KAElC,EAAA,CAAG;KACH,aAAa,WAAW,MAAM;IAChC;IAOA,IAAI,CAAC,OAAO,MAAM,YAAY,QAAQ,GAAG;IAEzC,MAAM,aAAa,IAAI,gBAAgB;IAEvC,MAAM,iBAAiB,YAAY;KACjC,MAAM,uBAAuB,aAAa,WAAW,MAAM;KAC3D,IAAI,WAAW,OAAO,SAAS;KAI/B,IAAI,YAAY,eAAe,QAAQ;KAEvC,MAAM,0BAA0B,YAAY,eAAe,WAAW,MAAM;KAC5E,IAAI,WAAW,OAAO,SAAS;KAM/B,IAAI,YAAY,eAAe,QAAQ;KAKvC,MAAM,iBAAiB,kBAAkB,YAAY,aAAa;KAClE,MAAM,WAAW,iBAAiB,aAAa,WAAY,iBAAiB,aAAa;KACzF,YAAY,WAAW;IACzB;IAEA,eAAe;IAEf,aAAa,WAAW,MAAM;GAChC,EACF;EACF;CACF,CAAC;AACH;AAEA,MAAa,4BAA4B,eAAe;CACtD,WAAW,CAAC,cAAc;CAC1B,aAAa,CAAC,aAAa;CAC3B,OAAO;AACT,CAAC"}