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

package/dist/default/playback/behaviors/dom/airplay.js

@@ -0,0 +1,211 @@
+import { computed, peek } from "../../../core/signals/primitives.js";
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { effect } from "../../../core/signals/effect.js";
+import { createMachineReactor } from "../../../core/reactors/create-machine-reactor.js";
+import { isWebKitAirPlayCapable, listen } from "@videojs/utils/dom";
+//#region src/playback/behaviors/dom/airplay.ts
+/**
+* **Bridge MSE playback to AirPlay on WebKit.**
+* MSE streams can't be handed to an AirPlay receiver directly.
+* The WebKit-recommended workaround is to append a fallback
+* `<source type="application/x-mpegURL">` carrying the original manifest URL:
+* Safari exposes the AirPlay picker and, when a wireless target is selected,
+* plays that native-HLS source on the receiver. The session state (WebKit's
+* wireless flag, falling edge debounced — see `REMOTE_INACTIVE_SETTLE_MS`) is
+* written straight to its policy consequences, declared here so the
+* cause→policy mapping stays with the feature:
+*
+* - `state.loadingSuspended` — held while the session is live. Observed by
+*   the `loadXSegments` dispatchers (no fetching alongside the receiver) and
+*   by `setupMediaSource` (its post-close rebuild waits — attaching runs
+*   `element.load()` under the live receiver, which destroys a session still
+*   being established). The suspension this behavior holds doubles as its own
+*   session fact — same writer, same edges.
+* - `state.startPosition` — one-shot command: the position is captured from
+*   the element at the session's settled end (still receiver-mirrored) and
+*   written once the rebuild's `load()` resets the element (its `'emptied'`),
+*   so `applyStartPosition` applies it to the rebuilt source — never to the
+*   pre-rebuild element — and starts it where the receiver left off. The
+*   playing state rides the same snapshot but stays behavior-local: this
+*   behavior itself calls `play()` once the command has been *consumed* — i.e.
+*   after the seek — when the receiver was playing at session end. The whole
+*   restore is bound to the presentation the session owned and retracted if
+*   that changes.
+*
+* A source change during a live session releases the hold rather than deferring
+* until the session ends, so the rebuild runs and WebKit switches the receiver
+* to the newly-built AirPlay alternate. Measured, not contracted — see the
+* effect below.
+* https://webkit.org/blog/15036/how-to-use-media-source-extensions-with-airplay/
+*
+* Single-positive-state reactor (`'preconditions-unmet'` ↔ `'airplay-capable'`):
+* gated on a WebKit-AirPlay-capable media element being in scope. The entry —
+* gated on `context.mediaSource` — appends the fallback `<source>` (kept
+* current from `state.presentation`) and enables the AirPlay picker once the
+* MediaSource is open, removing the source the moment the MediaSource detaches
+* so it never survives an MSE teardown. State-exit cleanup (author opt-out,
+* detach, source reset, behavior destroy) removes the source and restores the
+* element's `disableRemotePlayback` default. No-op on non-WebKit platforms
+* (Chromium, Firefox) — `deriveState` never leaves `'preconditions-unmet'`.
+*
+* MMS and AirPlay want *opposite* values of `disableRemotePlayback` on the same
+* element, so it is **sequenced**:
+*
+* - **MMS needs `true` to open.** `setupMediaSource` sets
+*   `disableRemotePlayback = true` when it attaches a ManagedMediaSource —
+*   Safari won't fire `sourceopen` (and MSE playback never starts) otherwise.
+* - **AirPlay needs `false` to offer the picker.** Flipping to `false` *before*
+*   the source opens would prevent `sourceopen`, so the flip is gated on
+*   `context.mediaSource` — which `setupMediaSource` publishes exactly once the
+*   MS is open. Re-fires per source (the slot clears + republishes on reset).
+* - **Author opt-out wins.** `state.disableRemotePlayback` is the author's
+*   intent, written only by the media adapter's IDL property; MMS/programmatic
+*   code touch the element's own `disableRemotePlayback` instead. A `true`
+*   there is unambiguously the author's choice to disable remote playback, so
+*   it holds the machine in `'preconditions-unmet'` and nothing is set up.
+*/
+/**
+* How long WebKit's wireless flag must read *inactive* before the
+* session-driven `loadingSuspended` clears.
+*
+* Measured on Safari 26.4 (macOS): when an AirPlay session engages, Safari
+* closes the ManagedMediaSource and — while its pipeline switches to the
+* native-HLS fallback source — transiently reports
+* `webkitCurrentPlaybackTargetIsWireless === false`, firing the changed
+* event. Trusting an instantaneous inactive reading would release
+* `setupMediaSource`'s rebuild hold mid-handoff; its recovery `load()` then
+* destroys the very session being established. Rising edges apply
+* immediately; only the falling edge waits out this settle window.
+*/
+const REMOTE_INACTIVE_SETTLE_MS = 1e3;
+function deriveState(mediaElement, authorDisabledRemotePlayback) {
+	if (!mediaElement || !isWebKitAirPlayCapable(mediaElement)) return "preconditions-unmet";
+	if (authorDisabledRemotePlayback) return "preconditions-unmet";
+	return "airplay-capable";
+}
+function setupAirPlaySetup({ state, context }) {
+	const derivedStateSignal = computed(() => deriveState(context.mediaElement.get(), state.disableRemotePlayback.get()));
+	return createMachineReactor({
+		initial: "preconditions-unmet",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"preconditions-unmet": {},
+			"airplay-capable": { entry: () => {
+				const mediaElement = context.mediaElement.get();
+				const isSessionActive = () => !!mediaElement.webkitCurrentPlaybackTargetIsWireless;
+				let settleTimer;
+				let sessionPresentationUrl;
+				let pendingRestore;
+				/** Presentation an already-written `state.startPosition` belongs to. */
+				let restoreOwnerUrl;
+				let resumeWhenRestored = false;
+				const sync = () => {
+					if (isSessionActive()) {
+						clearTimeout(settleTimer);
+						settleTimer = void 0;
+						if (!peek(state.loadingSuspended)) sessionPresentationUrl = peek(state.presentation)?.url;
+						state.loadingSuspended.set(true);
+					} else if (peek(state.loadingSuspended)) settleTimer ??= setTimeout(() => {
+						settleTimer = void 0;
+						const stillActive = isSessionActive();
+						if (!stillActive) {
+							const ownerUrl = sessionPresentationUrl;
+							sessionPresentationUrl = void 0;
+							if (peek(state.presentation)?.url === ownerUrl) pendingRestore = {
+								position: mediaElement.currentTime,
+								wasPlaying: !mediaElement.paused,
+								presentationUrl: ownerUrl
+							};
+						}
+						state.loadingSuspended.set(stillActive);
+					}, REMOTE_INACTIVE_SETTLE_MS);
+					else state.loadingSuspended.set(false);
+				};
+				const listenerCleanup = new AbortController();
+				listen(mediaElement, "webkitcurrentplaybacktargetiswirelesschanged", sync, { signal: listenerCleanup.signal });
+				listen(mediaElement, "emptied", () => {
+					if (!pendingRestore) return;
+					const { position, wasPlaying, presentationUrl } = pendingRestore;
+					pendingRestore = void 0;
+					if (peek(state.presentation)?.url !== presentationUrl) return;
+					state.startPosition.set(position);
+					restoreOwnerUrl = presentationUrl;
+					resumeWhenRestored = wasPlaying;
+				}, { signal: listenerCleanup.signal });
+				const disposeSourceChangeEnd = effect(() => {
+					const url = state.presentation.get()?.url;
+					if (!peek(state.loadingSuspended) || url === sessionPresentationUrl) return;
+					sessionPresentationUrl = void 0;
+					clearTimeout(settleTimer);
+					settleTimer = void 0;
+					state.loadingSuspended.set(false);
+				});
+				const disposeRestoreWatch = effect(() => {
+					const url = state.presentation.get()?.url;
+					const position = state.startPosition.get();
+					if (!restoreOwnerUrl) return;
+					if (url !== restoreOwnerUrl) {
+						restoreOwnerUrl = void 0;
+						resumeWhenRestored = false;
+						if (position !== void 0) state.startPosition.set(void 0);
+						return;
+					}
+					if (position !== void 0) return;
+					restoreOwnerUrl = void 0;
+					if (!resumeWhenRestored) return;
+					resumeWhenRestored = false;
+					mediaElement.play().catch((err) => {
+						console.warn("[setupAirPlay] session-end resume play() rejected — staying paused:", err);
+					});
+				});
+				let sourceEl = null;
+				const disposeSource = effect(() => {
+					const hasMediaSource = !!context.mediaSource.get();
+					const sessionActive = !!state.loadingSuspended.get();
+					const url = state.presentation.get()?.url ?? "";
+					if (!hasMediaSource && !sessionActive) {
+						sourceEl?.remove();
+						sourceEl = null;
+					} else if (hasMediaSource && (!sourceEl || sourceEl.parentNode !== mediaElement)) {
+						sourceEl = document.createElement("source");
+						sourceEl.type = "application/x-mpegURL";
+						mediaElement.append(sourceEl);
+						mediaElement.disableRemotePlayback = false;
+					}
+					if (sourceEl) sourceEl.src = url;
+				});
+				sync();
+				return () => {
+					disposeSource();
+					disposeSourceChangeEnd();
+					disposeRestoreWatch();
+					listenerCleanup.abort();
+					clearTimeout(settleTimer);
+					sourceEl?.remove();
+					sourceEl = null;
+					mediaElement.disableRemotePlayback = true;
+					state.loadingSuspended.set(false);
+					if (restoreOwnerUrl) {
+						restoreOwnerUrl = void 0;
+						resumeWhenRestored = false;
+						if (peek(state.startPosition) !== void 0) state.startPosition.set(void 0);
+					}
+				};
+			} }
+		}
+	});
+}
+const setupAirPlay = defineBehavior({
+	stateKeys: [
+		"presentation",
+		"disableRemotePlayback",
+		"loadingSuspended",
+		"startPosition"
+	],
+	contextKeys: ["mediaElement", "mediaSource"],
+	setup: setupAirPlaySetup
+});
+//#endregion
+export { setupAirPlay };
+
+//# sourceMappingURL=airplay.js.map

