@videojs/spf 10.0.0-beta.23 → 10.0.0-beta.24

package/dist/default/playback/behaviors/dom/setup-mediasource.js

@@ -0,0 +1,89 @@
+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 { isResolvedPresentation } from "../../../media/types/index.js";
+import { attachMediaSource, createMediaSource, waitForMediaSourceOpen } from "../../../media/dom/mse/mediasource-setup.js";
+//#region src/playback/behaviors/dom/setup-mediasource.ts
+/**
+* **Own the MediaSource lifecycle for the current source.** When a resolved
+* presentation and a mediaElement are both in scope, creates a MediaSource,
+* attaches it to the element, waits for `'open'`, and publishes it on
+* `context.mediaSource`. On source change or behavior destroy, detaches the
+* MediaSource and clears the slot so the next source starts fresh.
+*
+* Single-positive-state reactor (`'preconditions-unmet'` ↔ `'mediasource-attached'`):
+* state derivation gates on `mediaElement + isResolvedPresentation`. Riding the
+* resolver's resolved/unresolved lifecycle makes direct URL replacement
+* structural — `resolvePresentation` routes the presentation back through
+* unresolved on URL change, which drives this reactor through
+* `'preconditions-unmet'` so the entry's state-exit cleanup detaches the old
+* MediaSource before the new one is built.
+*
+* The entry resolves preconditions in sequence before publishing:
+*
+* 1. **Create + attach** — `createMediaSource` + `attachMediaSource` run
+*    synchronously on entry. The `detach` closure returned by
+*    `attachMediaSource` is captured for state-exit cleanup, so the cleanup
+*    is always bound to its setup even if the wait below is aborted.
+* 2. **Wait for `'open'`** — `waitForMediaSourceOpen` defers until the first
+*    `sourceopen` event (or any readyState transition out of `'closed'`).
+* 3. **Publish on `'open'`** — re-check `readyState === 'open'` after the
+*    await (covers `'ended'` / `'closed'` race) before writing to
+*    `context.mediaSource`. Downstream `setupVideoBufferActors` /
+*    `setupAudioBufferActors` call `addSourceBuffer` directly, which
+*    throws on non-open, so publish-only-when-open is the load-bearing
+*    contract.
+*
+* State-exit cleanup aborts the in-flight wait, detaches the MediaSource,
+* and clears `context.mediaSource`. Order: abort first (prevents a late
+* publish racing the slot clear), then detach, then clear.
+*
+* Sole writer of `context.mediaSource`; other MSE behaviors
+* (`setupVideoBufferActors`, `setupAudioBufferActors`,
+* `updateMediaSourceDuration`, `endOfStream`, `loadVideoSegments`) only
+* read.
+*/
+function deriveState(presentation, mediaElement) {
+	if (!mediaElement || !isResolvedPresentation(presentation)) return "preconditions-unmet";
+	return "mediasource-attached";
+}
+function setupMediaSourceSetup({ state, context }) {
+	const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaElement.get()));
+	return createMachineReactor({
+		initial: "preconditions-unmet",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"preconditions-unmet": {},
+			"mediasource-attached": { entry: () => {
+				const mediaElement = context.mediaElement.get();
+				const controller = new AbortController();
+				const mediaSource = createMediaSource({ preferManaged: true });
+				const { detach } = attachMediaSource(mediaSource, mediaElement);
+				const publishWhenOpen = async () => {
+					await waitForMediaSourceOpen(mediaSource, controller.signal);
+					if (controller.signal.aborted) return;
+					if (mediaSource.readyState !== "open") {
+						console.warn(`[setupMediaSource] MediaSource transitioned to '${mediaSource.readyState}' before first 'sourceopen' — slot left unpublished; recoverable on next source reset.`);
+						return;
+					}
+					context.mediaSource.set(mediaSource);
+				};
+				publishWhenOpen().catch((err) => console.error("[setupMediaSource] failed to publish MediaSource:", err));
+				return () => {
+					controller.abort();
+					detach();
+					context.mediaSource.set(void 0);
+				};
+			} }
+		}
+	});
+}
+const setupMediaSource = defineBehavior({
+	stateKeys: ["presentation"],
+	contextKeys: ["mediaElement", "mediaSource"],
+	setup: setupMediaSourceSetup
+});
+//#endregion
+export { setupMediaSource };
+
+//# sourceMappingURL=setup-mediasource.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setup-mediasource.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/setup-mediasource.ts"],"sourcesContent":["/**\n * **Own the MediaSource lifecycle for the current source.** When a resolved\n * presentation and a mediaElement are both in scope, creates a MediaSource,\n * attaches it to the element, waits for `'open'`, and publishes it on\n * `context.mediaSource`. On source change or behavior destroy, detaches the\n * MediaSource and clears the slot so the next source starts fresh.\n *\n * Single-positive-state reactor (`'preconditions-unmet'` ↔ `'mediasource-attached'`):\n * state derivation gates on `mediaElement + isResolvedPresentation`. Riding the\n * resolver's resolved/unresolved lifecycle makes direct URL replacement\n * structural — `resolvePresentation` routes the presentation back through\n * unresolved on URL change, which drives this reactor through\n * `'preconditions-unmet'` so the entry's state-exit cleanup detaches the old\n * MediaSource before the new one is built.\n *\n * The entry resolves preconditions in sequence before publishing:\n *\n * 1. **Create + attach** — `createMediaSource` + `attachMediaSource` run\n *    synchronously on entry. The `detach` closure returned by\n *    `attachMediaSource` is captured for state-exit cleanup, so the cleanup\n *    is always bound to its setup even if the wait below is aborted.\n * 2. **Wait for `'open'`** — `waitForMediaSourceOpen` defers until the first\n *    `sourceopen` event (or any readyState transition out of `'closed'`).\n * 3. **Publish on `'open'`** — re-check `readyState === 'open'` after the\n *    await (covers `'ended'` / `'closed'` race) before writing to\n *    `context.mediaSource`. Downstream `setupVideoBufferActors` /\n *    `setupAudioBufferActors` call `addSourceBuffer` directly, which\n *    throws on non-open, so publish-only-when-open is the load-bearing\n *    contract.\n *\n * State-exit cleanup aborts the in-flight wait, detaches the MediaSource,\n * and clears `context.mediaSource`. Order: abort first (prevents a late\n * publish racing the slot clear), then detach, then clear.\n *\n * Sole writer of `context.mediaSource`; other MSE behaviors\n * (`setupVideoBufferActors`, `setupAudioBufferActors`,\n * `updateMediaSourceDuration`, `endOfStream`, `loadVideoSegments`) only\n * read.\n */\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';\nimport { attachMediaSource, createMediaSource, waitForMediaSourceOpen } from '../../../media/dom/mse/mediasource-setup';\nimport { isResolvedPresentation, type MaybeResolvedPresentation } from '../../../media/types';\n\n/**\n * State shape required for MediaSource setup.\n */\nexport interface MediaSourceState {\n  presentation?: MaybeResolvedPresentation;\n}\n\n/**\n * Context shape for MediaSource setup.\n */\nexport interface MediaSourceContext {\n  mediaElement?: HTMLMediaElement | undefined;\n  mediaSource?: MediaSource;\n}\n\ntype MediaSourceFsmState = 'preconditions-unmet' | 'mediasource-attached';\n\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaElement: HTMLMediaElement | undefined\n): MediaSourceFsmState {\n  if (!mediaElement || !isResolvedPresentation(presentation)) return 'preconditions-unmet';\n  return 'mediasource-attached';\n}\n\nfunction setupMediaSourceSetup({\n  state,\n  context,\n}: {\n  state: {\n    presentation: ReadonlySignal<MediaSourceState['presentation']>;\n  };\n  context: {\n    mediaElement: ReadonlySignal<MediaSourceContext['mediaElement']>;\n    mediaSource: Signal<MediaSourceContext['mediaSource']>;\n  };\n}): Reactor<MediaSourceFsmState | 'destroying' | 'destroyed'> {\n  const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaElement.get()));\n\n  return createMachineReactor<MediaSourceFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'mediasource-attached': {\n        // entry body is auto-untracked. deriveState handles source resets via\n        // the resolver's resolved/unresolved transitions; this entry creates\n        // and attaches the MediaSource, awaits `'open'`, publishes on\n        // context, and binds detach + slot clear to state exit + destroy.\n        entry: () => {\n          const mediaElement = context.mediaElement.get()!;\n          const controller = new AbortController();\n\n          const mediaSource = createMediaSource({ preferManaged: true });\n          // Sync attach: the returned `detach` closes over the element +\n          // object-URL captured at this moment, so state-exit cleanup tears\n          // down exactly this attachment regardless of how the wait below\n          // resolves.\n          const { detach } = attachMediaSource(mediaSource, mediaElement);\n\n          const publishWhenOpen = async () => {\n            await waitForMediaSourceOpen(mediaSource, controller.signal);\n            if (controller.signal.aborted) return;\n            // `waitForMediaSourceOpen` resolves on any readyState transition\n            // out of `'closed'`; if we landed in `'ended'` / `'closed'`\n            // instead of `'open'`, the attach window is gone and we leave\n            // the slot unpublished. The session is dead within this source\n            // either way — publishing wouldn't help because\n            // `setupVideoBufferActors` / `setupAudioBufferActors` calls\n            // `addSourceBuffer` which throws on non-open. The next\n            // source-reset re-enters this state with a fresh MediaSource\n            // and recovers. Warn so the case is at least diagnosable; in\n            // practice it requires the MediaSource to close/end before its\n            // very first `sourceopen`, which a freshly attached MS\n            // shouldn't do.\n            if (mediaSource.readyState !== 'open') {\n              console.warn(\n                `[setupMediaSource] MediaSource transitioned to '${mediaSource.readyState}' before first 'sourceopen' — slot left unpublished; recoverable on next source reset.`\n              );\n              return;\n            }\n            context.mediaSource.set(mediaSource);\n          };\n\n          publishWhenOpen().catch((err) => console.error('[setupMediaSource] failed to publish MediaSource:', err));\n\n          return () => {\n            // Order matters: abort the wait first so a late publish can't\n            // race the slot clear; then detach to release the element; then\n            // clear the slot so downstream behaviors see no MediaSource.\n            controller.abort();\n            detach();\n            context.mediaSource.set(undefined);\n          };\n        },\n      },\n    },\n  });\n}\n\nexport const setupMediaSource = defineBehavior({\n  stateKeys: ['presentation'],\n  contextKeys: ['mediaElement', 'mediaSource'],\n  setup: setupMediaSourceSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,SAAS,YACP,cACA,cACqB;AACrB,KAAI,CAAC,gBAAgB,CAAC,uBAAuB,aAAa,CAAE,QAAO;AACnE,QAAO;;AAGT,SAAS,sBAAsB,EAC7B,OACA,WAS4D;CAC5D,MAAM,qBAAqB,eAAe,YAAY,MAAM,aAAa,KAAK,EAAE,QAAQ,aAAa,KAAK,CAAC,CAAC;AAE5G,QAAO,qBAA0C;EAC/C,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,uBAAuB,EAAE;GAEzB,wBAAwB,EAKtB,aAAa;IACX,MAAM,eAAe,QAAQ,aAAa,KAAK;IAC/C,MAAM,aAAa,IAAI,iBAAiB;IAExC,MAAM,cAAc,kBAAkB,EAAE,eAAe,MAAM,CAAC;IAK9D,MAAM,EAAE,WAAW,kBAAkB,aAAa,aAAa;IAE/D,MAAM,kBAAkB,YAAY;AAClC,WAAM,uBAAuB,aAAa,WAAW,OAAO;AAC5D,SAAI,WAAW,OAAO,QAAS;AAa/B,SAAI,YAAY,eAAe,QAAQ;AACrC,cAAQ,KACN,mDAAmD,YAAY,WAAW,wFAC3E;AACD;;AAEF,aAAQ,YAAY,IAAI,YAAY;;AAGtC,qBAAiB,CAAC,OAAO,QAAQ,QAAQ,MAAM,qDAAqD,IAAI,CAAC;AAEzG,iBAAa;AAIX,gBAAW,OAAO;AAClB,aAAQ;AACR,aAAQ,YAAY,IAAI,KAAA,EAAU;;MAGvC;GACF;EACF,CAAC;;AAGJ,MAAa,mBAAmB,eAAe;CAC7C,WAAW,CAAC,eAAe;CAC3B,aAAa,CAAC,gBAAgB,cAAc;CAC5C,OAAO;CACR,CAAC"}

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

