@videojs/spf 10.0.0-beta.9 → 10.0.0-rc.2

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

@@ -0,0 +1,69 @@
+import { MaybeResolvedPresentation } from "../../../media/types/index.js";
+import { ReadonlySignal } from "../../../core/signals/primitives.js";
+import { Reactor } from "../../../core/reactors/create-machine-reactor.js";
+import { SegmentLoaderActor } from "../../actors/dom/segment-loader.js";
+import { TextTrackSegmentLoaderActor } from "../../actors/text-track-segment-loader.js";
+//#region src/playback/behaviors/dom/load-segments.d.ts
+/** State shape for segment loading. */
+interface SegmentLoadingState {
+  presentation?: MaybeResolvedPresentation;
+  preload?: string;
+  /** Current playback position in seconds. Defaults to 0 when undefined. */
+  currentTime?: number;
+  /** True once a preload-overriding event has fired for the current source. */
+  loadActivated?: boolean;
+  /**
+   * Intent-level policy input: initiate no new loading work while `true`. Read here by the `loadXSegments` dispatchers
+   * (park in `'dormant'`, highest precedence) and by `setupMediaSource` (a pending MediaSource rebuild waits — attach
+   * runs the element's load algorithm). **Observed, never declared**: no reader lists this key in `stateKeys`, so the
+   * slot exists only in compositions where a feature behavior declares and writes it (e.g. `setupAirPlay`, while a
+   * remote-playback session owns presentation). An absent slot means never suspended.
+   */
+  loadingSuspended?: boolean;
+  selectedVideoTrackId?: string;
+  selectedAudioTrackId?: string;
+  selectedTextTrackId?: string;
+}
+/** Context shape for segment loading. Each variant only consumes its own type's loader actor. */
+interface SegmentLoadingContext {
+  videoSegmentLoaderActor?: SegmentLoaderActor;
+  audioSegmentLoaderActor?: SegmentLoaderActor;
+  textTrackSegmentLoaderActor?: TextTrackSegmentLoaderActor;
+}
+type SegmentLoadingFsmState = 'preconditions-unmet' | 'dormant' | 'metadata-only' | 'full-range';
+type SelectedTrackKey = 'selectedVideoTrackId' | 'selectedAudioTrackId' | 'selectedTextTrackId';
+type SegmentLoadingStateMap<K extends SelectedTrackKey> = {
+  presentation: ReadonlySignal<SegmentLoadingState['presentation']>;
+  preload: ReadonlySignal<SegmentLoadingState['preload']>;
+  currentTime: ReadonlySignal<SegmentLoadingState['currentTime']>;
+  loadActivated: ReadonlySignal<SegmentLoadingState['loadActivated']>;
+} & { [P in K]: ReadonlySignal<SegmentLoadingState[P]>; };
+declare const loadVideoSegments: {
+  stateKeys: readonly ["presentation", "preload", "currentTime", "loadActivated", "selectedVideoTrackId"];
+  contextKeys: readonly ["videoSegmentLoaderActor"];
+  setup: (deps: {
+    state: SegmentLoadingStateMap<"selectedVideoTrackId">;
+  } & {
+    context: {
+      videoSegmentLoaderActor: ReadonlySignal<SegmentLoadingContext['videoSegmentLoaderActor']>;
+    };
+  } & {
+    config?: object;
+  }) => Reactor<"destroyed" | "destroying" | SegmentLoadingFsmState>;
+};
+declare const loadAudioSegments: {
+  stateKeys: readonly ["presentation", "preload", "currentTime", "loadActivated", "selectedAudioTrackId"];
+  contextKeys: readonly ["audioSegmentLoaderActor"];
+  setup: (deps: {
+    state: SegmentLoadingStateMap<"selectedAudioTrackId">;
+  } & {
+    context: {
+      audioSegmentLoaderActor: ReadonlySignal<SegmentLoadingContext['audioSegmentLoaderActor']>;
+    };
+  } & {
+    config?: object;
+  }) => Reactor<"destroyed" | "destroying" | SegmentLoadingFsmState>;
+};
+//#endregion
+export { SegmentLoadingContext, SegmentLoadingState, loadAudioSegments, loadVideoSegments };
+//# sourceMappingURL=load-segments.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"load-segments.d.ts","names":[],"sources":["../../../../../src/playback/behaviors/dom/load-segments.ts"],"mappings":";;;;;;;UA8DiB;EACf,eAAe;EACf;;EAEA;;EAEA;;;;;;;;EAQA;EACA;EACA;EACA;;;UAIe;EACf,0BAA0B;EAC1B,0BAA0B;EAC1B,8BAA8B;;KAO3B;KAEA;KAGA,uBAAuB,UAAU;EACpC,cAAc,eAAe;EAC7B,SAAS,eAAe;EACxB,aAAa,eAAe;EAC5B,eAAe,eAAe;OACzB,KAAK,IAAI,eAAe,oBAAoB;cA4ItC;;;;;;;MAUkB,yBAAA,eAAe;;;;;;cAWjC;;;;;;;MAUkB,yBAAA,eAAe"}

package/dist/dev/playback/behaviors/dom/load-segments.js