package/dist/default/playback/behaviors/dom/airplay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"airplay.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/airplay.ts"],"sourcesContent":["/**\n * **Bridge MSE playback to AirPlay on WebKit.**\n * MSE streams can't be handed to an AirPlay receiver directly.\n * The WebKit-recommended workaround is to append a fallback\n * `<source type=\"application/x-mpegURL\">` carrying the original manifest URL:\n * Safari exposes the AirPlay picker and, when a wireless target is selected,\n * plays that native-HLS source on the receiver. The session state (WebKit's\n * wireless flag, falling edge debounced — see `REMOTE_INACTIVE_SETTLE_MS`) is\n * written straight to its policy consequences, declared here so the\n * cause→policy mapping stays with the feature:\n *\n * - `state.loadingSuspended` — held while the session is live. Observed by\n *   the `loadXSegments` dispatchers (no fetching alongside the receiver) and\n *   by `setupMediaSource` (its post-close rebuild waits — attaching runs\n *   `element.load()` under the live receiver, which destroys a session still\n *   being established). The suspension this behavior holds doubles as its own\n *   session fact — same writer, same edges.\n * - `state.startPosition` — one-shot command: the position is captured from\n *   the element at the session's settled end (still receiver-mirrored) and\n *   written once the rebuild's `load()` resets the element (its `'emptied'`),\n *   so `applyStartPosition` applies it to the rebuilt source — never to the\n *   pre-rebuild element — and starts it where the receiver left off. The\n *   playing state rides the same snapshot but stays behavior-local: this\n *   behavior itself calls `play()` once the command has been *consumed* — i.e.\n *   after the seek — when the receiver was playing at session end. The whole\n *   restore is bound to the presentation the session owned and retracted if\n *   that changes.\n *\n * A source change during a live session releases the hold rather than deferring\n * until the session ends, so the rebuild runs and WebKit switches the receiver\n * to the newly-built AirPlay alternate. Measured, not contracted — see the\n * effect below.\n * https://webkit.org/blog/15036/how-to-use-media-source-extensions-with-airplay/\n *\n * Single-positive-state reactor (`'preconditions-unmet'` ↔ `'airplay-capable'`):\n * gated on a WebKit-AirPlay-capable media element being in scope. The entry —\n * gated on `context.mediaSource` — appends the fallback `<source>` (kept\n * current from `state.presentation`) and enables the AirPlay picker once the\n * MediaSource is open, removing the source the moment the MediaSource detaches\n * so it never survives an MSE teardown. State-exit cleanup (author opt-out,\n * detach, source reset, behavior destroy) removes the source and restores the\n * element's `disableRemotePlayback` default. No-op on non-WebKit platforms\n * (Chromium, Firefox) — `deriveState` never leaves `'preconditions-unmet'`.\n *\n * MMS and AirPlay want *opposite* values of `disableRemotePlayback` on the same\n * element, so it is **sequenced**:\n *\n * - **MMS needs `true` to open.** `setupMediaSource` sets\n *   `disableRemotePlayback = true` when it attaches a ManagedMediaSource —\n *   Safari won't fire `sourceopen` (and MSE playback never starts) otherwise.\n * - **AirPlay needs `false` to offer the picker.** Flipping to `false` *before*\n *   the source opens would prevent `sourceopen`, so the flip is gated on\n *   `context.mediaSource` — which `setupMediaSource` publishes exactly once the\n *   MS is open. Re-fires per source (the slot clears + republishes on reset).\n * - **Author opt-out wins.** `state.disableRemotePlayback` is the author's\n *   intent, written only by the media adapter's IDL property; MMS/programmatic\n *   code touch the element's own `disableRemotePlayback` instead. A `true`\n *   there is unambiguously the author's choice to disable remote playback, so\n *   it holds the machine in `'preconditions-unmet'` and nothing is set up.\n */\n\nimport { isWebKitAirPlayCapable, listen, type WebKitVideoElement } 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 { effect } from '../../../core/signals/effect';\nimport { computed, peek, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';\nimport type { MaybeResolvedPresentation } from '../../../media/types';\nimport type { StartPositionState } from './apply-start-position';\nimport type { SegmentLoadingState } from './load-segments';\n\n/**\n * How long WebKit's wireless flag must read *inactive* before the\n * session-driven `loadingSuspended` clears.\n *\n * Measured on Safari 26.4 (macOS): when an AirPlay session engages, Safari\n * closes the ManagedMediaSource and — while its pipeline switches to the\n * native-HLS fallback source — transiently reports\n * `webkitCurrentPlaybackTargetIsWireless === false`, firing the changed\n * event. Trusting an instantaneous inactive reading would release\n * `setupMediaSource`'s rebuild hold mid-handoff; its recovery `load()` then\n * destroys the very session being established. Rising edges apply\n * immediately; only the falling edge waits out this settle window.\n */\nconst REMOTE_INACTIVE_SETTLE_MS = 1000;\n\ntype AirPlayFsmState = 'preconditions-unmet' | 'airplay-capable';\n\nfunction deriveState(\n  mediaElement: HTMLMediaElement | undefined,\n  authorDisabledRemotePlayback: boolean | undefined\n): AirPlayFsmState {\n  if (!mediaElement || !isWebKitAirPlayCapable(mediaElement)) return 'preconditions-unmet';\n  if (authorDisabledRemotePlayback) return 'preconditions-unmet';\n  return 'airplay-capable';\n}\n\nfunction setupAirPlaySetup({\n  state,\n  context,\n}: {\n  state: {\n    presentation: ReadonlySignal<MaybeResolvedPresentation | undefined>;\n    disableRemotePlayback: ReadonlySignal<boolean | undefined>;\n    loadingSuspended: Signal<SegmentLoadingState['loadingSuspended']>;\n    startPosition: Signal<StartPositionState['startPosition']>;\n  };\n  context: {\n    mediaElement: ReadonlySignal<HTMLMediaElement | undefined>;\n    mediaSource: ReadonlySignal<MediaSource | undefined>;\n  };\n}): Reactor<AirPlayFsmState | 'destroying' | 'destroyed'> {\n  const derivedStateSignal = computed(() => deriveState(context.mediaElement.get(), state.disableRemotePlayback.get()));\n\n  return createMachineReactor<AirPlayFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'airplay-capable': {\n        entry: () => {\n          const mediaElement = context.mediaElement.get() as WebKitVideoElement;\n\n          // WebKit's wireless flag is the only session signal. The standard\n          // Remote Playback API's `remote.state` is deliberately not consulted:\n          // it doesn't track AirPlay sessions reliably on WebKit (same reason\n          // `remotePlaybackFeature` in @videojs/core skips it), and a stale\n          // `'connected'` would pin `loadingSuspended` on — stranding the\n          // rebuild in a way the settle window below can't recover from.\n          const isSessionActive = () => !!mediaElement.webkitCurrentPlaybackTargetIsWireless;\n\n          let settleTimer: ReturnType<typeof setTimeout> | undefined;\n          // Session-end restore. The position/playing snapshot is taken at the\n          // settled falling edge (the element still mirrors the receiver) but\n          // acted on only at the element's next `'emptied'` — once the\n          // rebuild's `load()` has reset the element. Writing it earlier would\n          // hand `applyStartPosition` a command against the pre-rebuild element\n          // (readyState still >= HAVE_METADATA), which it would apply and\n          // consume before the rebuilt source exists.\n          //\n          // The restore is bound to the presentation the session owned, and\n          // that identity is re-checked at *every* async hop — settle timer,\n          // `'emptied'`, and the outstanding-command effect below. Checking at\n          // only one hop leaves the others open: a source change inside the\n          // settle window, or between `'emptied'` and the element becoming\n          // seekable, would otherwise strand the old session's position (and an\n          // unrequested `play()`) on the new source.\n          let sessionPresentationUrl: string | undefined;\n          let pendingRestore:\n            | { position: number; wasPlaying: boolean; presentationUrl: string | undefined }\n            | undefined;\n          /** Presentation an already-written `state.startPosition` belongs to. */\n          let restoreOwnerUrl: string | undefined;\n          let resumeWhenRestored = false;\n\n          const sync = () => {\n            if (isSessionActive()) {\n              clearTimeout(settleTimer);\n              settleTimer = undefined;\n              // Rising edge — the presentation the receiver is taking over.\n              if (!peek(state.loadingSuspended)) sessionPresentationUrl = peek(state.presentation)?.url;\n              state.loadingSuspended.set(true);\n            } else if (peek(state.loadingSuspended)) {\n              // Falling edge: don't trust an instantaneous inactive reading —\n              // re-check once the flag has settled.\n              settleTimer ??= setTimeout(() => {\n                settleTimer = undefined;\n                const stillActive = isSessionActive();\n                if (!stillActive) {\n                  const ownerUrl = sessionPresentationUrl;\n                  sessionPresentationUrl = undefined;\n                  // Snapshot only while the session's own presentation is still\n                  // current. `currentTime` here belongs to that presentation —\n                  // during a session `setupMediaSource` has already torn down,\n                  // so a source change inside this window resets neither the\n                  // element nor its position, and pairing that position with the\n                  // incoming URL would smuggle it onto the new source.\n                  if (peek(state.presentation)?.url === ownerUrl) {\n                    pendingRestore = {\n                      position: mediaElement.currentTime,\n                      wasPlaying: !mediaElement.paused,\n                      presentationUrl: ownerUrl,\n                    };\n                  }\n                }\n                state.loadingSuspended.set(stillActive);\n              }, REMOTE_INACTIVE_SETTLE_MS);\n            } else {\n              state.loadingSuspended.set(false);\n            }\n          };\n          const listenerCleanup = new AbortController();\n          listen(mediaElement, 'webkitcurrentplaybacktargetiswirelesschanged', sync, {\n            signal: listenerCleanup.signal,\n          });\n          listen(\n            mediaElement,\n            'emptied',\n            () => {\n              if (!pendingRestore) return;\n              const { position, wasPlaying, presentationUrl } = pendingRestore;\n              pendingRestore = undefined;\n              if (peek(state.presentation)?.url !== presentationUrl) return;\n              state.startPosition.set(position);\n              restoreOwnerUrl = presentationUrl;\n              resumeWhenRestored = wasPlaying;\n            },\n            { signal: listenerCleanup.signal }\n          );\n\n          // A source change during a live session releases the hold, letting the\n          // rebuild run instead of waiting for the session to end.\n          //\n          // Doing nothing is not a neutral choice — it silently defers the\n          // change. `<source>` children are only consulted while resource\n          // selection runs, so the effect below rewriting the fallback's `src`\n          // does nothing to what the receiver is already playing, and the\n          // rebuild is held by `loadingSuspended`, so the receiver stays on the\n          // outgoing stream until the user disengages.\n          //\n          // Releasing the hold lets the rebuild proceed, and the receiver ends\n          // up on the new stream — measured on Safari 26.4. Note where the\n          // handover actually happens, because it is not the rebuild's `load()`:\n          // clearing the hold also makes the source effect below see an inactive\n          // session with no `context.mediaSource`, so it drops the fallback, and\n          // the rebuild's resource selection runs with the MSE source alone. The\n          // switch comes afterwards, when that effect re-creates the fallback\n          // against the new presentation once the MediaSource opens and WebKit\n          // moves the live session onto the newly-appeared alternate.\n          //\n          // That leaves a window where an active session has no compatible\n          // alternate on the element, and it survives it. Holding the fallback\n          // across the rebuild instead would close the window and make the\n          // handover selection-driven, but it swaps a measured path for an\n          // argued one — don't without a device pass.\n          //\n          // Measured, not contracted: this is under-specified territory, so\n          // nothing here depends on the handover succeeding. If a UA drops the\n          // session instead, the falling edge runs its ordinary course; the\n          // restore is suppressed either way because the snapshot is bound to\n          // the presentation the session owned.\n          //\n          // Note this is *not* an attempt to end the session. Setting\n          // `disableRemotePlayback = true` was tried: the Remote Playback API\n          // requires it to disconnect (spec §5.3.2) but WebKit does not honor\n          // that for AirPlay — the session survived, measured on Safari 26.4.\n          // Deliberately not written here, so that behavior can't silently flip\n          // to \"receiver drops\" if WebKit ever implements the disconnect.\n          const disposeSourceChangeEnd = effect(() => {\n            const url = state.presentation.get()?.url;\n            // `loadingSuspended` is this behavior's own session fact; peeked so\n            // clearing it below doesn't re-trigger.\n            if (!peek(state.loadingSuspended) || url === sessionPresentationUrl) return;\n            sessionPresentationUrl = undefined;\n            clearTimeout(settleTimer);\n            settleTimer = undefined;\n            state.loadingSuspended.set(false);\n          });\n\n          // Watches an outstanding restore command to its end. Two outcomes:\n          //\n          // - **Consumed** (`startPosition` back to `undefined`): the element is\n          //   at the restored position, so resuming is safe. Keying the resume\n          //   off consumption rather than off `'loadedmetadata'` orders it after\n          //   `applyStartPosition`'s seek — arming a listener for the same event\n          //   would put `play()` ahead of the seek, since this behavior registers\n          //   synchronously while `applyStartPosition` only reaches its state a\n          //   microtask later. The rebuild's load algorithm forced `paused =\n          //   true`; a rejection here (autoplay policy) degrades to\n          //   paused-at-position. Requires a `startPosition` consumer in the\n          //   composition (`applyStartPosition`) — without one the position is\n          //   never restored either, so resuming would be wrong anyway.\n          // - **Superseded** (presentation changed): retract the command and\n          //   disarm, so neither the seek nor the resume reaches the new source.\n          const disposeRestoreWatch = effect(() => {\n            const url = state.presentation.get()?.url;\n            const position = state.startPosition.get();\n            if (!restoreOwnerUrl) return;\n\n            if (url !== restoreOwnerUrl) {\n              restoreOwnerUrl = undefined;\n              resumeWhenRestored = false;\n              if (position !== undefined) state.startPosition.set(undefined);\n              return;\n            }\n\n            if (position !== undefined) return;\n            restoreOwnerUrl = undefined;\n            if (!resumeWhenRestored) return;\n            resumeWhenRestored = false;\n            mediaElement.play().catch((err) => {\n              console.warn('[setupAirPlay] session-end resume play() rejected — staying paused:', err);\n            });\n          });\n\n          // This effect combines:\n          // - adding a native HLS fallback source when the mediaSource is\n          //   attached / removing it when it's detached — UNLESS a session is\n          //   live: during an AirPlay session the engine detaches its dead\n          //   MediaSource (see setupMediaSource's sourceclose recovery) while\n          //   the receiver is playing exactly this fallback source, so it\n          //   must survive until the session's falling edge (the rebuild's\n          //   republish then adopts it again).\n          // - keeping this sourceEl's src in sync with the current presentation.\n          // The created source is also cleaned on state exit.\n          // The dependence on context.mediaSource means the source is appended\n          // only after the MMS has been attached and opened (therefore we can\n          // flip disableRemotePlayback). Being in this state also implies\n          // that the author has not disabled remote playback.\n          let sourceEl: HTMLSourceElement | null = null;\n          const disposeSource = effect(() => {\n            const hasMediaSource = !!context.mediaSource.get();\n            const sessionActive = !!state.loadingSuspended.get();\n            const url = state.presentation.get()?.url ?? '';\n\n            if (!hasMediaSource && !sessionActive) {\n              sourceEl?.remove();\n              sourceEl = null;\n            } else if (hasMediaSource && (!sourceEl || sourceEl.parentNode !== mediaElement)) {\n              sourceEl = document.createElement('source');\n              sourceEl.type = 'application/x-mpegURL';\n              mediaElement.append(sourceEl);\n              mediaElement.disableRemotePlayback = false;\n            }\n            if (sourceEl) sourceEl.src = url;\n          });\n\n          // AirPlay may already be active at (re)attach.\n          sync();\n\n          return () => {\n            disposeSource();\n            disposeSourceChangeEnd();\n            disposeRestoreWatch();\n            listenerCleanup.abort();\n            clearTimeout(settleTimer);\n            sourceEl?.remove();\n            sourceEl = null;\n            // Undo the picker enable: hand the element back to its MMS-default\n            // `disableRemotePlayback = true`.\n            mediaElement.disableRemotePlayback = true;\n            // Don't strand the engine held/suspended if we tear down\n            // mid-session (author opt-out, detach, destroy).\n            state.loadingSuspended.set(false);\n            // Nor leave a restore command behind for the next source to apply.\n            if (restoreOwnerUrl) {\n              restoreOwnerUrl = undefined;\n              resumeWhenRestored = false;\n              if (peek(state.startPosition) !== undefined) state.startPosition.set(undefined);\n            }\n          };\n        },\n      },\n    },\n  });\n}\n\nexport const setupAirPlay = defineBehavior({\n  stateKeys: ['presentation', 'disableRemotePlayback', 'loadingSuspended', 'startPosition'],\n  contextKeys: ['mediaElement', 'mediaSource'],\n  setup: setupAirPlaySetup,\n});\n"],"mappings":"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"}

