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

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 /\n * audio / text), reads the per-type segment-loader actor from context and\n * sends typed `'load'` messages whenever a meaningful loading condition\n * changes (selected track, current time crossing a segment boundary).\n *\n * Loader-actor lifecycle is owned upstream:\n * - Video: `setupVideoBufferActors`\n * - Audio: `setupAudioBufferActors`\n * - Text: `setupTextTrackActors`\n *\n * This behavior is pure-consumer: it reads `context[loaderKey]` and\n * dispatches typed messages via the variant's per-type `findResolvedTrack`\n * 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\n *   track hasn't resolved.\n * - `'dormant'` — `preload === 'none' && !loadActivated`. Nothing fires.\n * - `'metadata-only'` — `!loadActivated && preload !== 'auto' && preload !== 'none'`.\n *   Fires an init-segment-only `load` message **once on entry**. The\n *   variant's loader actor decides what to do — v/a's actor fetches the\n *   init segment; text's actor no-ops (no init concept).\n * - `'full-range'` — `loadActivated || preload === 'auto'`. Effect re-fires\n *   on selected-track change and on segment-boundary crossing.\n *\n * # Per-type parameterization (inference-driven)\n *\n * The helper is generic over `Track` — the resolved-track type. Each\n * variant supplies its own `findResolvedTrack` resolver via config; TS\n * infers `Track` from the resolver's return type. The loader signal's\n * value type is constrained to `SegmentLoaderLike<Track>` — anything with\n * a `send` method accepting the `Track`-parameterized message. Concrete\n * actor types (`SegmentLoaderActor`, `TextTrackSegmentLoaderActor`)\n * satisfy this via function-parameter contravariance: an actor whose\n * `.send` accepts a wider track type is assignable to a slot expecting a\n * narrower track type.\n *\n * No widening of actor message types is needed; no casts inside the\n * helper. Per-variant wiring (right loader paired with right resolver)\n * 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 '../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  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\n * `findResolvedTrack`'s return type). The loader value type is\n * constrained to `SegmentLoaderLike<Track>` — concrete actor types\n * (whose `.send` accepts a wider track union) satisfy this via\n * function-parameter contravariance.\n *\n * Tracks that the helper handles must have a `segments` field — used by\n * `segmentBoundarySignal` to compute the load-anchor boundary. Each\n * 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  state: SegmentLoadingStateMap<K>;\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    return segmentStartForTime(state.currentTime.get() ?? 0, track.segments);\n  });\n\n  const derivedStateSignal = computed<SegmentLoadingFsmState>(() => {\n    if (!context[loaderKey].get() || !selectedTrack.get()) return 'preconditions-unmet';\n    if (state.loadActivated.get() || state.preload.get() === 'auto') return 'full-range';\n    if (state.preload.get() === 'none') return 'dormant';\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          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          segmentBoundarySignal.get();\n          const currentTime = peek(state.currentTime) ?? 0;\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8HA,SAAS,oBAIP,EACA,OACA,SACA,UAa+D;CAC/D,MAAM,EAAE,aAAa,WAAW,sBAAsB;CACtD,MAAM,iBAAiB,OAAO,eAAe,kBAAkB,8BAA8B;CAE7F,MAAM,gBAAgB,eACpB,kBAAkB,MAAM,aAAa,KAAK,EAAE,MAAM,aAAa,KAAK,CAAC,CACtE;CAKD,MAAM,wBAAwB,eAAe;EAC3C,MAAM,QAAQ,cAAc,KAAK;AACjC,MAAI,CAAC,MAAO,QAAO,KAAA;AACnB,SAAO,oBAAoB,MAAM,YAAY,KAAK,IAAI,GAAG,MAAM,SAAS;GACxE;CAEF,MAAM,qBAAqB,eAAuC;AAChE,MAAI,CAAC,QAAQ,WAAW,KAAK,IAAI,CAAC,cAAc,KAAK,CAAE,QAAO;AAC9D,MAAI,MAAM,cAAc,KAAK,IAAI,MAAM,QAAQ,KAAK,KAAK,OAAQ,QAAO;AACxE,MAAI,MAAM,QAAQ,KAAK,KAAK,OAAQ,QAAO;AAC3C,SAAO;GACP;AAEF,QAAO,qBAA6C;EAClD,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,uBAAuB,EAAE;GACzB,SAAS,EAAE;GACX,iBAAiB,EAOf,aAAa;IACX,MAAM,QAAQ,cAAc,KAAK;AACjC,YAAQ,WAAW,KAAK,CAAE,KAAK;KAAE,MAAM;KAAQ;KAAO,CAAC;MAE1D;GACD,cAAc,EAIZ,eAAe;IACb,MAAM,QAAQ,cAAc,KAAK;AACjC,0BAAsB,KAAK;IAC3B,MAAM,cAAc,KAAK,MAAM,YAAY,IAAI;AAC/C,SAAK,QAAQ,WAAW,CAAE,KAAK;KAC7B,MAAM;KACN;KACA,OAAO;MAAE,OAAO;MAAa,KAAK,cAAc;MAAgB;KACjE,CAAC;MAEL;GACF;EACF,CAAC;;AAOJ,MAAM,+BAA+B;CACnC,GAAG;CACH,mBAAmB;CACpB;AAED,MAAM,+BAA+B;CACnC,GAAG;CACH,mBAAmB;CACpB;AAED,MAAM,8BAA8B;CAClC,GAAG;CACH,mBAAmB;CACpB;AAMD,MAAa,oBAAoB,eAAe;CAC9C,WAAW;EAAC;EAAgB;EAAW;EAAe;EAAiB;EAAuB;CAC9F,aAAa,CAAC,0BAA0B;CACxC,QAAQ,EACN,OACA,SACA,SAAS,EAAE,OAQX,oBAAoB;EAClB;EACA;EACA,QAAQ;GAAE,GAAG;GAA8B,GAAG;GAAQ;EACvD,CAAC;CACL,CAAC;AAEF,MAAa,oBAAoB,eAAe;CAC9C,WAAW;EAAC;EAAgB;EAAW;EAAe;EAAiB;EAAuB;CAC9F,aAAa,CAAC,0BAA0B;CACxC,QAAQ,EACN,OACA,SACA,SAAS,EAAE,OAQX,oBAAoB;EAClB;EACA;EACA,QAAQ;GAAE,GAAG;GAA8B,GAAG;GAAQ;EACvD,CAAC;CACL,CAAC;AAEF,MAAa,wBAAwB,eAAe;CAClD,WAAW;EAAC;EAAgB;EAAW;EAAe;EAAiB;EAAsB;CAC7F,aAAa,CAAC,8BAA8B;CAC5C,QAAQ,EACN,OACA,SACA,SAAS,EAAE,OAQX,oBAAoB;EAClB;EACA;EACA,QAAQ;GAAE,GAAG;GAA6B,GAAG;GAAQ;EACtD,CAAC;CACL,CAAC"}