@@ -0,0 +1,169 @@
+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 { DEFAULT_FORWARD_BUFFER_CONFIG, segmentStartForTime } from "../../../media/buffer/forward-buffer.js";
+import { findResolvedAudioTrack, findResolvedTextTrack, findResolvedVideoTrack } from "../../../media/utils/tracks.js";
+import { AUDIO_TYPE_CONFIG, TEXT_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from "../../primitives/track-types.js";
+//#region src/playback/behaviors/dom/load-segments.ts
+/**
+* **Per-type segment loading dispatch.** Per available track type (video / audio / text), reads the per-type
+* segment-loader actor from context and sends typed `'load'` messages whenever a meaningful loading condition changes
+* (selected track, current time crossing a segment boundary).
+*
+* Loader-actor lifecycle is owned upstream:
+*
+* - Video: `setupVideoBufferActors`
+* - Audio: `setupAudioBufferActors`
+* - Text: `setupTextTrackActors`
+*
+* This behavior is pure-consumer: it reads `context[loaderKey]` and dispatches typed messages via the variant's
+* per-type `findResolvedTrack` resolver.
+*
+* # Load modes as reactor states
+*
+* Four states encode the load-gating policy directly:
+*
+* - `'preconditions-unmet'` — no loader actor in context, or the selected track hasn't resolved.
+* - `'dormant'` — loading disabled by policy: an observed `loadingSuspended` (highest precedence) or `preload === 'none'
+*   && !loadActivated`. Nothing fires; already-queued loader work drains. Auto-resumes into the derived state when the
+*   policy lifts.
+* - `'metadata-only'` — `!loadActivated && preload !== 'auto' && preload !== 'none'`. Fires an init-segment-only `load`
+*   message **once on entry**. The variant's loader actor decides what to do — v/a's actor fetches the init segment;
+*   text's actor no-ops (no init concept).
+* - `'full-range'` — `loadActivated || preload === 'auto'`. Effect re-fires on selected-track change and on
+*   segment-boundary crossing.
+*
+* # Per-type parameterization (inference-driven)
+*
+* The helper is generic over `Track` — the resolved-track type. Each variant supplies its own `findResolvedTrack`
+* resolver via config; TS infers `Track` from the resolver's return type. The loader signal's value type is constrained
+* to `SegmentLoaderLike<Track>` — anything with a `send` method accepting the `Track`-parameterized message. Concrete
+* actor types (`SegmentLoaderActor`, `TextTrackSegmentLoaderActor`) satisfy this via function-parameter contravariance:
+* an actor whose `.send` accepts a wider track type is assignable to a slot expecting a narrower track type.
+*
+* No widening of actor message types is needed; no casts inside the helper. Per-variant wiring (right loader paired
+* with right resolver) is enforced at the variant call site.
+*/
+/**
+* Specialization helper. Generic over `Track` (inferred from `findResolvedTrack`'s return type). The loader value type
+* is constrained to `SegmentLoaderLike<Track>` — concrete actor types (whose `.send` accepts a wider track union)
+* satisfy this via function-parameter contravariance.
+*
+* Tracks that the helper handles must have a `segments` field — used by `segmentBoundarySignal` to compute the
+* load-anchor boundary. Each variant's resolver narrows to the right resolved-track shape.
+*/
+function setupSegmentLoading({ state, context, config }) {
+	const { selectedKey, loaderKey, findResolvedTrack } = config;
+	const bufferDuration = config.forwardBuffer?.bufferDuration ?? DEFAULT_FORWARD_BUFFER_CONFIG.bufferDuration;
+	const selectedTrack = computed(() => findResolvedTrack(state.presentation.get(), state[selectedKey].get()));
+	const segmentBoundarySignal = computed(() => {
+		const track = selectedTrack.get();
+		if (!track) return void 0;
+		return segmentStartForTime(state.currentTime.get() ?? 0, track.segments);
+	});
+	const derivedStateSignal = computed(() => {
+		if (state.loadingSuspended?.get()) return "dormant";
+		if (!context[loaderKey].get() || !selectedTrack.get()) return "preconditions-unmet";
+		if (state.loadActivated.get() || state.preload.get() === "auto") return "full-range";
+		if (state.preload.get() === "none") return "dormant";
+		return "metadata-only";
+	});
+	return createMachineReactor({
+		initial: "preconditions-unmet",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"preconditions-unmet": {},
+			dormant: {},
+			"metadata-only": { entry: () => {
+				const track = selectedTrack.get();
+				context[loaderKey].get().send({
+					type: "load",
+					track
+				});
+			} },
+			"full-range": { effects: () => {
+				const track = selectedTrack.get();
+				segmentBoundarySignal.get();
+				const currentTime = peek(state.currentTime) ?? 0;
+				peek(context[loaderKey]).send({
+					type: "load",
+					track,
+					range: {
+						start: currentTime,
+						end: currentTime + bufferDuration
+					}
+				});
+			} }
+		}
+	});
+}
+const VIDEO_SEGMENT_LOADING_CONFIG = {
+	...VIDEO_TYPE_CONFIG,
+	findResolvedTrack: findResolvedVideoTrack
+};
+const AUDIO_SEGMENT_LOADING_CONFIG = {
+	...AUDIO_TYPE_CONFIG,
+	findResolvedTrack: findResolvedAudioTrack
+};
+const TEXT_SEGMENT_LOADING_CONFIG = {
+	...TEXT_TYPE_CONFIG,
+	findResolvedTrack: findResolvedTextTrack
+};
+const loadVideoSegments = defineBehavior({
+	stateKeys: [
+		"presentation",
+		"preload",
+		"currentTime",
+		"loadActivated",
+		"selectedVideoTrackId"
+	],
+	contextKeys: ["videoSegmentLoaderActor"],
+	setup: ({ state, context, config = {} }) => setupSegmentLoading({
+		state,
+		context,
+		config: {
+			...VIDEO_SEGMENT_LOADING_CONFIG,
+			...config
+		}
+	})
+});
+const loadAudioSegments = defineBehavior({
+	stateKeys: [
+		"presentation",
+		"preload",
+		"currentTime",
+		"loadActivated",
+		"selectedAudioTrackId"
+	],
+	contextKeys: ["audioSegmentLoaderActor"],
+	setup: ({ state, context, config = {} }) => setupSegmentLoading({
+		state,
+		context,
+		config: {
+			...AUDIO_SEGMENT_LOADING_CONFIG,
+			...config
+		}
+	})
+});
+const loadTextTrackSegments = defineBehavior({
+	stateKeys: [
+		"presentation",
+		"preload",
+		"currentTime",
+		"loadActivated",
+		"selectedTextTrackId"
+	],
+	contextKeys: ["textTrackSegmentLoaderActor"],
+	setup: ({ state, context, config = {} }) => setupSegmentLoading({
+		state,
+		context,
+		config: {
+			...TEXT_SEGMENT_LOADING_CONFIG,
+			...config
+		}
+	})
+});
+//#endregion
+export { loadAudioSegments, loadTextTrackSegments, loadVideoSegments };
+
+//# sourceMappingURL=load-segments.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"load-segments.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/load-segments.ts"],"sourcesContent":["/**\n * **Per-type segment loading dispatch.** Per available track type (video / audio / text), reads the per-type\n * segment-loader actor from context and sends typed `'load'` messages whenever a meaningful loading condition changes\n * (selected track, current time crossing a segment boundary).\n *\n * Loader-actor lifecycle is owned upstream:\n *\n * - Video: `setupVideoBufferActors`\n * - Audio: `setupAudioBufferActors`\n * - Text: `setupTextTrackActors`\n *\n * This behavior is pure-consumer: it reads `context[loaderKey]` and dispatches typed messages via the variant's\n * per-type `findResolvedTrack` resolver.\n *\n * # Load modes as reactor states\n *\n * Four states encode the load-gating policy directly:\n *\n * - `'preconditions-unmet'` — no loader actor in context, or the selected track hasn't resolved.\n * - `'dormant'` — loading disabled by policy: an observed `loadingSuspended` (highest precedence) or `preload === 'none'\n *   && !loadActivated`. Nothing fires; already-queued loader work drains. Auto-resumes into the derived state when the\n *   policy lifts.\n * - `'metadata-only'` — `!loadActivated && preload !== 'auto' && preload !== 'none'`. Fires an init-segment-only `load`\n *   message **once on entry**. The variant's loader actor decides what to do — v/a's actor fetches the init segment;\n *   text's actor no-ops (no init concept).\n * - `'full-range'` — `loadActivated || preload === 'auto'`. Effect re-fires on selected-track change and on\n *   segment-boundary crossing.\n *\n * # Per-type parameterization (inference-driven)\n *\n * The helper is generic over `Track` — the resolved-track type. Each variant supplies its own `findResolvedTrack`\n * resolver via config; TS infers `Track` from the resolver's return type. The loader signal's value type is constrained\n * to `SegmentLoaderLike<Track>` — anything with a `send` method accepting the `Track`-parameterized message. Concrete\n * actor types (`SegmentLoaderActor`, `TextTrackSegmentLoaderActor`) satisfy this via function-parameter contravariance:\n * an actor whose `.send` accepts a wider track type is assignable to a slot expecting a narrower track type.\n *\n * No widening of actor message types is needed; no casts inside the helper. Per-variant wiring (right loader paired\n * with right resolver) is enforced at the variant call site.\n */\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, peek, type ReadonlySignal } from '../../../core/signals/primitives';\nimport {\n  DEFAULT_FORWARD_BUFFER_CONFIG,\n  type ForwardBufferConfig,\n  segmentStartForTime,\n} from '../../../media/buffer/forward-buffer';\nimport type { MaybeResolvedPresentation, Segment } from '../../../media/types';\nimport { findResolvedAudioTrack, findResolvedTextTrack, findResolvedVideoTrack } from '../../../media/utils/tracks';\nimport type { BufferState, SegmentLoaderActor, SourceBufferState } from '../../actors/dom/segment-loader';\nimport type { TextTrackSegmentLoaderActor } from '../../actors/text-track-segment-loader';\nimport { AUDIO_TYPE_CONFIG, TEXT_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from '../../primitives/track-types';\n\n// Re-export buffer state types for consumers that import them from this module.\nexport type { BufferState, SourceBufferState };\n\n// ============================================================================\n// STATE & CONTEXT\n// ============================================================================\n\n/** State shape for segment loading. */\nexport interface SegmentLoadingState {\n  presentation?: MaybeResolvedPresentation;\n  preload?: string;\n  /** Current playback position in seconds. Defaults to 0 when undefined. */\n  currentTime?: number;\n  /** True once a preload-overriding event has fired for the current source. */\n  loadActivated?: boolean;\n  /**\n   * Intent-level policy input: initiate no new loading work while `true`. Read here by the `loadXSegments` dispatchers\n   * (park in `'dormant'`, highest precedence) and by `setupMediaSource` (a pending MediaSource rebuild waits — attach\n   * runs the element's load algorithm). **Observed, never declared**: no reader lists this key in `stateKeys`, so the\n   * slot exists only in compositions where a feature behavior declares and writes it (e.g. `setupAirPlay`, while a\n   * remote-playback session owns presentation). An absent slot means never suspended.\n   */\n  loadingSuspended?: boolean;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n  selectedTextTrackId?: string;\n}\n\n/** Context shape for segment loading. Each variant only consumes its own type's loader actor. */\nexport interface SegmentLoadingContext {\n  videoSegmentLoaderActor?: SegmentLoaderActor;\n  audioSegmentLoaderActor?: SegmentLoaderActor;\n  textTrackSegmentLoaderActor?: TextTrackSegmentLoaderActor;\n}\n\n// ============================================================================\n// REACTOR\n// ============================================================================\n\ntype SegmentLoadingFsmState = 'preconditions-unmet' | 'dormant' | 'metadata-only' | 'full-range';\n\ntype SelectedTrackKey = 'selectedVideoTrackId' | 'selectedAudioTrackId' | 'selectedTextTrackId';\ntype SegmentLoaderActorKey = 'videoSegmentLoaderActor' | 'audioSegmentLoaderActor' | 'textTrackSegmentLoaderActor';\n\ntype SegmentLoadingStateMap<K extends SelectedTrackKey> = {\n  presentation: ReadonlySignal<SegmentLoadingState['presentation']>;\n  preload: ReadonlySignal<SegmentLoadingState['preload']>;\n  currentTime: ReadonlySignal<SegmentLoadingState['currentTime']>;\n  loadActivated: ReadonlySignal<SegmentLoadingState['loadActivated']>;\n} & { [P in K]: ReadonlySignal<SegmentLoadingState[P]> };\n\n/** Shared `'load'` message shape parameterized over the resolved track type. */\ninterface LoadMessage<Track> {\n  type: 'load';\n  track: Track;\n  range?: { start: number; end: number };\n}\n\n/** Structural constraint for any segment-loader-style actor. */\ninterface SegmentLoaderLike<Track> {\n  send: (message: LoadMessage<Track>) => void;\n}\n\n/**\n * Specialization helper. Generic over `Track` (inferred from `findResolvedTrack`'s return type). The loader value type\n * is constrained to `SegmentLoaderLike<Track>` — concrete actor types (whose `.send` accepts a wider track union)\n * satisfy this via function-parameter contravariance.\n *\n * Tracks that the helper handles must have a `segments` field — used by `segmentBoundarySignal` to compute the\n * load-anchor boundary. Each variant's resolver narrows to the right resolved-track shape.\n */\nfunction setupSegmentLoading<\n  K extends SelectedTrackKey,\n  L extends SegmentLoaderActorKey,\n  Track extends { segments: readonly Segment[] },\n>({\n  state,\n  context,\n  config,\n}: {\n  // `loadingSuspended` is observed, never declared (see its state-shape doc):\n  // optional here so variant maps — which omit it from their contracts — are\n  // assignable as-is, while compositions with a writer expose the live slot.\n  state: SegmentLoadingStateMap<K> & { loadingSuspended?: ReadonlySignal<SegmentLoadingState['loadingSuspended']> };\n  context: { [P in L]: ReadonlySignal<SegmentLoaderLike<Track> | undefined> };\n  config: {\n    selectedKey: K;\n    loaderKey: L;\n    findResolvedTrack: (\n      presentation: MaybeResolvedPresentation | undefined,\n      trackId: string | undefined\n    ) => Track | undefined;\n    forwardBuffer?: Partial<ForwardBufferConfig>;\n  };\n}): Reactor<SegmentLoadingFsmState | 'destroying' | 'destroyed'> {\n  const { selectedKey, loaderKey, findResolvedTrack } = config;\n  const bufferDuration = config.forwardBuffer?.bufferDuration ?? DEFAULT_FORWARD_BUFFER_CONFIG.bufferDuration;\n\n  const selectedTrack = computed<Track | undefined>(() =>\n    findResolvedTrack(state.presentation.get(), state[selectedKey].get())\n  );\n\n  // Segment-boundary signal — `segmentStartForTime` returns the same number\n  // while `currentTime` stays inside one segment, so signal-polyfill's\n  // `Object.is` equality on this computed dedups within-segment ticks.\n  const segmentBoundarySignal = computed(() => {\n    const track = selectedTrack.get();\n    if (!track) return undefined;\n\n    return segmentStartForTime(state.currentTime.get() ?? 0, track.segments);\n  });\n\n  const derivedStateSignal = computed<SegmentLoadingFsmState>(() => {\n    // Policy-off wins even over preconditions: a loader arriving while\n    // suspended must not dispatch.\n    if (state.loadingSuspended?.get()) return 'dormant';\n\n    if (!context[loaderKey].get() || !selectedTrack.get()) return 'preconditions-unmet';\n\n    if (state.loadActivated.get() || state.preload.get() === 'auto') return 'full-range';\n\n    if (state.preload.get() === 'none') return 'dormant';\n\n    return 'metadata-only';\n  });\n\n  return createMachineReactor<SegmentLoadingFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n      dormant: {},\n      'metadata-only': {\n        // Fires once on entry. Matches HTMLMediaElement's preload='metadata'\n        // semantics — load enough to surface metadata for the entry-time\n        // selection. Each variant's loader decides what to do: v/a's actor\n        // fetches the init segment; text's actor treats no-range as a\n        // no-op. Selection changes while still in `'metadata-only'` are\n        // intentionally not followed.\n        entry: () => {\n          const track = selectedTrack.get()!;\n\n          context[loaderKey].get()!.send({ type: 'load', track });\n        },\n      },\n      'full-range': {\n        // Re-fires on selected-track changes and on segment-boundary\n        // crossings. The loader and `currentTime` are peeked — the\n        // boundary-dedup signal already handles re-firing policy.\n        effects: () => {\n          const track = selectedTrack.get()!;\n\n          segmentBoundarySignal.get();\n          const currentTime = peek(state.currentTime) ?? 0;\n\n          peek(context[loaderKey])!.send({\n            type: 'load',\n            track,\n            range: { start: currentTime, end: currentTime + bufferDuration },\n          });\n        },\n      },\n    },\n  });\n}\n\n// ============================================================================\n// Per-helper-per-type configs — defaults that variants spread engine config over\n// ============================================================================\n\nconst VIDEO_SEGMENT_LOADING_CONFIG = {\n  ...VIDEO_TYPE_CONFIG,\n  findResolvedTrack: findResolvedVideoTrack,\n} as const;\n\nconst AUDIO_SEGMENT_LOADING_CONFIG = {\n  ...AUDIO_TYPE_CONFIG,\n  findResolvedTrack: findResolvedAudioTrack,\n} as const;\n\nconst TEXT_SEGMENT_LOADING_CONFIG = {\n  ...TEXT_TYPE_CONFIG,\n  findResolvedTrack: findResolvedTextTrack,\n} as const;\n\n// ============================================================================\n// Specialized exports — one per media type\n// ============================================================================\n\nexport const loadVideoSegments = defineBehavior({\n  stateKeys: ['presentation', 'preload', 'currentTime', 'loadActivated', 'selectedVideoTrackId'],\n  contextKeys: ['videoSegmentLoaderActor'],\n  setup: ({\n    state,\n    context,\n    config = {},\n  }: {\n    state: SegmentLoadingStateMap<'selectedVideoTrackId'>;\n    context: {\n      videoSegmentLoaderActor: ReadonlySignal<SegmentLoadingContext['videoSegmentLoaderActor']>;\n    };\n    config?: object;\n  }) =>\n    setupSegmentLoading({\n      state,\n      context,\n      config: { ...VIDEO_SEGMENT_LOADING_CONFIG, ...config },\n    }),\n});\n\nexport const loadAudioSegments = defineBehavior({\n  stateKeys: ['presentation', 'preload', 'currentTime', 'loadActivated', 'selectedAudioTrackId'],\n  contextKeys: ['audioSegmentLoaderActor'],\n  setup: ({\n    state,\n    context,\n    config = {},\n  }: {\n    state: SegmentLoadingStateMap<'selectedAudioTrackId'>;\n    context: {\n      audioSegmentLoaderActor: ReadonlySignal<SegmentLoadingContext['audioSegmentLoaderActor']>;\n    };\n    config?: object;\n  }) =>\n    setupSegmentLoading({\n      state,\n      context,\n      config: { ...AUDIO_SEGMENT_LOADING_CONFIG, ...config },\n    }),\n});\n\nexport const loadTextTrackSegments = defineBehavior({\n  stateKeys: ['presentation', 'preload', 'currentTime', 'loadActivated', 'selectedTextTrackId'],\n  contextKeys: ['textTrackSegmentLoaderActor'],\n  setup: ({\n    state,\n    context,\n    config = {},\n  }: {\n    state: SegmentLoadingStateMap<'selectedTextTrackId'>;\n    context: {\n      textTrackSegmentLoaderActor: ReadonlySignal<SegmentLoadingContext['textTrackSegmentLoaderActor']>;\n    };\n    config?: object;\n  }) =>\n    setupSegmentLoading({\n      state,\n      context,\n      config: { ...TEXT_SEGMENT_LOADING_CONFIG, ...config },\n    }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6HA,SAAS,oBAIP,EACA,OACA,SACA,UAgB+D;CAC/D,MAAM,EAAE,aAAa,WAAW,sBAAsB;CACtD,MAAM,iBAAiB,OAAO,eAAe,kBAAkB,8BAA8B;CAE7F,MAAM,gBAAgB,eACpB,kBAAkB,MAAM,aAAa,IAAI,GAAG,MAAM,YAAY,CAAC,IAAI,CAAC,CACtE;CAKA,MAAM,wBAAwB,eAAe;EAC3C,MAAM,QAAQ,cAAc,IAAI;EAChC,IAAI,CAAC,OAAO,OAAO,KAAA;EAEnB,OAAO,oBAAoB,MAAM,YAAY,IAAI,KAAK,GAAG,MAAM,QAAQ;CACzE,CAAC;CAED,MAAM,qBAAqB,eAAuC;EAGhE,IAAI,MAAM,kBAAkB,IAAI,GAAG,OAAO;EAE1C,IAAI,CAAC,QAAQ,UAAU,CAAC,IAAI,KAAK,CAAC,cAAc,IAAI,GAAG,OAAO;EAE9D,IAAI,MAAM,cAAc,IAAI,KAAK,MAAM,QAAQ,IAAI,MAAM,QAAQ,OAAO;EAExE,IAAI,MAAM,QAAQ,IAAI,MAAM,QAAQ,OAAO;EAE3C,OAAO;CACT,CAAC;CAED,OAAO,qBAA6C;EAClD,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,CAAC;GACxB,SAAS,CAAC;GACV,iBAAiB,EAOf,aAAa;IACX,MAAM,QAAQ,cAAc,IAAI;IAEhC,QAAQ,UAAU,CAAC,IAAI,CAAC,CAAE,KAAK;KAAE,MAAM;KAAQ;IAAM,CAAC;GACxD,EACF;GACA,cAAc,EAIZ,eAAe;IACb,MAAM,QAAQ,cAAc,IAAI;IAEhC,sBAAsB,IAAI;IAC1B,MAAM,cAAc,KAAK,MAAM,WAAW,KAAK;IAE/C,KAAK,QAAQ,UAAU,CAAC,CAAE,KAAK;KAC7B,MAAM;KACN;KACA,OAAO;MAAE,OAAO;MAAa,KAAK,cAAc;KAAe;IACjE,CAAC;GACH,EACF;EACF;CACF,CAAC;AACH;AAMA,MAAM,+BAA+B;CACnC,GAAG;CACH,mBAAmB;AACrB;AAEA,MAAM,+BAA+B;CACnC,GAAG;CACH,mBAAmB;AACrB;AAEA,MAAM,8BAA8B;CAClC,GAAG;CACH,mBAAmB;AACrB;AAMA,MAAa,oBAAoB,eAAe;CAC9C,WAAW;EAAC;EAAgB;EAAW;EAAe;EAAiB;CAAsB;CAC7F,aAAa,CAAC,yBAAyB;CACvC,QAAQ,EACN,OACA,SACA,SAAS,CAAC,QAQV,oBAAoB;EAClB;EACA;EACA,QAAQ;GAAE,GAAG;GAA8B,GAAG;EAAO;CACvD,CAAC;AACL,CAAC;AAED,MAAa,oBAAoB,eAAe;CAC9C,WAAW;EAAC;EAAgB;EAAW;EAAe;EAAiB;CAAsB;CAC7F,aAAa,CAAC,yBAAyB;CACvC,QAAQ,EACN,OACA,SACA,SAAS,CAAC,QAQV,oBAAoB;EAClB;EACA;EACA,QAAQ;GAAE,GAAG;GAA8B,GAAG;EAAO;CACvD,CAAC;AACL,CAAC;AAED,MAAa,wBAAwB,eAAe;CAClD,WAAW;EAAC;EAAgB;EAAW;EAAe;EAAiB;CAAqB;CAC5F,aAAa,CAAC,6BAA6B;CAC3C,QAAQ,EACN,OACA,SACA,SAAS,CAAC,QAQV,oBAAoB;EAClB;EACA;EACA,QAAQ;GAAE,GAAG;GAA6B,GAAG;EAAO;CACtD,CAAC;AACL,CAAC"}