package/dist/default/playback/behaviors/dom/apply-start-position.js

@@ -0,0 +1,93 @@
+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 { listen } from "@videojs/utils/dom";
+import { isUndefined } from "@videojs/utils/predicate";
+//#region src/playback/behaviors/dom/apply-start-position.ts
+/**
+* **Start playback of a source at a requested position.** `state.startPosition`
+* is a one-shot command — "when the current source can seek, start there" —
+* the SPF analogue of hls.js's `startPosition` (and the primitive `EXT-X-START`,
+* resume-where-you-left-off, and MediaSource-recovery restore build on).
+* Consumers (adapters, `setupAirPlay`'s session-end snapshot) write it;
+* this behavior is its sole consumer and clears it after applying, so a
+* stale position can never replay against a later source or rebuild.
+*
+* Single-positive-state reactor (`'preconditions-unmet'` ↔ `'position-pending'`):
+* gated on `mediaElement + resolved presentation + startPosition` defined.
+* The entry applies the command in two steps:
+*
+* 1. **Seed `state.currentTime` immediately.** The segment loaders anchor
+*    their load window on `state.currentTime`; seeding points the *first*
+*    fetches at the requested position instead of 0. Multi-writer with
+*    `trackCurrentTime` (ongoing DOM mirror) — legitimate: different decision
+*    domains (element-derived mirror vs one-shot command), and before
+*    HAVE_METADATA no `timeupdate`/`seeking` fires to overwrite the seed.
+*    Compose this behavior *after* `trackCurrentTime` so the seed lands after
+*    the mirror's attach-time sync.
+* 2. **Seek the element at metadata.** `element.currentTime = position` once
+*    `readyState >= HAVE_METADATA` (immediately if already there, else on
+*    `loadedmetadata`), then clear `startPosition` (consume). The element
+*    clamps the seek to its seekable range per spec, and the resulting
+*    `seeking` event flows back through `trackCurrentTime` — from here the
+*    ordinary seek path owns the position.
+*
+* Position only — playing/paused is deliberately out of scope. The media
+* element load algorithm forces `paused = true`, so a source that was
+* playing before a rebuild comes back paused at the restored position;
+* resume intent belongs to whoever commands the start (e.g. `setupAirPlay`
+* restores its session-end playing state itself).
+*
+* Deliberately NOT relying on the pre-metadata "default playback start
+* position" write (setting `currentTime` at HAVE_NOTHING): cross-browser MSE
+* behavior there is inconsistent; the explicit `loadedmetadata` sequencing is
+* deterministic everywhere.
+*
+* State-exit cleanup (source reset, element detach, destroy) drops the
+* pending `loadedmetadata` listener. An *unapplied* command survives a source
+* reset — "start the source I'm loading at P" holds while the presentation
+* routes through unresolved — but is consumed the moment it applies.
+*/
+function deriveState(presentation, mediaElement, startPosition) {
+	if (!mediaElement || !isResolvedPresentation(presentation)) return "preconditions-unmet";
+	if (isUndefined(startPosition)) return "preconditions-unmet";
+	return "position-pending";
+}
+function applyStartPositionSetup({ state, context }) {
+	const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaElement.get(), state.startPosition.get()));
+	return createMachineReactor({
+		initial: "preconditions-unmet",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"preconditions-unmet": {},
+			"position-pending": { entry: () => {
+				const mediaElement = context.mediaElement.get();
+				const position = state.startPosition.get();
+				state.currentTime.set(position);
+				const apply = () => {
+					mediaElement.currentTime = position;
+					state.startPosition.set(void 0);
+				};
+				if (mediaElement.readyState >= HTMLMediaElement.HAVE_METADATA) {
+					apply();
+					return;
+				}
+				return listen(mediaElement, "loadedmetadata", apply, { once: true });
+			} }
+		}
+	});
+}
+const applyStartPosition = defineBehavior({
+	stateKeys: [
+		"presentation",
+		"startPosition",
+		"currentTime"
+	],
+	contextKeys: ["mediaElement"],
+	setup: applyStartPositionSetup
+});
+//#endregion
+export { applyStartPosition };
+
+//# sourceMappingURL=apply-start-position.js.map