package/dist/dev/playback/behaviors/dom/setup-buffer-actors.js

@@ -0,0 +1,173 @@
+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 { hasCodecs } from "../../../media/utils/tracks.js";
+import { AUDIO_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from "../track-types.js";
+import { getSelectedTrack } from "../../../media/utils/track-selection.js";
+import { buildMimeCodec, createSourceBuffer } from "../../../media/dom/mse/mediasource-setup.js";
+import { createTrackedFetch, fetchStream } from "../../../network/fetch.js";
+import { createSegmentLoaderActor } from "../../actors/dom/segment-loader.js";
+import { createSourceBufferActor } from "../../actors/dom/source-buffer.js";
+//#region src/playback/behaviors/dom/setup-buffer-actors.ts
+/**
+* **Per-type buffer + segment-loader actor setup.** Per available track
+* type (video / audio), when `mediaSource` is attached and the selected
+* track of that type is present in the presentation with codecs (partial
+* resolution from the multivariant playlist is enough — codecs live on
+* the `EXT-X-STREAM-INF` line, not in the per-type media playlist),
+* creates a `SourceBuffer`, a `SourceBufferActor`, and a
+* `SegmentLoaderActor` bound to that buffer-actor; publishes the per-type
+* actor slots. On `mediaSource` detach or behavior destroy, destroys both
+* actors in reverse order and clears the per-type slots so the next
+* source starts fresh.
+*
+* Each per-type variant (`setupVideoBufferActors` /
+* `setupAudioBufferActors`) is a single-positive-state reactor
+* (`'preconditions-unmet'` ↔ `'buffer-ready'`) gating only on its own
+* type. No cross-type coupling in `stateKeys` —
+* `setupVideoBufferActors` carries only `selectedVideoTrackId` (plus
+* `bandwidthState`, written by its trackedFetch), and audio mirrors.
+*
+* # Firefox `mozHasAudio` invariant
+*
+* Appending to a video `SourceBuffer` before the audio `SourceBuffer`
+* exists causes `mozHasAudio` to be permanently false in Firefox. With
+* the two per-type variants decoupled, the invariant is no longer
+* structural to a single `entry` body (as it was when both buffers were
+* created in one synchronous block inside a merged behavior). It's now
+* preserved by a chain of assumptions about how this behavior composes
+* with its upstream and downstream siblings:
+*
+* 1. **Upstream — default selections land in one `runPending`.**
+*    `selectAudioTrack` (default audio) and `switchVideoQuality`
+*    (default video) both subscribe to `state.presentation` flipping to
+*    resolved; their effects run in the same `runPending` iteration and
+*    write `selectedAudioTrackId` + `selectedVideoTrackId` within it.
+* 2. **Self — both per-type monitors flip in one `runPending`.**
+*    After (1), both monitors re-evaluate and flip to `'buffer-ready'`
+*    in the next `runPending`. Both `entry` bodies run synchronously
+*    within that iteration — both `addSourceBuffer` calls land before
+*    the iteration ends.
+* 3. **Downstream — `appendBuffer` is async.** `loadVideoSegments` /
+*    `loadAudioSegments` read the per-type `xSegmentLoaderActor` slots;
+*    their effects fire in the *next* `runPending` and the actual
+*    `appendBuffer` requires a network round-trip via the
+*    `SegmentLoaderActor` — many microtasks past both `addSourceBuffer`
+*    calls.
+*
+* The cross-tick failure mode — a user-initiated audio track switch
+* *after* video segments have begun appending — is out of scope for
+* this behavior and would be addressed in the buffer/segment-loading
+* path via `changeType`-aware logic.
+*
+* # Sole writer
+*
+* `setupVideoBufferActors` is sole writer of `videoBufferActor` +
+* `videoSegmentLoaderActor` (and `bandwidthState` via its
+* trackedFetch); `setupAudioBufferActors` is sole writer of
+* `audioBufferActor` + `audioSegmentLoaderActor`. Both read
+* `mediaSource` from `setupMediaSource`. Downstream MSE behaviors
+* (`loadVideoSegments`, `loadAudioSegments`, `endOfStream`,
+* `updateMediaSourceDuration`) only read these slots.
+*/
+function setupBufferActors({ state, context, config }) {
+	const { type, selectedKey, actorKey, loaderKey, fetch, forwardBuffer, backBuffer } = config;
+	const derivedStateSignal = computed(() => {
+		if (!context.mediaSource.get()) return "preconditions-unmet";
+		return hasCodecs(getSelectedTrack({
+			presentation: state.presentation.get(),
+			[selectedKey]: state[selectedKey].get()
+		}, type)) ? "buffer-ready" : "preconditions-unmet";
+	});
+	return createMachineReactor({
+		initial: "preconditions-unmet",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"preconditions-unmet": {},
+			"buffer-ready": { entry: () => {
+				const bufferActor = createSourceBufferActor(createSourceBuffer(context.mediaSource.get(), buildMimeCodec(getSelectedTrack({
+					presentation: state.presentation.get(),
+					[selectedKey]: state[selectedKey].get()
+				}, type))));
+				const segmentLoader = createSegmentLoaderActor(bufferActor, fetch, {
+					forwardBuffer,
+					backBuffer
+				});
+				context[actorKey].set(bufferActor);
+				context[loaderKey].set(segmentLoader);
+				return () => {
+					segmentLoader.destroy();
+					bufferActor.destroy();
+					context[loaderKey].set(void 0);
+					context[actorKey].set(void 0);
+				};
+			} }
+		}
+	});
+}
+/**
+* Set up the video `SourceBufferActor` + `SegmentLoaderActor`. Fires
+* when `mediaSource` is attached and the selected video track is
+* present in the presentation with codecs. Gates only on video state —
+* no cross-type coupling. Owns a bandwidth-sampling `trackedFetch` and
+* is sole writer of `state.bandwidthState`.
+*/
+const setupVideoBufferActors = defineBehavior({
+	stateKeys: [
+		"presentation",
+		"selectedVideoTrackId",
+		"bandwidthState"
+	],
+	contextKeys: [
+		"mediaSource",
+		"videoBufferActor",
+		"videoSegmentLoaderActor"
+	],
+	setup: ({ state, context, config = {} }) => {
+		const trackedFetch = createTrackedFetch(state.bandwidthState.get() ?? {
+			fastEstimate: 0,
+			fastTotalWeight: 0,
+			slowEstimate: 0,
+			slowTotalWeight: 0,
+			bytesSampled: 0
+		}, (next) => state.bandwidthState.set(next));
+		return setupBufferActors({
+			state,
+			context,
+			config: {
+				...VIDEO_TYPE_CONFIG,
+				fetch: trackedFetch,
+				...config
+			}
+		});
+	}
+});
+/**
+* Set up the audio `SourceBufferActor` + `SegmentLoaderActor`. Same
+* shape as `setupVideoBufferActors`, narrowed to audio. Today supplies
+* a non-sampling `fetchStream` (no audio ABR); adding audio ABR is a
+* localized change to this setup body (swap `fetchStream` for a
+* `createTrackedFetch` call + declare `bandwidthState` writable here)
+* without touching the shared helper.
+*/
+const setupAudioBufferActors = defineBehavior({
+	stateKeys: ["presentation", "selectedAudioTrackId"],
+	contextKeys: [
+		"mediaSource",
+		"audioBufferActor",
+		"audioSegmentLoaderActor"
+	],
+	setup: ({ state, context, config = {} }) => setupBufferActors({
+		state,
+		context,
+		config: {
+			...AUDIO_TYPE_CONFIG,
+			fetch: fetchStream,
+			...config
+		}
+	})
+});
+//#endregion
+export { setupAudioBufferActors, setupVideoBufferActors };
+
+//# sourceMappingURL=setup-buffer-actors.js.map