package/dist/dev/playback/behaviors/dom/recover-end-stall.js

@@ -0,0 +1,72 @@
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { effect } from "../../../core/signals/effect.js";
+import { getMinBufferedEnd } from "../../../media/dom/mse/duration.js";
+import { listen } from "@videojs/utils/dom";
+//#region src/playback/behaviors/dom/recover-end-stall.ts
+/**
+* Recover the end-of-stream stall that Chrome exhibits on skewed A/V. After `endOfStream`, when the audio and video
+* tracks end a few ms apart (e.g. a source with an A/V PTS skew), Chrome's audio-clock-paced playback freezes the
+* playhead ~50–70ms short of the reachable buffered end and never fires `ended` — so playback hangs at the very end and
+* loop never re-triggers. This behavior watches for the `waiting` event that fires at that freeze and, when the
+* MediaSource is `ended` and the playhead sits at the reachable buffered end, nudges `currentTime` to `duration` to
+* force the native `ended`.
+*
+* **Event-driven, no poll.** `waiting` fires at the instant the playhead stalls (measured ~0ms latency), so there's
+* nothing to gain from polling — and polling would add its interval + a stall threshold before reacting.
+*
+* **Proximity to the _reachable_ buffered end** is the discriminator. That end is
+* `getMinBufferedEnd(mediaSource.sourceBuffers)` — the `min` of the per-track (video/audio) SourceBuffer ends, i.e. the
+* furthest point playback can reach — read from the SourceBuffers directly rather than the `mediaElement.buffered`
+* aggregate. Once `endOfStream` is signalled that's the true content end. Requiring the playhead within
+* `endStallNudgeWindow` of it distinguishes the real end-of-stream freeze from a mid-stream buffer-hole stall (which
+* sits far from the buffered end), so we never skip content. The window must exceed the freeze gap; too small would
+* miss the stall (a permanent hang), so the default is generous relative to the measured gap and is config-tunable for
+* empirical tuning.
+*
+* Inert where it shouldn't act: live (the MediaSource never reaches `ended` while the window grows; `duration` is
+* `Infinity`) and streams that end cleanly (no `waiting`).
+*
+* See `internal/decisions/spf/end-of-stream-av-skew-recovery.md`.
+*/
+/** ~2.8× the measured max freeze gap (71ms) — tight, but with headroom against a miss. */
+const DEFAULT_END_STALL_NUDGE_WINDOW = .2;
+/**
+* Whether a `waiting` should be forced to `ended`: the MediaSource is `ended`, the stream is finite (not live),
+* playback is active (not paused/seeking/already-ended), and the playhead sits within `nudgeWindow` of the reachable
+* buffered end (so it's the true end, not a mid-stream buffer hole). Pure — the behavior supplies the live values.
+*/
+function shouldForceEnded(input, nudgeWindow) {
+	const { msEnded, durationFinite, paused, seeking, ended, currentTime, bufferedEnd } = input;
+	if (!msEnded || !durationFinite || paused || seeking || ended || bufferedEnd === void 0) return false;
+	const gap = bufferedEnd - currentTime;
+	return gap >= 0 && gap < nudgeWindow;
+}
+function recoverEndStallSetup({ context, config }) {
+	const nudgeWindow = config?.endStallNudgeWindow ?? .2;
+	return effect(() => {
+		const mediaElement = context.mediaElement.get();
+		if (!mediaElement) return;
+		const onWaiting = () => {
+			const mediaSource = context.mediaSource.get();
+			if (shouldForceEnded({
+				msEnded: mediaSource?.readyState === "ended",
+				durationFinite: Number.isFinite(mediaElement.duration),
+				paused: mediaElement.paused,
+				seeking: mediaElement.seeking,
+				ended: mediaElement.ended,
+				currentTime: mediaElement.currentTime,
+				bufferedEnd: mediaSource ? getMinBufferedEnd(mediaSource.sourceBuffers) : void 0
+			}, nudgeWindow)) mediaElement.currentTime = mediaElement.duration;
+		};
+		return listen(mediaElement, "waiting", onWaiting);
+	});
+}
+const recoverEndStall = defineBehavior({
+	stateKeys: [],
+	contextKeys: ["mediaElement", "mediaSource"],
+	setup: recoverEndStallSetup
+});
+//#endregion
+export { DEFAULT_END_STALL_NUDGE_WINDOW, recoverEndStall, shouldForceEnded };
+
+//# sourceMappingURL=recover-end-stall.js.map