@@ -0,0 +1,54 @@
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { effect } from "../../../core/signals/effect.js";
+import { createTextTracksActor } from "../../actors/dom/text-tracks.js";
+import { createTextTrackSegmentLoaderActor } from "../../actors/text-track-segment-loader.js";
+//#region src/playback/behaviors/dom/setup-text-track-actors.ts
+/**
+* **Own the TextTracks actor pair for the current `mediaElement`.** When a
+* `mediaElement` is in scope, creates the `TextTracksActor` (bound to the
+* element's `textTracks`) and the `TextTrackSegmentLoaderActor` (bound to
+* that actor + the injected cue resolver), and publishes both on
+* `context`. On element identity change or behavior destroy, destroys both
+* actors and clears the slots.
+*
+* Single-resource synchronous create/destroy driven by one signal — the
+* simple-effect form is the right shape (per `behaviors.md` → "Where both
+* shapes are legitimate": criterion 4b applies; sole writer of
+* `textTracksActor` / `textTrackSegmentLoaderActor`, the effect's cleanup
+* return handles destroy + slot clear structurally).
+*
+* Pairs with the `loadTextTrackSegments` behavior (a per-type variant of
+* `setupSegmentLoading` in `load-segments.ts`), which only reads
+* `textTrackSegmentLoaderActor`. The cue resolver is injected via
+* `config` so this behavior owns the DOM-bound part of the text-track
+* pipeline.
+*/
+function setupTextTrackActorsSetup({ context, config }) {
+	return effect(() => {
+		const mediaElement = context.mediaElement.get();
+		if (!mediaElement) return;
+		const textTracksActor = createTextTracksActor(mediaElement);
+		const textTrackSegmentLoaderActor = createTextTrackSegmentLoaderActor(textTracksActor, config.resolveTextTrackSegment, { forwardBuffer: config.forwardBuffer });
+		context.textTracksActor.set(textTracksActor);
+		context.textTrackSegmentLoaderActor.set(textTrackSegmentLoaderActor);
+		return () => {
+			textTracksActor.destroy();
+			textTrackSegmentLoaderActor.destroy();
+			context.textTracksActor.set(void 0);
+			context.textTrackSegmentLoaderActor.set(void 0);
+		};
+	});
+}
+const setupTextTrackActors = defineBehavior({
+	stateKeys: [],
+	contextKeys: [
+		"mediaElement",
+		"textTracksActor",
+		"textTrackSegmentLoaderActor"
+	],
+	setup: setupTextTrackActorsSetup
+});
+//#endregion
+export { setupTextTrackActors };
+
+//# sourceMappingURL=setup-text-track-actors.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setup-text-track-actors.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/setup-text-track-actors.ts"],"sourcesContent":["/**\n * **Own the TextTracks actor pair for the current `mediaElement`.** When a\n * `mediaElement` is in scope, creates the `TextTracksActor` (bound to the\n * element's `textTracks`) and the `TextTrackSegmentLoaderActor` (bound to\n * that actor + the injected cue resolver), and publishes both on\n * `context`. On element identity change or behavior destroy, destroys both\n * actors and clears the slots.\n *\n * Single-resource synchronous create/destroy driven by one signal — the\n * simple-effect form is the right shape (per `behaviors.md` → \"Where both\n * shapes are legitimate\": criterion 4b applies; sole writer of\n * `textTracksActor` / `textTrackSegmentLoaderActor`, the effect's cleanup\n * return handles destroy + slot clear structurally).\n *\n * Pairs with the `loadTextTrackSegments` behavior (a per-type variant of\n * `setupSegmentLoading` in `load-segments.ts`), which only reads\n * `textTrackSegmentLoaderActor`. The cue resolver is injected via\n * `config` so this behavior owns the DOM-bound part of the text-track\n * pipeline.\n */\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport type { ReadonlySignal, Signal } from '../../../core/signals/primitives';\nimport { createTextTracksActor } from '../../actors/dom/text-tracks';\nimport {\n  createTextTrackSegmentLoaderActor,\n  type TextTrackSegmentLoaderActor,\n  type TextTrackSegmentLoaderActorConfig,\n  type TextTrackSegmentResolver,\n} from '../../actors/text-track-segment-loader';\nimport type { TextTracksActor } from '../../actors/text-tracks';\n\nexport interface TextTrackActorsContext {\n  mediaElement?: HTMLMediaElement | undefined;\n  textTracksActor?: TextTracksActor<VTTCue> | undefined;\n  textTrackSegmentLoaderActor?: TextTrackSegmentLoaderActor | undefined;\n}\n\nexport interface TextTrackActorsConfig extends TextTrackSegmentLoaderActorConfig {\n  resolveTextTrackSegment: TextTrackSegmentResolver<VTTCue>;\n}\n\nfunction setupTextTrackActorsSetup({\n  context,\n  config,\n}: {\n  context: {\n    mediaElement: ReadonlySignal<TextTrackActorsContext['mediaElement']>;\n    textTracksActor: Signal<TextTrackActorsContext['textTracksActor']>;\n    textTrackSegmentLoaderActor: Signal<TextTrackActorsContext['textTrackSegmentLoaderActor']>;\n  };\n  config: TextTrackActorsConfig;\n}): () => void {\n  return effect(() => {\n    const mediaElement = context.mediaElement.get();\n    if (!mediaElement) return;\n\n    const textTracksActor = createTextTracksActor(mediaElement);\n    const textTrackSegmentLoaderActor = createTextTrackSegmentLoaderActor(\n      textTracksActor,\n      config.resolveTextTrackSegment,\n      { forwardBuffer: config.forwardBuffer }\n    );\n    context.textTracksActor.set(textTracksActor);\n    context.textTrackSegmentLoaderActor.set(textTrackSegmentLoaderActor);\n\n    return () => {\n      textTracksActor.destroy();\n      textTrackSegmentLoaderActor.destroy();\n      context.textTracksActor.set(undefined);\n      context.textTrackSegmentLoaderActor.set(undefined);\n    };\n  });\n}\n\nexport const setupTextTrackActors = defineBehavior({\n  stateKeys: [],\n  contextKeys: ['mediaElement', 'textTracksActor', 'textTrackSegmentLoaderActor'],\n  setup: setupTextTrackActorsSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAS,0BAA0B,EACjC,SACA,UAQa;AACb,QAAO,aAAa;EAClB,MAAM,eAAe,QAAQ,aAAa,KAAK;AAC/C,MAAI,CAAC,aAAc;EAEnB,MAAM,kBAAkB,sBAAsB,aAAa;EAC3D,MAAM,8BAA8B,kCAClC,iBACA,OAAO,yBACP,EAAE,eAAe,OAAO,eAAe,CACxC;AACD,UAAQ,gBAAgB,IAAI,gBAAgB;AAC5C,UAAQ,4BAA4B,IAAI,4BAA4B;AAEpE,eAAa;AACX,mBAAgB,SAAS;AACzB,+BAA4B,SAAS;AACrC,WAAQ,gBAAgB,IAAI,KAAA,EAAU;AACtC,WAAQ,4BAA4B,IAAI,KAAA,EAAU;;GAEpD;;AAGJ,MAAa,uBAAuB,eAAe;CACjD,WAAW,EAAE;CACb,aAAa;EAAC;EAAgB;EAAmB;EAA8B;CAC/E,OAAO;CACR,CAAC"}

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

