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

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

@@ -0,0 +1,124 @@
+import { computed, peek } from "../../../core/signals/primitives.js";
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { createMachineReactor } from "../../../core/reactors/create-machine-reactor.js";
+import { getTracksByType } from "../../../media/utils/tracks.js";
+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.
+*
+* 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.
+*
+* 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.
+*/
+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
+* language (precise within a source, just not portable).
+*/
+function deriveTextTrackIntent(showingId, modelTextTracks) {
+	if (!showingId) return "off";
+	const language = modelTextTracks.find((track) => track.id === showingId)?.language;
+	return language ? { language } : { id: showingId };
+}
+function syncTextTracksSetup({ state, context, config }) {
+	const { addSubtitlesTracksToMedia, getShowingSubtitlesTrackFromMedia, removeAllSubtitlesTracksFromMedia } = config;
+	const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaElement.get()));
+	return createMachineReactor({
+		initial: "preconditions-unmet",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"preconditions-unmet": {},
+			"sync-active": {
+				entry: () => {
+					const mediaElement = context.mediaElement.get();
+					const modelTextTracks = getTracksByType(state.presentation.get(), "text");
+					addSubtitlesTracksToMedia(mediaElement, modelTextTracks);
+					syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());
+					let inSettlingWindow = true;
+					const settlingTimeout = setTimeout(() => {
+						inSettlingWindow = false;
+					}, 0);
+					const onChange = () => {
+						if (inSettlingWindow) {
+							syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());
+							return;
+						}
+						const showingId = getShowingSubtitlesTrackFromMedia(mediaElement)?.id || void 0;
+						if (showingId === state.selectedTextTrackId.get()) return;
+						state.userTextTrackSelection.set(deriveTextTrackIntent(showingId, modelTextTracks));
+					};
+					const unlisten = listen(mediaElement.textTracks, "change", onChange);
+					return () => {
+						unlisten();
+						clearTimeout(settlingTimeout);
+						removeAllSubtitlesTracksFromMedia(mediaElement);
+						peek(context.textTracksActor)?.send({ type: "clear" });
+					};
+				},
+				effects: () => {
+					syncTextTrackModes(peek(context.mediaElement).textTracks, state.selectedTextTrackId.get());
+				}
+			}
+		}
+	});
+}
+const syncTextTracks = defineBehavior({
+	stateKeys: [
+		"presentation",
+		"selectedTextTrackId",
+		"userTextTrackSelection"
+	],
+	contextKeys: ["mediaElement", "textTracksActor"],
+	setup: syncTextTracksSetup
+});
+//#endregion
+export { syncTextTracks };
+
+//# sourceMappingURL=sync-text-tracks.js.map

package/dist/dev/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/dev/playback/behaviors/dom/track-current-time.d.ts

@@ -0,0 +1,33 @@
+import { ReadonlySignal, Signal } from "../../../core/signals/primitives.js";
+//#region src/playback/behaviors/dom/track-current-time.d.ts
+interface CurrentTimeState {
+  currentTime?: number;
+}
+interface CurrentTimeContext {
+  mediaElement?: HTMLMediaElement | undefined;
+}
+interface TrackCurrentTimeConfig {
+  /**
+   * Value written to `state.currentTime` when no media element is attached.
+   * Defaults to `0` — the HTMLMediaElement spec default.
+   */
+  defaultCurrentTime?: number;
+}
+declare const trackCurrentTime: {
+  stateKeys: readonly ["currentTime"];
+  contextKeys: readonly ["mediaElement"];
+  setup: (deps: {
+    state: {
+      currentTime: Signal<CurrentTimeState['currentTime']>;
+    };
+  } & {
+    context: {
+      mediaElement: ReadonlySignal<CurrentTimeContext['mediaElement']>;
+    };
+  } & {
+    config: TrackCurrentTimeConfig;
+  }) => () => void;
+};
+//#endregion
+export { CurrentTimeContext, CurrentTimeState, TrackCurrentTimeConfig, trackCurrentTime };
+//# sourceMappingURL=track-current-time.d.ts.map

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

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