package/dist/dev/playback/behaviors/dom/setup-buffer-actors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-buffer-actors.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/setup-buffer-actors.ts"],"sourcesContent":["/**\n * **Per-type buffer + segment-loader actor setup.** Per available track\n * type (video / audio), when `mediaSource` is attached and the selected\n * track of that type is present in the presentation with codecs (partial\n * resolution from the multivariant playlist is enough — codecs live on\n * the `EXT-X-STREAM-INF` line, not in the per-type media playlist),\n * creates a `SourceBuffer`, a `SourceBufferActor`, and a\n * `SegmentLoaderActor` bound to that buffer-actor; publishes the per-type\n * actor slots. On `mediaSource` detach or behavior destroy, destroys both\n * actors in reverse order and clears the per-type slots so the next\n * source starts fresh.\n *\n * Each per-type variant (`setupVideoBufferActors` /\n * `setupAudioBufferActors`) is a single-positive-state reactor\n * (`'preconditions-unmet'` ↔ `'buffer-ready'`) gating only on its own\n * type. No cross-type coupling in `stateKeys` —\n * `setupVideoBufferActors` carries only `selectedVideoTrackId` (plus\n * `bandwidthState`, written by its trackedFetch), and audio mirrors.\n *\n * # Firefox `mozHasAudio` invariant\n *\n * Appending to a video `SourceBuffer` before the audio `SourceBuffer`\n * exists causes `mozHasAudio` to be permanently false in Firefox. With\n * the two per-type variants decoupled, the invariant is no longer\n * structural to a single `entry` body (as it was when both buffers were\n * created in one synchronous block inside a merged behavior). It's now\n * preserved by a chain of assumptions about how this behavior composes\n * with its upstream and downstream siblings:\n *\n * 1. **Upstream — default selections land in one `runPending`.**\n *    `selectAudioTrack` (default audio) and `switchVideoQuality`\n *    (default video) both subscribe to `state.presentation` flipping to\n *    resolved; their effects run in the same `runPending` iteration and\n *    write `selectedAudioTrackId` + `selectedVideoTrackId` within it.\n * 2. **Self — both per-type monitors flip in one `runPending`.**\n *    After (1), both monitors re-evaluate and flip to `'buffer-ready'`\n *    in the next `runPending`. Both `entry` bodies run synchronously\n *    within that iteration — both `addSourceBuffer` calls land before\n *    the iteration ends.\n * 3. **Downstream — `appendBuffer` is async.** `loadVideoSegments` /\n *    `loadAudioSegments` read the per-type `xSegmentLoaderActor` slots;\n *    their effects fire in the *next* `runPending` and the actual\n *    `appendBuffer` requires a network round-trip via the\n *    `SegmentLoaderActor` — many microtasks past both `addSourceBuffer`\n *    calls.\n *\n * The cross-tick failure mode — a user-initiated audio track switch\n * *after* video segments have begun appending — is out of scope for\n * this behavior and would be addressed in the buffer/segment-loading\n * path via `changeType`-aware logic.\n *\n * # Sole writer\n *\n * `setupVideoBufferActors` is sole writer of `videoBufferActor` +\n * `videoSegmentLoaderActor` (and `bandwidthState` via its\n * trackedFetch); `setupAudioBufferActors` is sole writer of\n * `audioBufferActor` + `audioSegmentLoaderActor`. Both read\n * `mediaSource` from `setupMediaSource`. Downstream MSE behaviors\n * (`loadVideoSegments`, `loadAudioSegments`, `endOfStream`,\n * `updateMediaSourceDuration`) only read these slots.\n */\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';\nimport { buildMimeCodec, createSourceBuffer } from '../../../media/dom/mse/mediasource-setup';\nimport type { MaybeResolvedPresentation, PartiallyResolvedTrack } from '../../../media/types';\nimport { getSelectedTrack, type TrackSelectionState } from '../../../media/utils/track-selection';\nimport { hasCodecs } from '../../../media/utils/tracks';\nimport type { BandwidthState } from '../../../network/bandwidth-estimator';\nimport { createTrackedFetch, type FetchBytes, fetchStream } from '../../../network/fetch';\nimport {\n  createSegmentLoaderActor,\n  type SegmentLoaderActor,\n  type SegmentLoaderActorConfig,\n} from '../../actors/dom/segment-loader';\nimport { createSourceBufferActor, type SourceBufferActor } from '../../actors/dom/source-buffer';\nimport { AUDIO_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from '../track-types';\n\n/**\n * Media track type for MSE buffer setup.\n * Text tracks are excluded as they don't use MSE SourceBuffers.\n */\nexport type MediaTrackType = 'video' | 'audio';\n\nexport interface BufferActorsState {\n  presentation?: MaybeResolvedPresentation;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n  bandwidthState?: BandwidthState;\n}\n\nexport interface BufferActorsContext {\n  mediaSource?: MediaSource;\n  videoBufferActor?: SourceBufferActor;\n  audioBufferActor?: SourceBufferActor;\n  videoSegmentLoaderActor?: SegmentLoaderActor;\n  audioSegmentLoaderActor?: SegmentLoaderActor;\n}\n\ntype BufferActorsFsmState = 'preconditions-unmet' | 'buffer-ready';\n\ntype SelectedTrackKey = 'selectedVideoTrackId' | 'selectedAudioTrackId';\ntype BufferActorKey = 'videoBufferActor' | 'audioBufferActor';\ntype SegmentLoaderActorKey = 'videoSegmentLoaderActor' | 'audioSegmentLoaderActor';\n\ntype BufferActorsStateMap<K extends SelectedTrackKey> = {\n  presentation: ReadonlySignal<BufferActorsState['presentation']>;\n} & { [P in K]: ReadonlySignal<BufferActorsState[P]> };\n\ntype BufferActorsContextMap<A extends BufferActorKey, L extends SegmentLoaderActorKey> = {\n  mediaSource: ReadonlySignal<BufferActorsContext['mediaSource']>;\n} & { [P in A]: Signal<SourceBufferActor | undefined> } & {\n  [P in L]: Signal<SegmentLoaderActor | undefined>;\n};\n\n// ============================================================================\n// Specialization helper\n//\n// `setupBufferActors` has the same shape as a Behavior `setup` function:\n// `({ state, context, config }) => reactor`. Each `setupXBufferActors`\n// export below calls it from inside its own `defineBehavior` setup,\n// passing its narrowed `state` / `context` through directly and supplying\n// the per-type `selectedKey`, `actorKey`, `loaderKey`, `type` discriminator,\n// and `fetch` inline.\n//\n// Gating is per-type only: no cross-type coupling. See the file-level\n// JSDoc for how the Firefox `mozHasAudio` invariant survives the split\n// via SPF's effect coalescing.\n// ============================================================================\n\nfunction setupBufferActors<K extends SelectedTrackKey, A extends BufferActorKey, L extends SegmentLoaderActorKey>({\n  state,\n  context,\n  config,\n}: {\n  state: BufferActorsStateMap<K>;\n  context: BufferActorsContextMap<A, L>;\n  config: {\n    type: MediaTrackType;\n    selectedKey: K;\n    actorKey: A;\n    loaderKey: L;\n    fetch: FetchBytes;\n  } & SegmentLoaderActorConfig;\n}): Reactor<BufferActorsFsmState | 'destroying' | 'destroyed'> {\n  const { type, selectedKey, actorKey, loaderKey, fetch, forwardBuffer, backBuffer } = config;\n  const derivedStateSignal = computed<BufferActorsFsmState>(() => {\n    if (!context.mediaSource.get()) return 'preconditions-unmet';\n    const selection: TrackSelectionState = {\n      presentation: state.presentation.get(),\n      [selectedKey]: state[selectedKey].get(),\n    };\n    return hasCodecs(getSelectedTrack(selection, type)) ? 'buffer-ready' : 'preconditions-unmet';\n  });\n\n  return createMachineReactor<BufferActorsFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'buffer-ready': {\n        entry: () => {\n          const mediaSource = context.mediaSource.get()!;\n          const selection: TrackSelectionState = {\n            presentation: state.presentation.get(),\n            [selectedKey]: state[selectedKey].get(),\n          };\n          const track = getSelectedTrack(selection, type) as PartiallyResolvedTrack;\n          const buffer = createSourceBuffer(mediaSource, buildMimeCodec(track));\n          const bufferActor = createSourceBufferActor(buffer);\n          const segmentLoader = createSegmentLoaderActor(bufferActor, fetch, { forwardBuffer, backBuffer });\n\n          // Synchronous slot writes — load-bearing for the Firefox\n          // `mozHasAudio` invariant (see file-level JSDoc). Both per-type\n          // entries' `addSourceBuffer` calls must land in the same\n          // `runPending` iteration; synchronous writes keep the contiguous\n          // JS frame. Downstream `loadXSegments` effects fire in the\n          // *next* `runPending`.\n          context[actorKey].set(bufferActor);\n          context[loaderKey].set(segmentLoader);\n\n          // State-exit cleanup — fires when `mediaSource` detaches, the\n          // selection unsets, or the behavior is destroyed. Destroy the\n          // loader before its upstream buffer-actor so any in-flight\n          // `appendBuffer` is aborted before the buffer-actor's own\n          // teardown.\n          return () => {\n            segmentLoader.destroy();\n            bufferActor.destroy();\n            context[loaderKey].set(undefined);\n            context[actorKey].set(undefined);\n          };\n        },\n      },\n    },\n  });\n}\n\n// ============================================================================\n// Specialized exports — one per media type\n// ============================================================================\n\n/**\n * Set up the video `SourceBufferActor` + `SegmentLoaderActor`. Fires\n * when `mediaSource` is attached and the selected video track is\n * present in the presentation with codecs. Gates only on video state —\n * no cross-type coupling. Owns a bandwidth-sampling `trackedFetch` and\n * is sole writer of `state.bandwidthState`.\n */\nexport const setupVideoBufferActors = defineBehavior({\n  stateKeys: ['presentation', 'selectedVideoTrackId', 'bandwidthState'] as const,\n  contextKeys: ['mediaSource', 'videoBufferActor', 'videoSegmentLoaderActor'] as const,\n  setup: ({\n    state,\n    context,\n    config = {},\n  }: {\n    state: BufferActorsStateMap<'selectedVideoTrackId'> & {\n      bandwidthState: Signal<BufferActorsState['bandwidthState']>;\n    };\n    context: BufferActorsContextMap<'videoBufferActor', 'videoSegmentLoaderActor'>;\n    config?: object;\n  }) => {\n    // Bandwidth-sampling fetch. The factory accumulates EWMA state\n    // internally; the callback bridges samples to engine state for ABR.\n    // Created once at behavior setup time so the EWMA accumulates across\n    // source resets (each per-source loader-actor receives the same\n    // tracked fetch when reconstructed in `buffer-ready` entry).\n    const trackedFetch = createTrackedFetch(\n      state.bandwidthState.get() ?? {\n        fastEstimate: 0,\n        fastTotalWeight: 0,\n        slowEstimate: 0,\n        slowTotalWeight: 0,\n        bytesSampled: 0,\n      },\n      (next) => state.bandwidthState.set(next)\n    );\n    return setupBufferActors({\n      state,\n      context,\n      config: { ...VIDEO_TYPE_CONFIG, fetch: trackedFetch, ...config },\n    });\n  },\n});\n\n/**\n * Set up the audio `SourceBufferActor` + `SegmentLoaderActor`. Same\n * shape as `setupVideoBufferActors`, narrowed to audio. Today supplies\n * a non-sampling `fetchStream` (no audio ABR); adding audio ABR is a\n * localized change to this setup body (swap `fetchStream` for a\n * `createTrackedFetch` call + declare `bandwidthState` writable here)\n * without touching the shared helper.\n */\nexport const setupAudioBufferActors = defineBehavior({\n  stateKeys: ['presentation', 'selectedAudioTrackId'] as const,\n  contextKeys: ['mediaSource', 'audioBufferActor', 'audioSegmentLoaderActor'] as const,\n  setup: ({\n    state,\n    context,\n    config = {},\n  }: {\n    state: BufferActorsStateMap<'selectedAudioTrackId'>;\n    context: BufferActorsContextMap<'audioBufferActor', 'audioSegmentLoaderActor'>;\n    config?: object;\n  }) =>\n    setupBufferActors({\n      state,\n      context,\n      config: { ...AUDIO_TYPE_CONFIG, fetch: fetchStream, ...config },\n    }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmIA,SAAS,kBAAyG,EAChH,OACA,SACA,UAW6D;CAC7D,MAAM,EAAE,MAAM,aAAa,UAAU,WAAW,OAAO,eAAe,eAAe;CACrF,MAAM,qBAAqB,eAAqC;AAC9D,MAAI,CAAC,QAAQ,YAAY,KAAK,CAAE,QAAO;AAKvC,SAAO,UAAU,iBAJsB;GACrC,cAAc,MAAM,aAAa,KAAK;IACrC,cAAc,MAAM,aAAa,KAAK;GACxC,EAC4C,KAAK,CAAC,GAAG,iBAAiB;GACvE;AAEF,QAAO,qBAA2C;EAChD,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,uBAAuB,EAAE;GAEzB,gBAAgB,EACd,aAAa;IAQX,MAAM,cAAc,wBADL,mBANK,QAAQ,YAAY,KAAK,EAME,eADjC,iBAJyB;KACrC,cAAc,MAAM,aAAa,KAAK;MACrC,cAAc,MAAM,aAAa,KAAK;KACxC,EACyC,KAAK,CACqB,CAAC,CAClB;IACnD,MAAM,gBAAgB,yBAAyB,aAAa,OAAO;KAAE;KAAe;KAAY,CAAC;AAQjG,YAAQ,UAAU,IAAI,YAAY;AAClC,YAAQ,WAAW,IAAI,cAAc;AAOrC,iBAAa;AACX,mBAAc,SAAS;AACvB,iBAAY,SAAS;AACrB,aAAQ,WAAW,IAAI,KAAA,EAAU;AACjC,aAAQ,UAAU,IAAI,KAAA,EAAU;;MAGrC;GACF;EACF,CAAC;;;;;;;;;AAcJ,MAAa,yBAAyB,eAAe;CACnD,WAAW;EAAC;EAAgB;EAAwB;EAAiB;CACrE,aAAa;EAAC;EAAe;EAAoB;EAA0B;CAC3E,QAAQ,EACN,OACA,SACA,SAAS,EAAE,OAOP;EAMJ,MAAM,eAAe,mBACnB,MAAM,eAAe,KAAK,IAAI;GAC5B,cAAc;GACd,iBAAiB;GACjB,cAAc;GACd,iBAAiB;GACjB,cAAc;GACf,GACA,SAAS,MAAM,eAAe,IAAI,KAAK,CACzC;AACD,SAAO,kBAAkB;GACvB;GACA;GACA,QAAQ;IAAE,GAAG;IAAmB,OAAO;IAAc,GAAG;IAAQ;GACjE,CAAC;;CAEL,CAAC;;;;;;;;;AAUF,MAAa,yBAAyB,eAAe;CACnD,WAAW,CAAC,gBAAgB,uBAAuB;CACnD,aAAa;EAAC;EAAe;EAAoB;EAA0B;CAC3E,QAAQ,EACN,OACA,SACA,SAAS,EAAE,OAMX,kBAAkB;EAChB;EACA;EACA,QAAQ;GAAE,GAAG;GAAmB,OAAO;GAAa,GAAG;GAAQ;EAChE,CAAC;CACL,CAAC"}

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

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

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

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