package/dist/dev/playback/behaviors/dom/recover-end-stall.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recover-end-stall.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/recover-end-stall.ts"],"sourcesContent":["/**\n * Recover the end-of-stream stall that Chrome exhibits on skewed A/V. After `endOfStream`, when the audio and video\n * tracks end a few ms apart (e.g. a source with an A/V PTS skew), Chrome's audio-clock-paced playback freezes the\n * playhead ~50–70ms short of the reachable buffered end and never fires `ended` — so playback hangs at the very end and\n * loop never re-triggers. This behavior watches for the `waiting` event that fires at that freeze and, when the\n * MediaSource is `ended` and the playhead sits at the reachable buffered end, nudges `currentTime` to `duration` to\n * force the native `ended`.\n *\n * **Event-driven, no poll.** `waiting` fires at the instant the playhead stalls (measured ~0ms latency), so there's\n * nothing to gain from polling — and polling would add its interval + a stall threshold before reacting.\n *\n * **Proximity to the _reachable_ buffered end** is the discriminator. That end is\n * `getMinBufferedEnd(mediaSource.sourceBuffers)` — the `min` of the per-track (video/audio) SourceBuffer ends, i.e. the\n * furthest point playback can reach — read from the SourceBuffers directly rather than the `mediaElement.buffered`\n * aggregate. Once `endOfStream` is signalled that's the true content end. Requiring the playhead within\n * `endStallNudgeWindow` of it distinguishes the real end-of-stream freeze from a mid-stream buffer-hole stall (which\n * sits far from the buffered end), so we never skip content. The window must exceed the freeze gap; too small would\n * miss the stall (a permanent hang), so the default is generous relative to the measured gap and is config-tunable for\n * empirical tuning.\n *\n * Inert where it shouldn't act: live (the MediaSource never reaches `ended` while the window grows; `duration` is\n * `Infinity`) and streams that end cleanly (no `waiting`).\n *\n * See `internal/decisions/spf/end-of-stream-av-skew-recovery.md`.\n */\nimport { listen } from '@videojs/utils/dom';\n\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport type { ReadonlySignal } from '../../../core/signals/primitives';\nimport { getMinBufferedEnd } from '../../../media/dom/mse/duration';\n\nexport interface RecoverEndStallContext {\n  mediaElement?: HTMLMediaElement | undefined;\n  mediaSource?: MediaSource | undefined;\n}\n\nexport interface RecoverEndStallConfig {\n  /**\n   * How close (seconds) the playhead must be to the reachable buffered end for a `waiting` to count as the\n   * end-of-stream freeze. Must exceed the audio-clock freeze gap (~50–70ms measured on Chrome); too small risks missing\n   * the stall (a permanent hang), so keep a margin. Default {@link DEFAULT_END_STALL_NUDGE_WINDOW}.\n   */\n  endStallNudgeWindow?: number;\n}\n\n/** ~2.8× the measured max freeze gap (71ms) — tight, but with headroom against a miss. */\nexport const DEFAULT_END_STALL_NUDGE_WINDOW = 0.2;\n\n/**\n * Whether a `waiting` should be forced to `ended`: the MediaSource is `ended`, the stream is finite (not live),\n * playback is active (not paused/seeking/already-ended), and the playhead sits within `nudgeWindow` of the reachable\n * buffered end (so it's the true end, not a mid-stream buffer hole). Pure — the behavior supplies the live values.\n */\nexport function shouldForceEnded(\n  input: {\n    msEnded: boolean;\n    durationFinite: boolean;\n    paused: boolean;\n    seeking: boolean;\n    ended: boolean;\n    currentTime: number;\n    bufferedEnd: number | undefined;\n  },\n  nudgeWindow: number\n): boolean {\n  const { msEnded, durationFinite, paused, seeking, ended, currentTime, bufferedEnd } = input;\n  if (!msEnded || !durationFinite || paused || seeking || ended || bufferedEnd === undefined) return false;\n\n  const gap = bufferedEnd - currentTime;\n\n  return gap >= 0 && gap < nudgeWindow;\n}\n\nfunction recoverEndStallSetup({\n  context,\n  config,\n}: {\n  context: {\n    mediaElement: ReadonlySignal<RecoverEndStallContext['mediaElement']>;\n    mediaSource: ReadonlySignal<RecoverEndStallContext['mediaSource']>;\n  };\n  config?: RecoverEndStallConfig;\n}): () => void {\n  const nudgeWindow = config?.endStallNudgeWindow ?? DEFAULT_END_STALL_NUDGE_WINDOW;\n\n  return effect(() => {\n    const mediaElement = context.mediaElement.get();\n    if (!mediaElement) return;\n\n    const onWaiting = () => {\n      const mediaSource = context.mediaSource.get();\n      const forceEnded = shouldForceEnded(\n        {\n          msEnded: mediaSource?.readyState === 'ended',\n          durationFinite: Number.isFinite(mediaElement.duration),\n          paused: mediaElement.paused,\n          seeking: mediaElement.seeking,\n          ended: mediaElement.ended,\n          currentTime: mediaElement.currentTime,\n          bufferedEnd: mediaSource ? getMinBufferedEnd(mediaSource.sourceBuffers) : undefined,\n        },\n        nudgeWindow\n      );\n\n      // Nudge to `duration` → native `ended` (the seeking/ended guards above prevent a\n      // re-fire while the nudge-seek is in flight, so no latch is needed).\n      if (forceEnded) mediaElement.currentTime = mediaElement.duration;\n    };\n\n    return listen(mediaElement, 'waiting', onWaiting);\n  });\n}\n\nexport const recoverEndStall = defineBehavior({\n  stateKeys: [] as const,\n  contextKeys: ['mediaElement', 'mediaSource'] as const,\n  setup: recoverEndStallSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,MAAa,iCAAiC;;;;;;AAO9C,SAAgB,iBACd,OASA,aACS;CACT,MAAM,EAAE,SAAS,gBAAgB,QAAQ,SAAS,OAAO,aAAa,gBAAgB;CACtF,IAAI,CAAC,WAAW,CAAC,kBAAkB,UAAU,WAAW,SAAS,gBAAgB,KAAA,GAAW,OAAO;CAEnG,MAAM,MAAM,cAAc;CAE1B,OAAO,OAAO,KAAK,MAAM;AAC3B;AAEA,SAAS,qBAAqB,EAC5B,SACA,UAOa;CACb,MAAM,cAAc,QAAQ,uBAAA;CAE5B,OAAO,aAAa;EAClB,MAAM,eAAe,QAAQ,aAAa,IAAI;EAC9C,IAAI,CAAC,cAAc;EAEnB,MAAM,kBAAkB;GACtB,MAAM,cAAc,QAAQ,YAAY,IAAI;GAgB5C,IAfmB,iBACjB;IACE,SAAS,aAAa,eAAe;IACrC,gBAAgB,OAAO,SAAS,aAAa,QAAQ;IACrD,QAAQ,aAAa;IACrB,SAAS,aAAa;IACtB,OAAO,aAAa;IACpB,aAAa,aAAa;IAC1B,aAAa,cAAc,kBAAkB,YAAY,aAAa,IAAI,KAAA;GAC5E,GACA,WAKW,GAAG,aAAa,cAAc,aAAa;EAC1D;EAEA,OAAO,OAAO,cAAc,WAAW,SAAS;CAClD,CAAC;AACH;AAEA,MAAa,kBAAkB,eAAe;CAC5C,WAAW,CAAC;CACZ,aAAa,CAAC,gBAAgB,aAAa;CAC3C,OAAO;AACT,CAAC"}

package/dist/dev/playback/behaviors/dom/seek-to-live-edge.js

@@ -0,0 +1,113 @@
+import { computed, peek } from "../../../core/signals/primitives.js";
+import { createMachineReactor } from "../../../core/reactors/create-machine-reactor.js";
+import { getLiveEdge } from "../../primitives/live-window.js";
+import { listen } from "@videojs/utils/dom";
+//#region src/playback/behaviors/dom/seek-to-live-edge.ts
+/**
+* Keep the playhead in the live window, via a two-state reactor gated on the preconditions for "we know where live is":
+*
+* - **`inactive`** — no media element, or no live edge (`getLiveEdge` is `null`: VOD, ended, or unresolved). Idle.
+* - **`live`** — preconditions met. `entry` commands `state.startPosition` once to the target live latency behind the
+*   edge (clamped to the window start) so playback begins near the edge and the loader dispatches an in-window range;
+*   `effects` runs the window-exit guard.
+*
+* A derivable live edge is itself the establishment gate: segment placement is settled at parse time — the reference
+* track's local placement _is_ the presentation timeline, and every other track's first parse is held until the anchor
+* is stamped (`resolve-track`'s gate + `establishStartMediaTime`) — so any window derived from resolved segments is
+* already final, with no separate anchor signal to wait on (see
+* `internal/design/spf/live-presentation-timeline-model.md`).
+*
+* The two pieces split along the axis a future DVR / EVENT mode will care about: the **one-time start position**
+* (`entry`) is the _live-specific_ behavior — start near the edge on load; a DVR mode makes it conditional (start in
+* place). The **window-exit guard** (`effects`) is the _general windowed-live_ behavior — applies to sliding-window
+* live, DVR, and EVENT alike. Because the command is an `entry`, it fires once per entry into `live`; a source change
+* exits to `inactive`, so the next source re-commands (no closure latch to reset). The guard stays a direct seek — it
+* is recurring, while `startPosition` is a self-clearing one-shot.
+*
+* Window-exit guard: while playing (not paused), reposition to the live edge when the playhead has fallen behind the
+* window start — including when a seek to a now-evicted position has stranded the playhead (such a seek can never
+* settle, so we rescue rather than wait on it). Two triggers: the **window-update re-fire** (the guard reads the live
+* edge, so each reload / slide re-runs it — this catches a stall, where `timeupdate` stops but the playlist keeps
+* reloading) and a **`play` listener** for immediate reactivity on resume, since the reload interval can be seconds.
+* `play`, not `playing`: after a long pause the playhead sits behind the window at an unseekable position, where the
+* browser stalls and `playing` never fires; `play` fires on the paused→false transition regardless, so we snap before
+* the stall. In-window pause / DVR scrub-back are left untouched.
+*
+* The latency comes from the injected `resolveLiveLatency` seam (HLS: `HOLD-BACK`), so this behavior carries no
+* delivery-format specifics. `applyStartPosition` performs the seek, gated on `loadedmetadata` — which implies an open
+* MediaSource and hence a declared seekable range (a seek outside `seekable` is clamped) — so this behavior needs no
+* MediaSource precondition of its own.
+*/
+/**
+* Tolerance (seconds) around the window edges before the guard repositions, so boundary / floating-point noise doesn't
+* trigger a spurious seek.
+*/
+const REPOSITION_TOLERANCE = .1;
+/**
+* `'live'` once the preconditions hold: a media element and a derivable live edge (whose placement is final by
+* construction — see the module docstring). `'inactive'` otherwise.
+*
+* Deliberately narrow: every signal here can flip the reactor out of and back into `live`, re-firing `entry`. Neither
+* blinks mid-source — the edge can't, because `liveWindowForType` falls back to any resolved track of the type — so
+* `entry` fires once per source without a latch, and a live reload (same source, slid window) correctly doesn't
+* re-command.
+*
+* The flip side: the presentation _url_ is not part of this state, so replacing one already-resolved live presentation
+* with another would stay in `live` and never command a start position for the new source. Unreachable today — every
+* writer sets `{ url }` (unresolved) or `undefined` first, so a source change always transits `inactive`. Supporting a
+* seeded pre-resolved presentation (via `initialState`) that later changes would mean folding the url in here.
+*/
+function deriveState(mediaElement, edge) {
+	return mediaElement && edge ? "live" : "inactive";
+}
+function seekToLiveEdgeSetup({ state, context, config }) {
+	const derivedStateSignal = computed(() => deriveState(context.mediaElement.get(), getLiveEdge({
+		state,
+		config
+	})));
+	return createMachineReactor({
+		initial: "inactive",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			inactive: {},
+			live: {
+				entry: () => {
+					const mediaElement = context.mediaElement.get();
+					const { liveEdgeStart } = getLiveEdge({
+						state,
+						config
+					});
+					if (mediaElement.currentTime >= liveEdgeStart) return;
+					state.startPosition.set(liveEdgeStart);
+				},
+				effects: () => {
+					const { start: windowStart, liveEdgeStart } = getLiveEdge({
+						state,
+						config
+					});
+					const mediaElement = peek(context.mediaElement);
+					const reposition = () => {
+						if (mediaElement.paused) return;
+						if (mediaElement.currentTime < windowStart - REPOSITION_TOLERANCE) mediaElement.currentTime = liveEdgeStart;
+					};
+					reposition();
+					return listen(mediaElement, "play", reposition);
+				}
+			}
+		}
+	});
+}
+/**
+* Manual `Behavior<>` literal (like `calculatePresentationDuration`): declares only `presentation` + `startPosition` in
+* stateKeys while reading `selectedVideoTrackId` / `selectedAudioTrackId` defensively (contributed by the switch*
+* behaviors), so it composes without a stateKeys/type conflict.
+*/
+const seekToLiveEdge = {
+	stateKeys: ["presentation", "startPosition"],
+	contextKeys: ["mediaElement"],
+	setup: seekToLiveEdgeSetup
+};
+//#endregion
+export { seekToLiveEdge };
+
+//# sourceMappingURL=seek-to-live-edge.js.map

package/dist/dev/playback/behaviors/dom/seek-to-live-edge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"seek-to-live-edge.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/seek-to-live-edge.ts"],"sourcesContent":["/**\n * Keep the playhead in the live window, via a two-state reactor gated on the preconditions for \"we know where live is\":\n *\n * - **`inactive`** — no media element, or no live edge (`getLiveEdge` is `null`: VOD, ended, or unresolved). Idle.\n * - **`live`** — preconditions met. `entry` commands `state.startPosition` once to the target live latency behind the\n *   edge (clamped to the window start) so playback begins near the edge and the loader dispatches an in-window range;\n *   `effects` runs the window-exit guard.\n *\n * A derivable live edge is itself the establishment gate: segment placement is settled at parse time — the reference\n * track's local placement _is_ the presentation timeline, and every other track's first parse is held until the anchor\n * is stamped (`resolve-track`'s gate + `establishStartMediaTime`) — so any window derived from resolved segments is\n * already final, with no separate anchor signal to wait on (see\n * `internal/design/spf/live-presentation-timeline-model.md`).\n *\n * The two pieces split along the axis a future DVR / EVENT mode will care about: the **one-time start position**\n * (`entry`) is the _live-specific_ behavior — start near the edge on load; a DVR mode makes it conditional (start in\n * place). The **window-exit guard** (`effects`) is the _general windowed-live_ behavior — applies to sliding-window\n * live, DVR, and EVENT alike. Because the command is an `entry`, it fires once per entry into `live`; a source change\n * exits to `inactive`, so the next source re-commands (no closure latch to reset). The guard stays a direct seek — it\n * is recurring, while `startPosition` is a self-clearing one-shot.\n *\n * Window-exit guard: while playing (not paused), reposition to the live edge when the playhead has fallen behind the\n * window start — including when a seek to a now-evicted position has stranded the playhead (such a seek can never\n * settle, so we rescue rather than wait on it). Two triggers: the **window-update re-fire** (the guard reads the live\n * edge, so each reload / slide re-runs it — this catches a stall, where `timeupdate` stops but the playlist keeps\n * reloading) and a **`play` listener** for immediate reactivity on resume, since the reload interval can be seconds.\n * `play`, not `playing`: after a long pause the playhead sits behind the window at an unseekable position, where the\n * browser stalls and `playing` never fires; `play` fires on the paused→false transition regardless, so we snap before\n * the stall. In-window pause / DVR scrub-back are left untouched.\n *\n * The latency comes from the injected `resolveLiveLatency` seam (HLS: `HOLD-BACK`), so this behavior carries no\n * delivery-format specifics. `applyStartPosition` performs the seek, gated on `loadedmetadata` — which implies an open\n * MediaSource and hence a declared seekable range (a seek outside `seekable` is clamped) — so this behavior needs no\n * MediaSource precondition of its own.\n */\nimport { listen } from '@videojs/utils/dom';\n\nimport type { Behavior } from '../../../core/composition/create-composition';\nimport { createMachineReactor, type Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, peek, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';\nimport type { MaybeResolvedPresentation } from '../../../media/types';\nimport { getLiveEdge, type LiveEdge, type ResolveLiveLatency } from '../../primitives/live-window';\n\n/**\n * Tolerance (seconds) around the window edges before the guard repositions, so boundary / floating-point noise doesn't\n * trigger a spurious seek.\n */\nconst REPOSITION_TOLERANCE = 0.1;\n\nexport interface SeekToLiveEdgeState {\n  presentation?: MaybeResolvedPresentation;\n  /**\n   * One-shot start-position command in presentation-timeline seconds. Written here on entry into `live`; consumed\n   * (cleared) by `applyStartPosition`.\n   */\n  startPosition?: number;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n}\n\nexport interface SeekToLiveEdgeContext {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\nexport interface SeekToLiveEdgeConfig {\n  /**\n   * Resolve the target live latency (seconds the playhead should trail the live edge) for the timeline-bearing track.\n   * Injected by the engine so the latency rule stays format-specific (HLS: `HOLD-BACK`, default 3× target duration;\n   * DASH would read `suggestedPresentationDelay`) while this behavior stays neutral. Absent → `0` (seek straight to the\n   * edge).\n   */\n  resolveLiveLatency?: ResolveLiveLatency;\n}\n\ntype SeekToLiveEdgeFsmState = 'inactive' | 'live';\n\n/**\n * `'live'` once the preconditions hold: a media element and a derivable live edge (whose placement is final by\n * construction — see the module docstring). `'inactive'` otherwise.\n *\n * Deliberately narrow: every signal here can flip the reactor out of and back into `live`, re-firing `entry`. Neither\n * blinks mid-source — the edge can't, because `liveWindowForType` falls back to any resolved track of the type — so\n * `entry` fires once per source without a latch, and a live reload (same source, slid window) correctly doesn't\n * re-command.\n *\n * The flip side: the presentation _url_ is not part of this state, so replacing one already-resolved live presentation\n * with another would stay in `live` and never command a start position for the new source. Unreachable today — every\n * writer sets `{ url }` (unresolved) or `undefined` first, so a source change always transits `inactive`. Supporting a\n * seeded pre-resolved presentation (via `initialState`) that later changes would mean folding the url in here.\n */\nfunction deriveState(mediaElement: HTMLMediaElement | undefined, edge: LiveEdge | null): SeekToLiveEdgeFsmState {\n  return mediaElement && edge ? 'live' : 'inactive';\n}\n\nfunction seekToLiveEdgeSetup({\n  state,\n  context,\n  config,\n}: {\n  state: {\n    presentation: ReadonlySignal<SeekToLiveEdgeState['presentation']>;\n    startPosition: Signal<SeekToLiveEdgeState['startPosition']>;\n    selectedVideoTrackId?: ReadonlySignal<SeekToLiveEdgeState['selectedVideoTrackId']>;\n    selectedAudioTrackId?: ReadonlySignal<SeekToLiveEdgeState['selectedAudioTrackId']>;\n  };\n  context: {\n    mediaElement: ReadonlySignal<SeekToLiveEdgeContext['mediaElement']>;\n  };\n  config?: SeekToLiveEdgeConfig;\n}): Reactor<SeekToLiveEdgeFsmState | 'destroying' | 'destroyed'> {\n  const derivedStateSignal = computed(() => deriveState(context.mediaElement.get(), getLiveEdge({ state, config })));\n\n  return createMachineReactor<SeekToLiveEdgeFsmState>({\n    initial: 'inactive',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      inactive: {},\n\n      live: {\n        // One-time-per-source start position so the loader dispatches an in-window\n        // range and preload shows the right frame. The window-exit guard below is\n        // the separate, continuous rule. Live-specific — a future DVR mode skips\n        // even this first command (starts in place).\n        entry: () => {\n          // The monitor guarantees a media element + live edge while in `live`.\n          const mediaElement = context.mediaElement.get()!;\n          const { liveEdgeStart } = getLiveEdge({ state, config })!;\n          // Never command backwards: seeding `state.currentTime` behind a playhead\n          // already at/past the edge would drag the loaders back.\n          if (mediaElement.currentTime >= liveEdgeStart) return;\n\n          state.startPosition.set(liveEdgeStart);\n        },\n\n        // Window-exit guard. Repositions to the live edge when the playhead has\n        // fallen behind the window start, while playing. Two triggers: this\n        // effect's window-update re-fire (it reads the live edge, so each reload\n        // re-runs it — catches a stall, where `timeupdate` is silent) and a\n        // `play` listener for immediate reactivity on resume.\n        effects: () => {\n          // Read the live edge first — the only tracked dependency — so window\n          // slides keep re-firing this effect even while paused. Bailing before\n          // it (on paused) would drop the dependency and the effect would go\n          // inert, missing the next slide. The monitor guarantees the edge while\n          // in `live`; the media element is read untracked (the window update,\n          // not element identity, is the re-fire trigger).\n          const { start: windowStart, liveEdgeStart } = getLiveEdge({ state, config })!;\n          const mediaElement = peek(context.mediaElement)!;\n          const reposition = () => {\n            // Don't yank a paused viewer. We deliberately DON'T bail on\n            // `mediaElement.seeking`: a seek whose target sits behind the window\n            // start can never complete (the data has slid out of the window and\n            // been evicted), so `seeking` would stay true forever and strand the\n            // playhead — the very stall this guard exists to rescue. The\n            // `currentTime < windowStart` test is itself the precise\n            // discriminator: an in-window DVR scrub-back lands at\n            // `currentTime >= windowStart` and never trips it, so only a stuck\n            // out-of-window seek is repositioned.\n            if (mediaElement.paused) return;\n\n            if (mediaElement.currentTime < windowStart - REPOSITION_TOLERANCE) {\n              mediaElement.currentTime = liveEdgeStart;\n            }\n          };\n\n          reposition();\n          // `play` (not `playing`): a slid-past playhead is at an unseekable\n          // position where `playing` would stall and never fire; `play` fires on\n          // unpause regardless, so we snap before the stall.\n          return listen(mediaElement, 'play', reposition);\n        },\n      },\n    },\n  });\n}\n\n/**\n * Manual `Behavior<>` literal (like `calculatePresentationDuration`): declares only `presentation` + `startPosition` in\n * stateKeys while reading `selectedVideoTrackId` / `selectedAudioTrackId` defensively (contributed by the switch*\n * behaviors), so it composes without a stateKeys/type conflict.\n */\nexport const seekToLiveEdge: Behavior<\n  {\n    presentation: ReadonlySignal<SeekToLiveEdgeState['presentation']>;\n    startPosition: Signal<SeekToLiveEdgeState['startPosition']>;\n  },\n  { mediaElement: ReadonlySignal<SeekToLiveEdgeContext['mediaElement']> },\n  SeekToLiveEdgeConfig\n> = {\n  stateKeys: ['presentation', 'startPosition'],\n  contextKeys: ['mediaElement'],\n  setup: seekToLiveEdgeSetup,\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,MAAM,uBAAuB;;;;;;;;;;;;;;;AA2C7B,SAAS,YAAY,cAA4C,MAA+C;CAC9G,OAAO,gBAAgB,OAAO,SAAS;AACzC;AAEA,SAAS,oBAAoB,EAC3B,OACA,SACA,UAY+D;CAC/D,MAAM,qBAAqB,eAAe,YAAY,QAAQ,aAAa,IAAI,GAAG,YAAY;EAAE;EAAO;CAAO,CAAC,CAAC,CAAC;CAEjH,OAAO,qBAA6C;EAClD,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,UAAU,CAAC;GAEX,MAAM;IAKJ,aAAa;KAEX,MAAM,eAAe,QAAQ,aAAa,IAAI;KAC9C,MAAM,EAAE,kBAAkB,YAAY;MAAE;MAAO;KAAO,CAAC;KAGvD,IAAI,aAAa,eAAe,eAAe;KAE/C,MAAM,cAAc,IAAI,aAAa;IACvC;IAOA,eAAe;KAOb,MAAM,EAAE,OAAO,aAAa,kBAAkB,YAAY;MAAE;MAAO;KAAO,CAAC;KAC3E,MAAM,eAAe,KAAK,QAAQ,YAAY;KAC9C,MAAM,mBAAmB;MAUvB,IAAI,aAAa,QAAQ;MAEzB,IAAI,aAAa,cAAc,cAAc,sBAC3C,aAAa,cAAc;KAE/B;KAEA,WAAW;KAIX,OAAO,OAAO,cAAc,QAAQ,UAAU;IAChD;GACF;EACF;CACF,CAAC;AACH;;;;;;AAOA,MAAa,iBAOT;CACF,WAAW,CAAC,gBAAgB,eAAe;CAC3C,aAAa,CAAC,cAAc;CAC5B,OAAO;AACT"}