@@ -0,0 +1,99 @@
+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
+* `selectedTextTrackId` into their `mode`s, and propagate user-initiated
+* DOM `change` events back to `selectedTextTrackId` so non-SPF consumers
+* (host-page captions buttons, browser native UI, video.js store) remain
+* the canonical write path for selection.
+*
+* 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.
+*
+* Multi-writer with `selectTextTrack` is intentional and orthogonal:
+* `selectTextTrack` owns the *default-on-load / clear-on-unload* contract
+* for `selectedTextTrackId`; this behavior writes only from DOM `change`
+* events. They reflect distinct decision-making domains (config-driven
+* intent vs DOM-driven user action), so this behavior never clears the
+* slot on source unload — that's `selectTextTrack`'s contract. (It *does*
+* write `undefined` when a user disables all tracks via native UI, since
+* that's a real user action that should round-trip into SPF state.)
+*/
+function deriveState(presentation, mediaElement) {
+	if (!mediaElement || !presentation) return "preconditions-unmet";
+	return getTracksByType(presentation, "text").length > 0 ? "sync-active" : "preconditions-unmet";
+}
+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();
+					addSubtitlesTracksToMedia(mediaElement, getTracksByType(state.presentation.get(), "text"));
+					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 nextId = getShowingSubtitlesTrackFromMedia(mediaElement)?.id || void 0;
+						if (nextId === state.selectedTextTrackId.get()) return;
+						state.selectedTextTrackId.set(nextId);
+					};
+					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"],
+	contextKeys: ["mediaElement", "textTracksActor"],
+	setup: syncTextTracksSetup
+});
+//#endregion
+export { syncTextTracks };
+
+//# sourceMappingURL=sync-text-tracks.js.map

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\n * `selectedTextTrackId` into their `mode`s, and propagate user-initiated\n * DOM `change` events back to `selectedTextTrackId` so non-SPF consumers\n * (host-page captions buttons, browser native UI, video.js store) remain\n * the canonical write path for selection.\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 * Multi-writer with `selectTextTrack` is intentional and orthogonal:\n * `selectTextTrack` owns the *default-on-load / clear-on-unload* contract\n * for `selectedTextTrackId`; this behavior writes only from DOM `change`\n * events. They reflect distinct decision-making domains (config-driven\n * intent vs DOM-driven user action), so this behavior never clears the\n * slot on source unload — that's `selectTextTrack`'s contract. (It *does*\n * write `undefined` when a user disables all tracks via native UI, since\n * that's a real user action that should round-trip into SPF state.)\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\nfunction syncTextTracksSetup({\n  state,\n  context,\n  config,\n}: {\n  state: {\n    presentation: ReadonlySignal<MaybeResolvedPresentation | undefined>;\n    selectedTextTrackId: Signal<string | 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 `quality-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 nextId = showingTrack?.id || undefined;\n            if (nextId === state.selectedTextTrackId.get()) return;\n            state.selectedTextTrackId.set(nextId);\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'],\n  contextKeys: ['mediaElement', 'textTracksActor'],\n  setup: syncTextTracksSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EA,SAAS,YACP,cACA,cACwB;AACxB,KAAI,CAAC,gBAAgB,CAAC,aAAc,QAAO;AAC3C,QAAO,gBAAgB,cAAc,OAAO,CAAC,SAAS,IAAI,gBAAgB;;AAG5E,SAAS,oBAAoB,EAC3B,OACA,SACA,UAW+D;CAC/D,MAAM,EAAE,2BAA2B,mCAAmC,sCAAsC;CAE5G,MAAM,qBAAqB,eAAe,YAAY,MAAM,aAAa,KAAK,EAAE,QAAQ,aAAa,KAAK,CAAC,CAAC;AAE5G,QAAO,qBAA6C;EAClD,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,uBAAuB,EAAE;GAEzB,eAAe;IAOb,aAAa;KACX,MAAM,eAAe,QAAQ,aAAa,KAAK;AAU/C,+BAA0B,cALF,gBAAgB,MAAM,aAAa,KAAK,EAAG,OAAO,CAKlB;AASxD,wBAAmB,aAAa,YAAY,MAAM,oBAAoB,KAAK,CAAC;KAO5E,IAAI,mBAAmB;KACvB,MAAM,kBAAkB,iBAAiB;AACvC,yBAAmB;QAClB,EAAE;KAEL,MAAM,iBAAuB;AAC3B,UAAI,kBAAkB;AACpB,0BAAmB,aAAa,YAAY,MAAM,oBAAoB,KAAK,CAAC;AAC5E;;MAKF,MAAM,SAHe,kCAAkC,aAAa,EAGvC,MAAM,KAAA;AACnC,UAAI,WAAW,MAAM,oBAAoB,KAAK,CAAE;AAChD,YAAM,oBAAoB,IAAI,OAAO;;KAGvC,MAAM,WAAW,OAAO,aAAa,YAAY,UAAU,SAAS;AAEpE,kBAAa;AACX,gBAAU;AACV,mBAAa,gBAAgB;AAC7B,wCAAkC,aAAa;AAS/C,WAAK,QAAQ,gBAAgB,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;;;IAO1D,eAAe;AAEb,wBADqB,KAAK,QAAQ,aAAa,CACf,YAAY,MAAM,oBAAoB,KAAK,CAAC;;IAE/E;GACF;EACF,CAAC;;AAGJ,MAAa,iBAAiB,eAAe;CAC3C,WAAW,CAAC,gBAAgB,sBAAsB;CAClD,aAAa,CAAC,gBAAgB,kBAAkB;CAChD,OAAO;CACR,CAAC"}

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