package/dist/dev/playback/behaviors/dom/setup-text-track-actors.d.ts

@@ -0,0 +1,31 @@
+import { ReadonlySignal, Signal } from "../../../core/signals/primitives.js";
+import { TextTracksActor } from "../../actors/text-tracks.js";
+import { TextTrackSegmentLoaderActor, TextTrackSegmentLoaderActorConfig, TextTrackSegmentResolver } from "../../actors/text-track-segment-loader.js";
+
+//#region src/playback/behaviors/dom/setup-text-track-actors.d.ts
+interface TextTrackActorsContext {
+  mediaElement?: HTMLMediaElement | undefined;
+  textTracksActor?: TextTracksActor<VTTCue> | undefined;
+  textTrackSegmentLoaderActor?: TextTrackSegmentLoaderActor | undefined;
+}
+interface TextTrackActorsConfig extends TextTrackSegmentLoaderActorConfig {
+  resolveTextTrackSegment: TextTrackSegmentResolver<VTTCue>;
+}
+declare const setupTextTrackActors: {
+  stateKeys: readonly [];
+  contextKeys: readonly ["mediaElement", "textTracksActor", "textTrackSegmentLoaderActor"];
+  setup: (deps: {
+    state?: {};
+  } & {
+    context: {
+      mediaElement: ReadonlySignal<TextTrackActorsContext['mediaElement']>;
+      textTracksActor: Signal<TextTrackActorsContext['textTracksActor']>;
+      textTrackSegmentLoaderActor: Signal<TextTrackActorsContext['textTrackSegmentLoaderActor']>;
+    };
+  } & {
+    config: TextTrackActorsConfig;
+  }) => () => void;
+};
+//#endregion
+export { setupTextTrackActors };
+//# sourceMappingURL=setup-text-track-actors.d.ts.map