package/dist/dev/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/dev/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/dev/playback/behaviors/dom/track-load-triggers.d.ts

@@ -0,0 +1,47 @@
+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.
+ */
+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.
+   *
+   * 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.
+ */
+interface LoadTriggersContext {
+  mediaElement?: HTMLMediaElement | undefined;
+}
+type LoadTriggersFsmState = 'preconditions-unmet' | 'monitoring' | 'load-active';
+declare const trackLoadTriggers: {
+  stateKeys: readonly ["loadActivated", "presentation"];
+  contextKeys: readonly ["mediaElement"];
+  setup: (deps: {
+    state: {
+      loadActivated: Signal<LoadTriggersState['loadActivated']>;
+      presentation: ReadonlySignal<LoadTriggersState['presentation']>;
+    };
+  } & {
+    context: {
+      mediaElement: ReadonlySignal<LoadTriggersContext['mediaElement']>;
+    };
+  } & {
+    config?: {};
+  }) => Reactor<"destroyed" | "destroying" | LoadTriggersFsmState>;
+};
+//#endregion
+export { LoadTriggersContext, LoadTriggersState, trackLoadTriggers };
+//# sourceMappingURL=track-load-triggers.d.ts.map

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

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

package/dist/dev/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/dev/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/dev/playback/behaviors/dom/track-playback-rate.d.ts

@@ -0,0 +1,33 @@
+import { ReadonlySignal, Signal } from "../../../core/signals/primitives.js";
+//#region src/playback/behaviors/dom/track-playback-rate.d.ts
+interface PlaybackRateState {
+  playbackRate?: number;
+}
+interface PlaybackRateContext {
+  mediaElement?: HTMLMediaElement | undefined;
+}
+interface TrackPlaybackRateConfig {
+  /**
+   * Value written to `state.playbackRate` when no media element is attached.
+   * Defaults to `1` — the HTMLMediaElement spec default.
+   */
+  defaultPlaybackRate?: number;
+}
+declare const trackPlaybackRate: {
+  stateKeys: readonly ["playbackRate"];
+  contextKeys: readonly ["mediaElement"];
+  setup: (deps: {
+    state: {
+      playbackRate: Signal<PlaybackRateState['playbackRate']>;
+    };
+  } & {
+    context: {
+      mediaElement: ReadonlySignal<PlaybackRateContext['mediaElement']>;
+    };
+  } & {
+    config: TrackPlaybackRateConfig;
+  }) => () => void;
+};
+//#endregion
+export { PlaybackRateContext, PlaybackRateState, TrackPlaybackRateConfig, trackPlaybackRate };
+//# sourceMappingURL=track-playback-rate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"track-playback-rate.d.ts","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-playback-rate.ts"],"mappings":";;UAgBiB;EACf;;UAGe;EACf,eAAe;;UAGA;;;;;EAKf;;cA2BW;;;;;MAnBY,cAAA,OAAO;;;;MACL,cAAA,eAAe"}

package/dist/dev/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/dev/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/dev/playback/behaviors/dom/track-player-resolution.d.ts

@@ -0,0 +1,8 @@
+import "../../../core/signals/primitives.js";
+import { Resolution } from "../../../media/primitives/resolution.js";
+//#region src/playback/behaviors/dom/track-player-resolution.d.ts
+/** A player element's rendered pixel dimensions. */
+type PlayerResolution = Resolution;
+//#endregion
+export { PlayerResolution };
+//# sourceMappingURL=track-player-resolution.d.ts.map

package/dist/dev/playback/behaviors/dom/track-player-resolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-player-resolution.d.ts","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-player-resolution.ts"],"mappings":";;;;KA6BY,mBAAmB"}

package/dist/dev/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/dev/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/dev/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/dev/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"}