@@ -0,0 +1,46 @@
+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.
+*
+* 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 removeTimeupdate = listen(mediaElement, "timeupdate", sync);
+		const removeSeeking = listen(mediaElement, "seeking", sync);
+		return () => {
+			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 *\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 removeTimeupdate = listen(mediaElement, 'timeupdate', sync);\n    const removeSeeking = listen(mediaElement, 'seeking', sync);\n    return () => {\n      removeTimeupdate();\n      removeSeeking();\n    };\n  });\n}\n\nexport const trackCurrentTime = defineBehavior({\n  stateKeys: ['currentTime'],\n  contextKeys: ['mediaElement'],\n  setup: trackCurrentTimeSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAoCA,SAAS,sBAAsB,EAC7B,OACA,SACA,UAKa;CACb,MAAM,qBAAqB,QAAQ,sBAAsB;AAEzD,QAAO,aAAa;EAClB,MAAM,eAAe,QAAQ,aAAa,KAAK;AAC/C,MAAI,CAAC,cAAc;AACjB,SAAM,YAAY,IAAI,mBAAmB;AACzC;;EAGF,MAAM,aAAa,MAAM,YAAY,IAAI,aAAa,YAAY;AAClE,QAAM;EACN,MAAM,mBAAmB,OAAO,cAAc,cAAc,KAAK;EACjE,MAAM,gBAAgB,OAAO,cAAc,WAAW,KAAK;AAC3D,eAAa;AACX,qBAAkB;AAClB,kBAAe;;GAEjB;;AAGJ,MAAa,mBAAmB,eAAe;CAC7C,WAAW,CAAC,cAAc;CAC1B,aAAa,CAAC,eAAe;CAC7B,OAAO;CACR,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 in such a state
+* (`!el.paused` or `el.seeking`), mirroring autoplay / native-controls /
+* 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.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 in such a state\n * (`!el.paused` or `el.seeking`), mirroring autoplay / native-controls /\n * 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.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;AACtB,KAAI,CAAC,gBAAgB,CAAC,cAAc,IAAK,QAAO;AAChD,KAAI,cAAe,QAAO;AAC1B,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BT,SAAS,uBAAuB,EAC9B,OACA,WAO6D;CAC7D,MAAM,qBAAqB,eACzB,YAAY,MAAM,aAAa,KAAK,EAAE,QAAQ,aAAa,KAAK,EAAE,MAAM,cAAc,KAAK,CAAC,CAC7F;CAUD,MAAM,YAAY,eAAe,MAAM,aAAa,KAAK,EAAE,IAAI;AAE/D,QAAO,qBAA2C;EAChD,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,uBAAuB,EAAE;GAEzB,YAAY,EAIV,eAAe;IACb,MAAM,KAAK,QAAQ,aAAa,KAAK;IAErC,MAAM,yBAAyB,MAAM,cAAc,IAAI,KAAK;AAC5D,QAAI,CAAC,GAAG,UAAU,GAAG,SAAS;AAC5B,uBAAkB;AAClB;;IAEF,MAAM,cAAc,OAAO,IAAI,QAAQ,iBAAiB;IACxD,MAAM,iBAAiB,OAAO,IAAI,WAAW,iBAAiB;AAC9D,iBAAa;AACX,kBAAa;AACb,qBAAgB;;MAGrB;GAED,eAAe,EAOb,eAAe;AACb,YAAQ,aAAa,KAAK;AAC1B,cAAU,KAAK;AACf,iBAAa,MAAM,cAAc,IAAI,MAAM;MAE9C;GACF;EACF,CAAC;;AAGJ,MAAa,oBAAoB,eAAe;CAC9C,WAAW,CAAC,iBAAiB,eAAe;CAC5C,aAAa,CAAC,eAAe;CAC7B,OAAO;CACR,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;AAE3D,QAAO,aAAa;EAClB,MAAM,eAAe,QAAQ,aAAa,KAAK;AAC/C,MAAI,CAAC,cAAc;AACjB,SAAM,aAAa,IAAI,oBAAoB;AAC3C;;EAGF,MAAM,aAAa,MAAM,aAAa,IAAI,aAAa,aAAa;AACpE,QAAM;AACN,SAAO,OAAO,cAAc,cAAc,KAAK;GAC/C;;AAGJ,MAAa,oBAAoB,eAAe;CAC9C,WAAW,CAAC,eAAe;CAC3B,aAAa,CAAC,eAAe;CAC7B,OAAO;CACR,CAAC"}

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

@@ -0,0 +1,90 @@
+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 { getMaxBufferedEnd, shouldUpdateDuration, waitForSourceBuffersReady } from "../../../media/dom/mse/duration.js";
+import { waitForMediaSourceOpen } from "../../../media/dom/mse/mediasource-setup.js";
+//#region src/playback/behaviors/dom/update-mediasource-duration.ts
+/**
+* **Propagate `presentation.duration` to `mediaSource.duration` — exactly
+* once per MediaSource.**
+*
+* When the presentation has a valid positive duration (including `Infinity`
+* for live) and a MediaSource is in context, writes the value through to
+* `mediaSource.duration` on initial setup — once, while `mediaSource.duration`
+* is still `NaN`. Once any non-NaN value is present (set by us, or by
+* `endOfStream` from the buffered end), the behavior leaves the property
+* alone; re-syncing a drift against `presentation.duration` would race with
+* 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 (!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);
+					mediaSource.duration = maxBufferedEnd > presentation.duration ? maxBufferedEnd : presentation.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 * When the presentation has a valid positive duration (including `Infinity`\n * for live) and a MediaSource is in context, writes the value through to\n * `mediaSource.duration` on initial setup — once, while `mediaSource.duration`\n * is still `NaN`. Once any non-NaN value is present (set by us, or by\n * `endOfStream` from the buffered end), the behavior leaves the property\n * alone; re-syncing a drift against `presentation.duration` would race with\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          // 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,SAAS,YACP,cACA,aACkB;AAClB,QAAO,qBAAqB,cAAc,YAAY,GAAG,sBAAsB;;AAGjF,SAAS,+BAA+B,EACtC,OACA,WAIyD;CAMzD,MAAM,qBAAqB,eAAe,YAAY,MAAM,aAAa,KAAK,EAAE,QAAQ,YAAY,KAAK,CAAC,CAAC;AAE3G,QAAO,qBAAuC;EAC5C,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,uBAAuB,EAAE;GAEzB,qBAAqB,EAKnB,aAAa;IACX,MAAM,eAAe,MAAM,aAAa,KAAK;IAC7C,MAAM,cAAc,QAAQ,YAAY,KAAK;AAO7C,QAAI,CAAC,OAAO,MAAM,YAAY,SAAS,CAAE;IAEzC,MAAM,aAAa,IAAI,iBAAiB;IAExC,MAAM,iBAAiB,YAAY;AACjC,WAAM,uBAAuB,aAAa,WAAW,OAAO;AAC5D,SAAI,WAAW,OAAO,QAAS;AAI/B,SAAI,YAAY,eAAe,OAAQ;AAEvC,WAAM,0BAA0B,YAAY,eAAe,WAAW,OAAO;AAC7E,SAAI,WAAW,OAAO,QAAS;AAM/B,SAAI,YAAY,eAAe,OAAQ;KAKvC,MAAM,iBAAiB,kBAAkB,YAAY,cAAc;AAEnE,iBAAY,WADK,iBAAiB,aAAa,WAAY,iBAAiB,aAAa;;AAI3F,oBAAgB;AAEhB,iBAAa,WAAW,OAAO;MAElC;GACF;EACF,CAAC;;AAGJ,MAAa,4BAA4B,eAAe;CACtD,WAAW,CAAC,eAAe;CAC3B,aAAa,CAAC,cAAc;CAC5B,OAAO;CACR,CAAC"}