package/dist/dev/playback/behaviors/dom/setup-text-track-actors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-text-track-actors.d.ts","names":[],"sources":["../../../../../src/playback/behaviors/dom/setup-text-track-actors.ts"],"mappings":";;;;;UAgCiB,sBAAA;EACf,YAAA,GAAe,gBAAA;EACf,eAAA,GAAkB,eAAA,CAAgB,MAAA;EAClC,2BAAA,GAA8B,2BAAA;AAAA;AAAA,UAGf,qBAAA,SAA8B,iCAAA;EAC7C,uBAAA,EAAyB,wBAAA,CAAyB,MAAA;AAAA;AAAA,cAoCvC,oBAAA;;;;;;;oBA5BK,cAAA,CAAe,sBAAA;uBACZ,MAAA,CAAO,sBAAA;mCACK,MAAA,CAAO,sBAAA;IAAA;EAAA"}

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

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

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

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

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

@@ -0,0 +1,99 @@
+import { computed, peek } from "../../../core/signals/primitives.js";
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { createMachineReactor } from "../../../core/reactors/create-machine-reactor.js";
+import { getTracksByType } from "../../../media/utils/tracks.js";
+import { syncTextTrackModes } from "../../../media/dom/text/text-track-slots.js";
+import { listen } from "@videojs/utils/dom";
+//#region src/playback/behaviors/dom/sync-text-tracks.ts
+/**
+* **Own the text-track slots on the host media element, mirroring the SPF
+* model.** When a presentation is resolved and a media element is
+* available, allocate one slot in `mediaElement.textTracks` per model text
+* track — via creating `<track>` children, since that's the only spec
+* mechanism for adding *and* removing entries to `textTracks` (no
+* `removeTextTrack` API exists). Once slots are provisioned, mirror
+* `selectedTextTrackId` into their `mode`s, and propagate user-initiated
+* DOM `change` events back to `selectedTextTrackId` so non-SPF consumers
+* (host-page captions buttons, browser native UI, video.js store) remain
+* the canonical write path for selection.
+*
+* Single-positive-state reactor (`'preconditions-unmet'` ↔ `'sync-active'`):
+* the entry allocates the slots, applies the initial selection, attaches
+* the `change` listener, and opens a brief Chromium settling-window guard —
+* all transition-driven, fire-once on state entry, with paired cleanup on
+* state exit. A single `effects:` mirrors subsequent
+* `selectedTextTrackId` changes into `mode`s; that's the only
+* continuous-reactivity concern.
+*
+* State-exit cleanup also sends a `'clear'` message to the
+* `TextTracksActor` so its cue+segment cache (keyed by trackId) is
+* dropped alongside the DOM `<track>` slots. The actor itself is owned
+* by `setupTextTrackActors` and bound to mediaElement, not presentation,
+* so it survives source resets; clearing its context here keeps the
+* cache consistent with the DOM. Without this, a subsequent
+* presentation reusing a trackId would have `getSegmentsToLoad` treat
+* its segments as already-buffered and skip loading them.
+*
+* Multi-writer with `selectTextTrack` is intentional and orthogonal:
+* `selectTextTrack` owns the *default-on-load / clear-on-unload* contract
+* for `selectedTextTrackId`; this behavior writes only from DOM `change`
+* events. They reflect distinct decision-making domains (config-driven
+* intent vs DOM-driven user action), so this behavior never clears the
+* slot on source unload — that's `selectTextTrack`'s contract. (It *does*
+* write `undefined` when a user disables all tracks via native UI, since
+* that's a real user action that should round-trip into SPF state.)
+*/
+function deriveState(presentation, mediaElement) {
+	if (!mediaElement || !presentation) return "preconditions-unmet";
+	return getTracksByType(presentation, "text").length > 0 ? "sync-active" : "preconditions-unmet";
+}
+function syncTextTracksSetup({ state, context, config }) {
+	const { addSubtitlesTracksToMedia, getShowingSubtitlesTrackFromMedia, removeAllSubtitlesTracksFromMedia } = config;
+	const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaElement.get()));
+	return createMachineReactor({
+		initial: "preconditions-unmet",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"preconditions-unmet": {},
+			"sync-active": {
+				entry: () => {
+					const mediaElement = context.mediaElement.get();
+					addSubtitlesTracksToMedia(mediaElement, getTracksByType(state.presentation.get(), "text"));
+					syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());
+					let inSettlingWindow = true;
+					const settlingTimeout = setTimeout(() => {
+						inSettlingWindow = false;
+					}, 0);
+					const onChange = () => {
+						if (inSettlingWindow) {
+							syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());
+							return;
+						}
+						const nextId = getShowingSubtitlesTrackFromMedia(mediaElement)?.id || void 0;
+						if (nextId === state.selectedTextTrackId.get()) return;
+						state.selectedTextTrackId.set(nextId);
+					};
+					const unlisten = listen(mediaElement.textTracks, "change", onChange);
+					return () => {
+						unlisten();
+						clearTimeout(settlingTimeout);
+						removeAllSubtitlesTracksFromMedia(mediaElement);
+						peek(context.textTracksActor)?.send({ type: "clear" });
+					};
+				},
+				effects: () => {
+					syncTextTrackModes(peek(context.mediaElement).textTracks, state.selectedTextTrackId.get());
+				}
+			}
+		}
+	});
+}
+const syncTextTracks = defineBehavior({
+	stateKeys: ["presentation", "selectedTextTrackId"],
+	contextKeys: ["mediaElement", "textTracksActor"],
+	setup: syncTextTracksSetup
+});
+//#endregion
+export { syncTextTracks };
+
+//# sourceMappingURL=sync-text-tracks.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sync-text-tracks.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/sync-text-tracks.ts"],"sourcesContent":["/**\n * **Own the text-track slots on the host media element, mirroring the SPF\n * model.** When a presentation is resolved and a media element is\n * available, allocate one slot in `mediaElement.textTracks` per model text\n * track — via creating `<track>` children, since that's the only spec\n * mechanism for adding *and* removing entries to `textTracks` (no\n * `removeTextTrack` API exists). Once slots are provisioned, mirror\n * `selectedTextTrackId` into their `mode`s, and propagate user-initiated\n * DOM `change` events back to `selectedTextTrackId` so non-SPF consumers\n * (host-page captions buttons, browser native UI, video.js store) remain\n * the canonical write path for selection.\n *\n * Single-positive-state reactor (`'preconditions-unmet'` ↔ `'sync-active'`):\n * the entry allocates the slots, applies the initial selection, attaches\n * the `change` listener, and opens a brief Chromium settling-window guard —\n * all transition-driven, fire-once on state entry, with paired cleanup on\n * state exit. A single `effects:` mirrors subsequent\n * `selectedTextTrackId` changes into `mode`s; that's the only\n * continuous-reactivity concern.\n *\n * State-exit cleanup also sends a `'clear'` message to the\n * `TextTracksActor` so its cue+segment cache (keyed by trackId) is\n * dropped alongside the DOM `<track>` slots. The actor itself is owned\n * by `setupTextTrackActors` and bound to mediaElement, not presentation,\n * so it survives source resets; clearing its context here keeps the\n * cache consistent with the DOM. Without this, a subsequent\n * presentation reusing a trackId would have `getSegmentsToLoad` treat\n * its segments as already-buffered and skip loading them.\n *\n * Multi-writer with `selectTextTrack` is intentional and orthogonal:\n * `selectTextTrack` owns the *default-on-load / clear-on-unload* contract\n * for `selectedTextTrackId`; this behavior writes only from DOM `change`\n * events. They reflect distinct decision-making domains (config-driven\n * intent vs DOM-driven user action), so this behavior never clears the\n * slot on source unload — that's `selectTextTrack`'s contract. (It *does*\n * write `undefined` when a user disables all tracks via native UI, since\n * that's a real user action that should round-trip into SPF state.)\n */\n\nimport { listen } from '@videojs/utils/dom';\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, peek, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';\nimport { syncTextTrackModes } from '../../../media/dom/text/text-track-slots';\nimport type { MaybeResolvedPresentation, PartiallyResolvedTextTrack, TextTrack } from '../../../media/types';\nimport { getTracksByType } from '../../../media/utils/tracks';\nimport type { TextTracksActor } from '../../actors/text-tracks';\n\ntype SyncTextTracksFsmState = 'preconditions-unmet' | 'sync-active';\n\nexport interface SyncTextTracksConfig {\n  /**\n   * Create and append SPF-owned `<track>` slots on `mediaElement`, one per\n   * model text track. Implementation tags each element so the read/remove\n   * helpers can scope to SPF-owned slots. **Required** — the behavior is\n   * DOM-binding-neutral and the composing engine supplies the integration.\n   */\n  addSubtitlesTracksToMedia: (\n    mediaElement: HTMLMediaElement,\n    modelTextTracks: readonly (PartiallyResolvedTextTrack | TextTrack)[]\n  ) => void;\n  /**\n   * Return the SPF-owned subtitle/caption `TextTrack` currently in `'showing'`\n   * mode, or `undefined` if none. Used by the DOM `change` bridge to mirror\n   * native-UI selection back into `selectedTextTrackId`.\n   */\n  getShowingSubtitlesTrackFromMedia: (mediaElement: HTMLMediaElement) => globalThis.TextTrack | undefined;\n  /**\n   * Remove every SPF-owned `<track>` child from `mediaElement`. Called on\n   * state exit (source unload, behavior destroy) to evict slots.\n   */\n  removeAllSubtitlesTracksFromMedia: (mediaElement: HTMLMediaElement) => void;\n}\n\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaElement: HTMLMediaElement | undefined\n): SyncTextTracksFsmState {\n  if (!mediaElement || !presentation) return 'preconditions-unmet';\n  return getTracksByType(presentation, 'text').length > 0 ? 'sync-active' : 'preconditions-unmet';\n}\n\nfunction syncTextTracksSetup({\n  state,\n  context,\n  config,\n}: {\n  state: {\n    presentation: ReadonlySignal<MaybeResolvedPresentation | undefined>;\n    selectedTextTrackId: Signal<string | undefined>;\n  };\n  context: {\n    mediaElement: ReadonlySignal<HTMLMediaElement | undefined>;\n    textTracksActor: ReadonlySignal<TextTracksActor<VTTCue> | undefined>;\n  };\n  config: SyncTextTracksConfig;\n}): Reactor<SyncTextTracksFsmState | 'destroying' | 'destroyed'> {\n  const { addSubtitlesTracksToMedia, getShowingSubtitlesTrackFromMedia, removeAllSubtitlesTracksFromMedia } = config;\n\n  const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaElement.get()));\n\n  return createMachineReactor<SyncTextTracksFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'sync-active': {\n        // Allocate slots, apply the initial selection, attach the change\n        // listener, and open the settling window — all transition-driven\n        // (fire once per state entry). Entry is auto-untracked, so `.get()`\n        // here doesn't subscribe; the returned cleanup detaches and evicts\n        // on state exit (src reset through 'preconditions-unmet') and on\n        // destroy.\n        entry: () => {\n          const mediaElement = context.mediaElement.get()!;\n          // `getTracksByType('text', ...)` returns text tracks only — the\n          // selection-set filter inside the helper ensures that — but its\n          // declared return is the wide track union. Mirror the cast\n          // pattern used by `quality-switching` for the video branch.\n          const modelTextTracks = getTracksByType(state.presentation.get()!, 'text') as readonly (\n            | PartiallyResolvedTextTrack\n            | TextTrack\n          )[];\n\n          addSubtitlesTracksToMedia(mediaElement, modelTextTracks);\n          // Apply our selection synchronously so the change-event tasks\n          // these mode writes queue land in the macrotask queue *before*\n          // the settling-close `setTimeout(0)` queued below. This keeps\n          // the settling window open long enough to swallow Chromium's\n          // own auto-selection task (also scheduled in the next tick after\n          // `<track>` insertion); if the order flipped, our handler would\n          // treat Chromium's auto-pick as a user action. The `effects:`\n          // block below handles subsequent `selectedTextTrackId` changes.\n          syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());\n\n          // Chromium re-applies its own selection across the next task tick\n          // after `<track>` insertion (default-track auto-pick, language\n          // preference). During this window, the `change` event may fire\n          // with browser-chosen modes that don't reflect a real user action;\n          // re-apply our modes silently rather than writing them back.\n          let inSettlingWindow = true;\n          const settlingTimeout = setTimeout(() => {\n            inSettlingWindow = false;\n          }, 0);\n\n          const onChange = (): void => {\n            if (inSettlingWindow) {\n              syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());\n              return;\n            }\n            const showingTrack = getShowingSubtitlesTrackFromMedia(mediaElement);\n            // `showingTrack.id` matches the SPF id we set when the slot was\n            // allocated. Empty-string ids fall through to `undefined`.\n            const nextId = showingTrack?.id || undefined;\n            if (nextId === state.selectedTextTrackId.get()) return;\n            state.selectedTextTrackId.set(nextId);\n          };\n\n          const unlisten = listen(mediaElement.textTracks, 'change', onChange);\n\n          return () => {\n            unlisten();\n            clearTimeout(settlingTimeout);\n            removeAllSubtitlesTracksFromMedia(mediaElement);\n            // Clear the TextTracksActor's cue+segment cache, which is\n            // keyed by trackId. If we don't, a subsequent presentation\n            // reusing a trackId would have `getSegmentsToLoad` treat its\n            // segments as already-buffered. The DOM cleanup above\n            // already evicted the live cues; this drops the cache that\n            // tracked them. The actor itself is owned by\n            // `setupTextTrackActors` (mediaElement-bound lifecycle), so\n            // we send rather than destroy.\n            peek(context.textTracksActor)?.send({ type: 'clear' });\n          };\n        },\n\n        // Mirror selection changes into mode. The state machine handles\n        // mediaElement/presentation changes via 'preconditions-unmet'\n        // round-trips, so we peek mediaElement here.\n        effects: () => {\n          const mediaElement = peek(context.mediaElement)!;\n          syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());\n        },\n      },\n    },\n  });\n}\n\nexport const syncTextTracks = defineBehavior({\n  stateKeys: ['presentation', 'selectedTextTrackId'],\n  contextKeys: ['mediaElement', 'textTracksActor'],\n  setup: syncTextTracksSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EA,SAAS,YACP,cACA,cACwB;AACxB,KAAI,CAAC,gBAAgB,CAAC,aAAc,QAAO;AAC3C,QAAO,gBAAgB,cAAc,OAAO,CAAC,SAAS,IAAI,gBAAgB;;AAG5E,SAAS,oBAAoB,EAC3B,OACA,SACA,UAW+D;CAC/D,MAAM,EAAE,2BAA2B,mCAAmC,sCAAsC;CAE5G,MAAM,qBAAqB,eAAe,YAAY,MAAM,aAAa,KAAK,EAAE,QAAQ,aAAa,KAAK,CAAC,CAAC;AAE5G,QAAO,qBAA6C;EAClD,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,uBAAuB,EAAE;GAEzB,eAAe;IAOb,aAAa;KACX,MAAM,eAAe,QAAQ,aAAa,KAAK;AAU/C,+BAA0B,cALF,gBAAgB,MAAM,aAAa,KAAK,EAAG,OAAO,CAKlB;AASxD,wBAAmB,aAAa,YAAY,MAAM,oBAAoB,KAAK,CAAC;KAO5E,IAAI,mBAAmB;KACvB,MAAM,kBAAkB,iBAAiB;AACvC,yBAAmB;QAClB,EAAE;KAEL,MAAM,iBAAuB;AAC3B,UAAI,kBAAkB;AACpB,0BAAmB,aAAa,YAAY,MAAM,oBAAoB,KAAK,CAAC;AAC5E;;MAKF,MAAM,SAHe,kCAAkC,aAAa,EAGvC,MAAM,KAAA;AACnC,UAAI,WAAW,MAAM,oBAAoB,KAAK,CAAE;AAChD,YAAM,oBAAoB,IAAI,OAAO;;KAGvC,MAAM,WAAW,OAAO,aAAa,YAAY,UAAU,SAAS;AAEpE,kBAAa;AACX,gBAAU;AACV,mBAAa,gBAAgB;AAC7B,wCAAkC,aAAa;AAS/C,WAAK,QAAQ,gBAAgB,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;;;IAO1D,eAAe;AAEb,wBADqB,KAAK,QAAQ,aAAa,CACf,YAAY,MAAM,oBAAoB,KAAK,CAAC;;IAE/E;GACF;EACF,CAAC;;AAGJ,MAAa,iBAAiB,eAAe;CAC3C,WAAW,CAAC,gBAAgB,sBAAsB;CAClD,aAAa,CAAC,gBAAgB,kBAAkB;CAChD,OAAO;CACR,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"track-current-time.d.ts","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-current-time.ts"],"mappings":";;;UAoBiB,gBAAA;EACf,WAAA;AAAA;AAAA,UAGe,kBAAA;EACf,YAAA,GAAe,gBAAA;AAAA;AAAA,UAGA,sBAAA;EAJA;;;;EASf,kBAAA;AAAA;AAAA,cAgCW,gBAAA;;;;;mBAxBW,MAAA,CAAO,gBAAA;IAAA;EAAA;;oBACJ,cAAA,CAAe,kBAAA;IAAA;EAAA"}