package/dist/default/playback/behaviors/dom/apply-start-position.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-start-position.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/apply-start-position.ts"],"sourcesContent":["/**\n * **Start playback of a source at a requested position.** `state.startPosition`\n * is a one-shot command — \"when the current source can seek, start there\" —\n * the SPF analogue of hls.js's `startPosition` (and the primitive `EXT-X-START`,\n * resume-where-you-left-off, and MediaSource-recovery restore build on).\n * Consumers (adapters, `setupAirPlay`'s session-end snapshot) write it;\n * this behavior is its sole consumer and clears it after applying, so a\n * stale position can never replay against a later source or rebuild.\n *\n * Single-positive-state reactor (`'preconditions-unmet'` ↔ `'position-pending'`):\n * gated on `mediaElement + resolved presentation + startPosition` defined.\n * The entry applies the command in two steps:\n *\n * 1. **Seed `state.currentTime` immediately.** The segment loaders anchor\n *    their load window on `state.currentTime`; seeding points the *first*\n *    fetches at the requested position instead of 0. Multi-writer with\n *    `trackCurrentTime` (ongoing DOM mirror) — legitimate: different decision\n *    domains (element-derived mirror vs one-shot command), and before\n *    HAVE_METADATA no `timeupdate`/`seeking` fires to overwrite the seed.\n *    Compose this behavior *after* `trackCurrentTime` so the seed lands after\n *    the mirror's attach-time sync.\n * 2. **Seek the element at metadata.** `element.currentTime = position` once\n *    `readyState >= HAVE_METADATA` (immediately if already there, else on\n *    `loadedmetadata`), then clear `startPosition` (consume). The element\n *    clamps the seek to its seekable range per spec, and the resulting\n *    `seeking` event flows back through `trackCurrentTime` — from here the\n *    ordinary seek path owns the position.\n *\n * Position only — playing/paused is deliberately out of scope. The media\n * element load algorithm forces `paused = true`, so a source that was\n * playing before a rebuild comes back paused at the restored position;\n * resume intent belongs to whoever commands the start (e.g. `setupAirPlay`\n * restores its session-end playing state itself).\n *\n * Deliberately NOT relying on the pre-metadata \"default playback start\n * position\" write (setting `currentTime` at HAVE_NOTHING): cross-browser MSE\n * behavior there is inconsistent; the explicit `loadedmetadata` sequencing is\n * deterministic everywhere.\n *\n * State-exit cleanup (source reset, element detach, destroy) drops the\n * pending `loadedmetadata` listener. An *unapplied* command survives a source\n * reset — \"start the source I'm loading at P\" holds while the presentation\n * routes through unresolved — but is consumed the moment it applies.\n */\n\nimport { listen } from '@videojs/utils/dom';\nimport { isUndefined } from '@videojs/utils/predicate';\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 { isResolvedPresentation, type MaybeResolvedPresentation } from '../../../media/types';\n\nexport interface StartPositionState {\n  presentation?: MaybeResolvedPresentation;\n  /**\n   * One-shot start-position command in presentation-timeline seconds.\n   * Written by consumers (adapter, recovery snapshot); consumed (cleared)\n   * by `applyStartPosition` once the element seeks.\n   */\n  startPosition?: number;\n  currentTime?: number;\n}\n\nexport interface StartPositionContext {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\ntype StartPositionFsmState = 'preconditions-unmet' | 'position-pending';\n\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaElement: HTMLMediaElement | undefined,\n  startPosition: number | undefined\n): StartPositionFsmState {\n  if (!mediaElement || !isResolvedPresentation(presentation)) return 'preconditions-unmet';\n  if (isUndefined(startPosition)) return 'preconditions-unmet';\n  return 'position-pending';\n}\n\nfunction applyStartPositionSetup({\n  state,\n  context,\n}: {\n  state: {\n    presentation: ReadonlySignal<StartPositionState['presentation']>;\n    startPosition: Signal<StartPositionState['startPosition']>;\n    currentTime: Signal<StartPositionState['currentTime']>;\n  };\n  context: {\n    mediaElement: ReadonlySignal<StartPositionContext['mediaElement']>;\n  };\n}): Reactor<StartPositionFsmState | 'destroying' | 'destroyed'> {\n  const derivedStateSignal = computed(() =>\n    deriveState(state.presentation.get(), context.mediaElement.get(), state.startPosition.get())\n  );\n\n  return createMachineReactor<StartPositionFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'position-pending': {\n        // entry body is auto-untracked. Consuming the command flips the\n        // monitor back to 'preconditions-unmet'; the state-exit cleanup then\n        // drops the (already-fired) listener.\n        entry: () => {\n          const mediaElement = context.mediaElement.get()!;\n          const position = state.startPosition.get()!;\n\n          // Step 1 — point the loaders' first load window at the position.\n          state.currentTime.set(position);\n\n          // Step 2 — seek once the element can honor it, then consume.\n          const apply = () => {\n            mediaElement.currentTime = position;\n            state.startPosition.set(undefined);\n          };\n\n          if (mediaElement.readyState >= HTMLMediaElement.HAVE_METADATA) {\n            apply();\n            return;\n          }\n          return listen(mediaElement, 'loadedmetadata', apply, { once: true });\n        },\n      },\n    },\n  });\n}\n\nexport const applyStartPosition = defineBehavior({\n  stateKeys: ['presentation', 'startPosition', 'currentTime'],\n  contextKeys: ['mediaElement'],\n  setup: applyStartPositionSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsEA,SAAS,YACP,cACA,cACA,eACuB;CACvB,IAAI,CAAC,gBAAgB,CAAC,uBAAuB,YAAY,GAAG,OAAO;CACnE,IAAI,YAAY,aAAa,GAAG,OAAO;CACvC,OAAO;AACT;AAEA,SAAS,wBAAwB,EAC/B,OACA,WAU8D;CAC9D,MAAM,qBAAqB,eACzB,YAAY,MAAM,aAAa,IAAI,GAAG,QAAQ,aAAa,IAAI,GAAG,MAAM,cAAc,IAAI,CAAC,CAC7F;CAEA,OAAO,qBAA4C;EACjD,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,CAAC;GAExB,oBAAoB,EAIlB,aAAa;IACX,MAAM,eAAe,QAAQ,aAAa,IAAI;IAC9C,MAAM,WAAW,MAAM,cAAc,IAAI;IAGzC,MAAM,YAAY,IAAI,QAAQ;IAG9B,MAAM,cAAc;KAClB,aAAa,cAAc;KAC3B,MAAM,cAAc,IAAI,KAAA,CAAS;IACnC;IAEA,IAAI,aAAa,cAAc,iBAAiB,eAAe;KAC7D,MAAM;KACN;IACF;IACA,OAAO,OAAO,cAAc,kBAAkB,OAAO,EAAE,MAAM,KAAK,CAAC;GACrE,EACF;EACF;CACF,CAAC;AACH;AAEA,MAAa,qBAAqB,eAAe;CAC/C,WAAW;EAAC;EAAgB;EAAiB;CAAa;CAC1D,aAAa,CAAC,cAAc;CAC5B,OAAO;AACT,CAAC"}

package/dist/default/playback/behaviors/dom/end-of-stream.js

@@ -0,0 +1,102 @@
+import { computed, signal } from "../../../core/signals/primitives.js";
+import { effect } from "../../../core/signals/effect.js";
+import { createMachineReactor } from "../../../core/reactors/create-machine-reactor.js";
+import { isResolvedTrack } from "../../../media/types/index.js";
+import { findTrackById } from "../../../media/utils/tracks.js";
+import { onMediaSourceReadyStateChange } from "../../../media/dom/mse/mediasource-setup.js";
+import { getMaxBufferedEnd, waitForSourceBuffersReady } from "../../../media/dom/mse/duration.js";
+import { isLastSegmentAppended } from "../../../media/dom/mse/end-of-stream.js";
+//#region src/playback/behaviors/dom/end-of-stream.ts
+/**
+* Slack (seconds) on the "playhead has reached the last segment" gate. A tiny final
+* segment (e.g. Apple's ~44ms last segment) starts right at the buffered end, and the
+* browser freezes the playhead ~50–70ms short of that end (its render horizon), so a
+* strict `currentTime >= lastSegStart` would never open — deadlocking `endOfStream`
+* (the MediaSource stays `'open'`, so the browser keeps the playhead frozen waiting for
+* data/EOS that never comes). This slack lets a playhead stalled just short of the final
+* segment still finalize. Firing slightly early is harmless: the last segment is already
+* appended (the gate above), so no more data is expected.
+*/
+const LAST_SEGMENT_REACHED_SLACK = .5;
+function deriveState(presentation, mediaSource, msIsOpen, videoBufferActor, audioBufferActor, currentTime) {
+	if (!mediaSource || !presentation || !msIsOpen) return "preconditions-unmet";
+	const actors = [videoBufferActor, audioBufferActor].filter((a) => a !== void 0);
+	if (actors.length === 0) return "preconditions-unmet";
+	let lastSegStart;
+	for (const actor of actors) {
+		const snapshot = actor.snapshot.get();
+		if (snapshot.value !== "idle") return "preconditions-unmet";
+		const { initTrackId, segments: appended } = snapshot.context;
+		if (!initTrackId) return "preconditions-unmet";
+		const track = findTrackById(presentation, initTrackId);
+		if (!track || !isResolvedTrack(track)) return "preconditions-unmet";
+		if (!Number.isFinite(track.duration)) return "preconditions-unmet";
+		if (!isLastSegmentAppended(track.segments, appended)) return "preconditions-unmet";
+		if (track.segments.length > 0) {
+			const start = track.segments[track.segments.length - 1].startTime;
+			if (lastSegStart === void 0 || start > lastSegStart) lastSegStart = start;
+		}
+	}
+	if (lastSegStart !== void 0 && (currentTime ?? 0) < lastSegStart - LAST_SEGMENT_REACHED_SLACK) return "preconditions-unmet";
+	return "eos-ready";
+}
+function endOfStreamSetup({ state, context }) {
+	const msIsOpen = signal(false);
+	const cleanupMsListener = effect(() => {
+		const mediaSource = context.mediaSource.get();
+		if (!mediaSource) {
+			msIsOpen.set(false);
+			return;
+		}
+		msIsOpen.set(mediaSource.readyState === "open");
+		const controller = new AbortController();
+		onMediaSourceReadyStateChange(mediaSource, controller.signal, (rs) => {
+			msIsOpen.set(rs === "open");
+		});
+		return () => controller.abort();
+	});
+	const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaSource.get(), msIsOpen.get(), context.videoBufferActor?.get(), context.audioBufferActor?.get(), state.currentTime.get()));
+	const reactor = createMachineReactor({
+		initial: "preconditions-unmet",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"preconditions-unmet": {},
+			"eos-ready": { entry: () => {
+				const mediaSource = context.mediaSource.get();
+				const controller = new AbortController();
+				const endStreamWhenReady = async () => {
+					await waitForSourceBuffersReady(mediaSource.sourceBuffers, controller.signal);
+					if (controller.signal.aborted) return;
+					const bufferedEnd = getMaxBufferedEnd(mediaSource.sourceBuffers);
+					if (bufferedEnd > 0) mediaSource.duration = bufferedEnd;
+					mediaSource.endOfStream();
+				};
+				endStreamWhenReady().catch((err) => console.error("Failed to call endOfStream:", err));
+				return () => controller.abort();
+			} }
+		}
+	});
+	return () => {
+		cleanupMsListener();
+		reactor.destroy();
+	};
+}
+/**
+* `endOfStream` uses a manual `Behavior<>` literal (rather than
+* `defineBehavior`) because it reads `videoBufferActor` /
+* `audioBufferActor` defensively without declaring them in its
+* contextKeys — those slots are contributed by other behaviors and
+* compose conditionally per engine variant. The `Behavior<>` literal
+* opts out of the exhaustiveness check so the typed context shape can
+* include the optional fields used at runtime. See the comment on
+* `endOfStreamSetup`'s context param for the discipline.
+*/
+const endOfStream = {
+	stateKeys: ["presentation", "currentTime"],
+	contextKeys: ["mediaSource"],
+	setup: endOfStreamSetup
+};
+//#endregion
+export { endOfStream };
+
+//# sourceMappingURL=end-of-stream.js.map

package/dist/default/playback/behaviors/dom/end-of-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"end-of-stream.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/end-of-stream.ts"],"sourcesContent":["/**\n * **Drive each `open → ended` transition of the MediaSource.** Calls\n * `MediaSource.endOfStream()` once every active buffer actor's\n * currently-loading track is *complete* (finite `Track.duration` — the parser's\n * completeness signal), its temporally last segments are fully appended, and\n * the user has reached them — letting the browser finalize duration and\n * fire `ended` on the media element. The completeness gate keeps it inert for\n * ongoing live (`Track.duration === Infinity`), whose \"last segment\" is only\n * the rolling edge; a live stream opts in when its duration turns finite.\n *\n * Re-fires on every subsequent `open → ended → open` cycle. Per the MSE\n * spec, `appendBuffer()` after `endOfStream()` transitions the MediaSource\n * back to `'open'`; seek-back replays and back-buffer refills that re-load\n * earlier segments take this path, so the behavior must call\n * `endOfStream()` again once the last segments are reappended. The reactor's\n * `'preconditions-unmet'` ↔ `'eos-ready'` cycle *is* the re-arm mechanism:\n * a successful `endOfStream()` flips `mediaSource.readyState` to `'ended'`,\n * which (via the local `msIsOpen` signal) exits `'eos-ready'`; the next\n * `'open'` re-evaluates preconditions and may re-enter.\n *\n * # Tracking what's in the buffer\n *\n * Each `SourceBufferActor` knows which track it's currently loading via\n * `initTrackId` (set on the most recent `append-init` message) and which\n * segments it has appended. `deriveState` iterates over the available\n * buffer actors (`[videoBufferActor, audioBufferActor].filter(Boolean)`),\n * resolves each to its track via `findTrackById`, and checks that track's\n * last segment is appended. This means audio-only / video-only / mixed\n * configurations compose uniformly — the body iterates whatever's in\n * scope. No reliance on `selectedTrackId` slots: the actor's view IS the\n * source of truth for \"what's being loaded into this buffer.\"\n *\n * **Two-fire on mid-end ABR switches**: when a quality switch occurs near\n * end-of-stream, the actor's `initTrackId` still reflects the *old* track\n * until the new init segment is appended. The reactor may fire\n * `endOfStream()` against the old track's last-segment-appended state,\n * then the new init's `appendBuffer()` re-opens the MS, which re-arms us\n * to fire again once the new track's last segment lands. Functionally\n * correct (the browser re-fires `ended` after the re-arm), at the cost of\n * one extra call. Accepted as the price of dropping `selectedTrackId`\n * dependence.\n *\n * # Buffer-actor idle gate\n *\n * Each actor must be `'idle'` (no queued or in-flight tasks) before we\n * fire. `buffer.updating === false` alone is insufficient: for chunked\n * fMP4 streaming, `updateend` fires after each chunk while the actor's\n * for-await loop synchronously enqueues the next `appendBuffer()` — so\n * the buffer flips `!updating → updating` across a microtask boundary.\n * The actor's `'updating'` state spans the entire multi-chunk append, so\n * `actor.snapshot.value === 'idle'` is the canonical \"no more pending or\n * in-flight work\" oracle.\n *\n * This bet (actor models the pipeline; `mediaSource.sourceBuffers` models\n * DOM state) is durable as long as the segment loader is the sole writer\n * of `appendBuffer()` calls. A future loop-mode that auto-fetches earlier\n * segments mid-`ended` would require a broader coordination story\n * between SourceBuffers and the MediaSource — possibly via a\n * `MediaSourceActor` — and that's where this gate would want\n * re-evaluating.\n *\n * # currentTime gate\n *\n * `currentTime` must have reached (within {@link LAST_SEGMENT_REACHED_SLACK})\n * at least one active track's last segment startTime. Prevents `'eos-ready'`\n * entry when a back-buffer `remove()` / `appendBuffer()` briefly re-opens the\n * MediaSource while the user is mid-stream. HLS rendition time-alignment means\n * any active track works as the reference. The slack absorbs the near-end\n * playhead freeze (see the constant) so a tiny final segment doesn't deadlock.\n *\n * # MS readyState — local subscription\n *\n * The behavior subscribes to `mediaSource`'s readyState changes inside\n * its setup (via `onMediaSourceReadyStateChange`) and mirrors `'open'` to\n * a behavior-local `msIsOpen` signal that `deriveState` reads. No shared\n * `mediaSourceReadyState` slot dependency. Anticipates a future\n * `MediaSourceActor` whose snapshot would expose the same signal — the\n * consumer code wouldn't change.\n *\n * # `endOfStream` entry sequence\n *\n * 1. Wait for all SourceBuffers to be idle (DOM-level — defensive,\n *    should already hold given the actor-idle gate in `deriveState`).\n * 2. Set `mediaSource.duration` from `getMaxBufferedEnd` to match actual\n *    container timestamps (`endOfStream()` only clamps up implicitly;\n *    setting it explicitly here keeps the final value deterministic).\n * 3. Call `mediaSource.endOfStream()`.\n *\n * State-exit cleanup (`controller.abort()`) cancels any in-flight wait\n * on source unload, presentation replace, or behavior destroy.\n *\n * # Coordination with `updateMediaSourceDuration`\n *\n * `updateMediaSourceDuration` writes the initial `mediaSource.duration`\n * from `presentation.duration` once per source; this behavior writes the\n * final value from the buffered end. Decision domains don't overlap.\n */\nimport type { Behavior } from '../../../core/composition/create-composition';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { effect } from '../../../core/signals/effect';\nimport { computed, type ReadonlySignal, signal } from '../../../core/signals/primitives';\nimport { getMaxBufferedEnd, waitForSourceBuffersReady } from '../../../media/dom/mse/duration';\nimport { isLastSegmentAppended } from '../../../media/dom/mse/end-of-stream';\nimport { onMediaSourceReadyStateChange } from '../../../media/dom/mse/mediasource-setup';\nimport type { MaybeResolvedPresentation } from '../../../media/types';\nimport { isResolvedTrack } from '../../../media/types';\nimport { findTrackById } from '../../../media/utils/tracks';\nimport type { SourceBufferActor } from '../../actors/dom/source-buffer';\n\nexport interface EndOfStreamState {\n  presentation?: MaybeResolvedPresentation;\n  currentTime?: number;\n}\n\nexport interface EndOfStreamContext {\n  mediaSource?: MediaSource;\n  videoBufferActor?: SourceBufferActor;\n  audioBufferActor?: SourceBufferActor;\n}\n\ntype EndOfStreamFsmState = 'preconditions-unmet' | 'eos-ready';\n\n/**\n * Slack (seconds) on the \"playhead has reached the last segment\" gate. A tiny final\n * segment (e.g. Apple's ~44ms last segment) starts right at the buffered end, and the\n * browser freezes the playhead ~50–70ms short of that end (its render horizon), so a\n * strict `currentTime >= lastSegStart` would never open — deadlocking `endOfStream`\n * (the MediaSource stays `'open'`, so the browser keeps the playhead frozen waiting for\n * data/EOS that never comes). This slack lets a playhead stalled just short of the final\n * segment still finalize. Firing slightly early is harmless: the last segment is already\n * appended (the gate above), so no more data is expected.\n */\nconst LAST_SEGMENT_REACHED_SLACK = 0.5;\n\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined,\n  msIsOpen: boolean,\n  videoBufferActor: SourceBufferActor | undefined,\n  audioBufferActor: SourceBufferActor | undefined,\n  currentTime: number | undefined\n): EndOfStreamFsmState {\n  if (!mediaSource || !presentation || !msIsOpen) return 'preconditions-unmet';\n\n  const actors = [videoBufferActor, audioBufferActor].filter((a): a is SourceBufferActor => a !== undefined);\n  // No active buffer actors means setup hasn't completed wiring yet.\n  if (actors.length === 0) return 'preconditions-unmet';\n\n  // Track the latest last-segment startTime across actors as the\n  // currentTime reference. HLS rendition time-alignment makes any active\n  // track usable; using the max is safest when timings drift slightly.\n  let lastSegStart: number | undefined;\n\n  for (const actor of actors) {\n    const snapshot = actor.snapshot.get();\n    if (snapshot.value !== 'idle') return 'preconditions-unmet';\n\n    const { initTrackId, segments: appended } = snapshot.context;\n    if (!initTrackId) return 'preconditions-unmet';\n\n    const track = findTrackById(presentation, initTrackId);\n    if (!track || !isResolvedTrack(track)) return 'preconditions-unmet';\n    // Only a complete playlist has a true last segment: firing on an ongoing\n    // live window would pin a finite (live-edge) duration and end the stream,\n    // only for the next reload's appends to reopen it and re-fire on a loop.\n    // Independent of the currentTime slack below — this asks \"is there an end at\n    // all,\" the slack asks \"has the playhead effectively reached it.\"\n    if (!Number.isFinite(track.duration)) return 'preconditions-unmet';\n    if (!isLastSegmentAppended(track.segments, appended)) return 'preconditions-unmet';\n\n    if (track.segments.length > 0) {\n      const start = track.segments[track.segments.length - 1]!.startTime;\n      if (lastSegStart === undefined || start > lastSegStart) lastSegStart = start;\n    }\n  }\n\n  // Slack absorbs the near-end playhead freeze so a tiny final segment doesn't deadlock.\n  if (lastSegStart !== undefined && (currentTime ?? 0) < lastSegStart - LAST_SEGMENT_REACHED_SLACK) {\n    return 'preconditions-unmet';\n  }\n\n  return 'eos-ready';\n}\n\nfunction endOfStreamSetup({\n  state,\n  context,\n}: {\n  state: {\n    presentation: ReadonlySignal<EndOfStreamState['presentation']>;\n    currentTime: ReadonlySignal<EndOfStreamState['currentTime']>;\n  };\n  context: {\n    mediaSource: ReadonlySignal<EndOfStreamContext['mediaSource']>;\n    // See behavior definition for details on these optional context signals.\n    videoBufferActor?: ReadonlySignal<SourceBufferActor | undefined>;\n    audioBufferActor?: ReadonlySignal<SourceBufferActor | undefined>;\n  };\n}): () => void {\n  // Behavior-local mirror of `mediaSource.readyState === 'open'`. Subscribes\n  // to MS events whenever a MediaSource is in scope; tears down when the\n  // MS is swapped or the behavior destroys. Anticipates a future\n  // `MediaSourceActor` whose snapshot would expose the same value — the\n  // consumer code (deriveState) wouldn't change.\n  const msIsOpen = signal(false);\n  const cleanupMsListener = effect(() => {\n    const mediaSource = context.mediaSource.get();\n    if (!mediaSource) {\n      msIsOpen.set(false);\n      return;\n    }\n    msIsOpen.set(mediaSource.readyState === 'open');\n    const controller = new AbortController();\n    onMediaSourceReadyStateChange(mediaSource, controller.signal, (rs) => {\n      msIsOpen.set(rs === 'open');\n    });\n    return () => controller.abort();\n  });\n\n  const derivedStateSignal = computed(() =>\n    deriveState(\n      state.presentation.get(),\n      context.mediaSource.get(),\n      msIsOpen.get(),\n      context.videoBufferActor?.get(),\n      context.audioBufferActor?.get(),\n      state.currentTime.get()\n    )\n  );\n\n  const reactor = createMachineReactor<EndOfStreamFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'eos-ready': {\n        // entry body is auto-untracked. deriveState handles source resets\n        // and the MS readyState flip from 'open' to 'ended' that\n        // endOfStream() produces; this entry resolves the MSE-spec\n        // preconditions and binds its cleanup (abort) to state exit +\n        // destroy.\n        entry: () => {\n          const mediaSource = context.mediaSource.get()!;\n          const controller = new AbortController();\n\n          const endStreamWhenReady = async () => {\n            // Defensive: the actor-idle gate in deriveState should mean\n            // buffers are already settled, but a microtask boundary\n            // between deriveState's read and entry firing leaves a thin\n            // gap. The DOM-level wait closes it.\n            await waitForSourceBuffersReady(mediaSource.sourceBuffers, controller.signal);\n            if (controller.signal.aborted) return;\n\n            // MSE spec: duration cannot be less than any buffered range, and\n            // endOfStream() will only clamp up implicitly. Setting it\n            // explicitly here from actual container timestamps keeps the\n            // final value deterministic for assets whose declared duration\n            // disagrees with the buffered end (common with CMAF).\n            const bufferedEnd = getMaxBufferedEnd(mediaSource.sourceBuffers);\n            if (bufferedEnd > 0) mediaSource.duration = bufferedEnd;\n\n            mediaSource.endOfStream();\n          };\n\n          endStreamWhenReady().catch((err) => console.error('Failed to call endOfStream:', err));\n\n          return () => controller.abort();\n        },\n      },\n    },\n  });\n\n  return () => {\n    cleanupMsListener();\n    reactor.destroy();\n  };\n}\n\n/**\n * `endOfStream` uses a manual `Behavior<>` literal (rather than\n * `defineBehavior`) because it reads `videoBufferActor` /\n * `audioBufferActor` defensively without declaring them in its\n * contextKeys — those slots are contributed by other behaviors and\n * compose conditionally per engine variant. The `Behavior<>` literal\n * opts out of the exhaustiveness check so the typed context shape can\n * include the optional fields used at runtime. See the comment on\n * `endOfStreamSetup`'s context param for the discipline.\n */\nexport const endOfStream: Behavior<\n  {\n    presentation: ReadonlySignal<EndOfStreamState['presentation']>;\n    currentTime: ReadonlySignal<EndOfStreamState['currentTime']>;\n  },\n  { mediaSource: ReadonlySignal<EndOfStreamContext['mediaSource']> }\n> = {\n  stateKeys: ['presentation', 'currentTime'],\n  contextKeys: ['mediaSource'],\n  setup: endOfStreamSetup,\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAoIA,MAAM,6BAA6B;AAEnC,SAAS,YACP,cACA,aACA,UACA,kBACA,kBACA,aACqB;CACrB,IAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC,UAAU,OAAO;CAEvD,MAAM,SAAS,CAAC,kBAAkB,gBAAgB,CAAC,CAAC,QAAQ,MAA8B,MAAM,KAAA,CAAS;CAEzG,IAAI,OAAO,WAAW,GAAG,OAAO;CAKhC,IAAI;CAEJ,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,MAAM,SAAS,IAAI;EACpC,IAAI,SAAS,UAAU,QAAQ,OAAO;EAEtC,MAAM,EAAE,aAAa,UAAU,aAAa,SAAS;EACrD,IAAI,CAAC,aAAa,OAAO;EAEzB,MAAM,QAAQ,cAAc,cAAc,WAAW;EACrD,IAAI,CAAC,SAAS,CAAC,gBAAgB,KAAK,GAAG,OAAO;EAM9C,IAAI,CAAC,OAAO,SAAS,MAAM,QAAQ,GAAG,OAAO;EAC7C,IAAI,CAAC,sBAAsB,MAAM,UAAU,QAAQ,GAAG,OAAO;EAE7D,IAAI,MAAM,SAAS,SAAS,GAAG;GAC7B,MAAM,QAAQ,MAAM,SAAS,MAAM,SAAS,SAAS,EAAE,CAAE;GACzD,IAAI,iBAAiB,KAAA,KAAa,QAAQ,cAAc,eAAe;EACzE;CACF;CAGA,IAAI,iBAAiB,KAAA,MAAc,eAAe,KAAK,eAAe,4BACpE,OAAO;CAGT,OAAO;AACT;AAEA,SAAS,iBAAiB,EACxB,OACA,WAYa;CAMb,MAAM,WAAW,OAAO,KAAK;CAC7B,MAAM,oBAAoB,aAAa;EACrC,MAAM,cAAc,QAAQ,YAAY,IAAI;EAC5C,IAAI,CAAC,aAAa;GAChB,SAAS,IAAI,KAAK;GAClB;EACF;EACA,SAAS,IAAI,YAAY,eAAe,MAAM;EAC9C,MAAM,aAAa,IAAI,gBAAgB;EACvC,8BAA8B,aAAa,WAAW,SAAS,OAAO;GACpE,SAAS,IAAI,OAAO,MAAM;EAC5B,CAAC;EACD,aAAa,WAAW,MAAM;CAChC,CAAC;CAED,MAAM,qBAAqB,eACzB,YACE,MAAM,aAAa,IAAI,GACvB,QAAQ,YAAY,IAAI,GACxB,SAAS,IAAI,GACb,QAAQ,kBAAkB,IAAI,GAC9B,QAAQ,kBAAkB,IAAI,GAC9B,MAAM,YAAY,IAAI,CACxB,CACF;CAEA,MAAM,UAAU,qBAA0C;EACxD,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,CAAC;GAExB,aAAa,EAMX,aAAa;IACX,MAAM,cAAc,QAAQ,YAAY,IAAI;IAC5C,MAAM,aAAa,IAAI,gBAAgB;IAEvC,MAAM,qBAAqB,YAAY;KAKrC,MAAM,0BAA0B,YAAY,eAAe,WAAW,MAAM;KAC5E,IAAI,WAAW,OAAO,SAAS;KAO/B,MAAM,cAAc,kBAAkB,YAAY,aAAa;KAC/D,IAAI,cAAc,GAAG,YAAY,WAAW;KAE5C,YAAY,YAAY;IAC1B;IAEA,mBAAmB,CAAC,CAAC,OAAO,QAAQ,QAAQ,MAAM,+BAA+B,GAAG,CAAC;IAErF,aAAa,WAAW,MAAM;GAChC,EACF;EACF;CACF,CAAC;CAED,aAAa;EACX,kBAAkB;EAClB,QAAQ,QAAQ;CAClB;AACF;;;;;;;;;;;AAYA,MAAa,cAMT;CACF,WAAW,CAAC,gBAAgB,aAAa;CACzC,aAAa,CAAC,aAAa;CAC3B,OAAO;AACT"}