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

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

@@ -1 +1 @@
-{"version":3,"file":"source-buffer.js","names":[],"sources":["../../../../../src/playback/actors/dom/source-buffer.ts"],"sourcesContent":["import { createMachineActor, type HandlerContext, type MessageActor } from '../../../core/actors/create-machine-actor';\nimport { SerialRunner, Task } from '../../../core/tasks/task';\nimport { type AppendData, appendSegment } from '../../../media/dom/mse/append-segment';\nimport { flushBuffer } from '../../../media/dom/mse/buffer-flusher';\nimport { SEGMENT_TIME_EPSILON, type Segment, type Track } from '../../../media/types';\n\n// =============================================================================\n// Types\n// =============================================================================\n\nexport interface BufferedRange {\n  start: number;\n  end: number;\n}\n\nexport type AppendSegmentMeta = Pick<Segment, 'id' | 'startTime' | 'duration'> & {\n  trackId: Track['id'];\n  /** Declared track bandwidth in bps (from playlist BANDWIDTH attribute). */\n  trackBandwidth?: number;\n};\n\nexport type { AppendData };\n\nexport type AppendInitMessage = { type: 'append-init'; data: AppendData; meta: { trackId: Track['id'] } };\nexport type AppendSegmentMessage = { type: 'append-segment'; data: AppendData; meta: AppendSegmentMeta };\nexport type RemoveMessage = { type: 'remove'; start: number; end: number };\nexport type IndividualSourceBufferMessage = AppendInitMessage | AppendSegmentMessage | RemoveMessage;\nexport type BatchMessage = { type: 'batch'; messages: IndividualSourceBufferMessage[] };\nexport type CancelMessage = { type: 'cancel' };\n\n/** All messages accepted by a SourceBufferActor. */\nexport type SourceBufferMessage = IndividualSourceBufferMessage | BatchMessage | CancelMessage;\n\n/** Finite states of the actor. */\nexport type SourceBufferActorState = 'idle' | 'updating' | 'destroyed';\n\n/** Non-finite (extended) data managed by the actor — the XState \"context\". */\nexport interface SourceBufferActorContext {\n  initTrackId?: string | undefined;\n  segments: Array<\n    Pick<Segment, 'id' | 'startTime' | 'duration'> & {\n      trackId: Track['id'];\n      trackBandwidth?: number;\n      /**\n       * True while a streaming append is in progress for this segment.\n       * The segment's data is partially present in the SourceBuffer.\n       * Downstream code must not treat a partial segment as fully buffered.\n       */\n      partial?: boolean;\n    }\n  >;\n  bufferedRanges: BufferedRange[];\n}\n\n/** SourceBuffer actor: queues operations, owns its snapshot. */\nexport type SourceBufferActor = MessageActor<SourceBufferActorState, SourceBufferActorContext, SourceBufferMessage>;\n\n// =============================================================================\n// Helpers\n// =============================================================================\n\nfunction snapshotBuffered(buffered: TimeRanges): BufferedRange[] {\n  const ranges: BufferedRange[] = [];\n  for (let i = 0; i < buffered.length; i++) {\n    ranges.push({ start: buffered.start(i), end: buffered.end(i) });\n  }\n  return ranges;\n}\n\n// =============================================================================\n// Message task factories\n// =============================================================================\n\n// Context is read lazily via getContext at task execution time — not at creation\n// time — so each task always operates on the most recent context regardless of\n// when it was scheduled.\n\ninterface MessageTaskOptions {\n  getContext: () => SourceBufferActorContext;\n  sourceBuffer: SourceBuffer;\n  setContext: (ctx: SourceBufferActorContext) => void;\n}\n\nfunction appendInitTask(\n  message: AppendInitMessage,\n  { getContext, sourceBuffer }: MessageTaskOptions\n): Task<SourceBufferActorContext> {\n  return new Task(async (taskSignal) => {\n    const ctx = getContext();\n    if (taskSignal.aborted) return ctx;\n    await appendSegment(sourceBuffer, message.data);\n    // No abort check here: the physical SourceBuffer has been modified, so\n    // the model must be updated to match regardless of signal state.\n    return { ...ctx, initTrackId: message.meta.trackId };\n  });\n}\n\nfunction appendSegmentTask(\n  message: AppendSegmentMessage,\n  { getContext, sourceBuffer, setContext }: MessageTaskOptions\n): Task<SourceBufferActorContext> {\n  return new Task(async (taskSignal) => {\n    const ctx = getContext();\n    if (taskSignal.aborted) return ctx;\n\n    const { meta } = message;\n    // Remove any existing entry at the same start time (same \"slot\" in the\n    // timeline), then record the new segment. Assumes time-aligned segments\n    // across playlists. `SEGMENT_TIME_EPSILON` guards against floating-point\n    // drift in parsed timestamps (shared with the segment-loader quality\n    // filter — single source of truth).\n    const filtered = ctx.segments.filter((s) => Math.abs(s.startTime - meta.startTime) >= SEGMENT_TIME_EPSILON);\n\n    // For streaming data: emit partial state before the first chunk so\n    // downstream code can see the in-progress segment and treat it as\n    // incomplete. ArrayBuffer appends are atomic so no partial state is\n    // needed — context is updated once at task completion.\n    if (!(message.data instanceof ArrayBuffer)) {\n      setContext({\n        ...ctx,\n        segments: [\n          ...filtered,\n          {\n            id: meta.id,\n            startTime: meta.startTime,\n            duration: meta.duration,\n            trackId: meta.trackId,\n            ...(meta.trackBandwidth !== undefined && { trackBandwidth: meta.trackBandwidth }),\n            partial: true,\n          },\n        ],\n        bufferedRanges: ctx.bufferedRanges,\n      });\n    }\n\n    await appendSegment(sourceBuffer, message.data, taskSignal);\n    // No abort check here: the physical SourceBuffer has been modified, so\n    // the model must be updated to match regardless of signal state.\n    return {\n      ...ctx,\n      segments: [\n        ...filtered,\n        {\n          id: meta.id,\n          startTime: meta.startTime,\n          duration: meta.duration,\n          trackId: meta.trackId,\n          ...(meta.trackBandwidth !== undefined && { trackBandwidth: meta.trackBandwidth }),\n        },\n      ],\n      bufferedRanges: snapshotBuffered(sourceBuffer.buffered),\n    };\n  });\n}\n\nfunction removeTask(\n  message: RemoveMessage,\n  { getContext, sourceBuffer }: MessageTaskOptions\n): Task<SourceBufferActorContext> {\n  return new Task(async (taskSignal) => {\n    const ctx = getContext();\n    if (taskSignal.aborted) return ctx;\n    await flushBuffer(sourceBuffer, message.start, message.end);\n    // No abort check here: the physical SourceBuffer has been modified, so\n    // the model must be updated to match regardless of signal state.\n    //\n    // Use the post-flush buffered ranges as ground truth. A segment is kept\n    // in the model only if its midpoint falls within a buffered range.\n    // Midpoint-based membership handles flush boundaries that don't align\n    // exactly with segment edges without over-removing adjacent segments.\n    const bufferedRanges = snapshotBuffered(sourceBuffer.buffered);\n    const filtered = ctx.segments.filter((s) => {\n      const midpoint = s.startTime + s.duration / 2;\n      return bufferedRanges.some((r) => midpoint >= r.start && midpoint < r.end);\n    });\n    return { ...ctx, segments: filtered, bufferedRanges };\n  });\n}\n\ntype MessageTaskFactory<T extends IndividualSourceBufferMessage> = (\n  message: T,\n  options: MessageTaskOptions\n) => Task<SourceBufferActorContext>;\n\nconst messageTaskFactories = {\n  'append-init': appendInitTask,\n  'append-segment': appendSegmentTask,\n  remove: removeTask,\n} satisfies {\n  [K in IndividualSourceBufferMessage['type']]: MessageTaskFactory<Extract<IndividualSourceBufferMessage, { type: K }>>;\n};\n\nfunction messageToTask(\n  message: IndividualSourceBufferMessage,\n  options: MessageTaskOptions\n): Task<SourceBufferActorContext> {\n  const factory = messageTaskFactories[message.type] as MessageTaskFactory<typeof message>;\n  return factory(message, options);\n}\n\n// =============================================================================\n// Implementation\n// =============================================================================\n\nexport function createSourceBufferActor(\n  sourceBuffer: SourceBuffer,\n  initialContext?: Partial<SourceBufferActorContext>\n): SourceBufferActor {\n  type UserState = Exclude<SourceBufferActorState, 'destroyed'>;\n\n  const handleError = (e: unknown): void => {\n    if (!(e instanceof Error && e.name === 'AbortError')) {\n      console.error('SourceBuffer operation failed:', e);\n    }\n  };\n\n  type Ctx = HandlerContext<UserState, SourceBufferActorContext, () => SerialRunner>;\n\n  const onMessage = (msg: IndividualSourceBufferMessage, { transition, setContext, getContext, runner }: Ctx): void => {\n    transition('updating');\n    const task = messageToTask(msg, { getContext, sourceBuffer, setContext });\n    runner.schedule(task).then(setContext, handleError);\n  };\n\n  return createMachineActor<UserState, SourceBufferActorContext, SourceBufferMessage, () => SerialRunner>({\n    runner: () => new SerialRunner(),\n    initial: 'idle',\n    context: { segments: [], bufferedRanges: [], initTrackId: undefined, ...initialContext },\n    states: {\n      idle: {\n        on: {\n          'append-init': onMessage,\n          'append-segment': onMessage,\n          remove: onMessage,\n          batch: (msg, { transition, setContext, getContext, runner }) => {\n            const { messages } = msg;\n            if (messages.length === 0) return;\n\n            transition('updating');\n            messages.forEach((msg) => {\n              const task = messageToTask(msg, { getContext, sourceBuffer, setContext });\n              runner.schedule(task).then(setContext, handleError);\n            });\n          },\n        },\n      },\n      updating: {\n        // Automatically return to idle once all scheduled tasks settle.\n        onSettled: 'idle',\n        on: {\n          // Abort all in-progress and pending tasks. onSettled handles → 'idle'\n          // once the aborted tasks drain.\n          cancel: (_, { runner }) => {\n            runner.abortAll();\n          },\n        },\n      },\n    },\n  });\n}\n"],"mappings":"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"}
+{"version":3,"file":"source-buffer.js","names":[],"sources":["../../../../../src/playback/actors/dom/source-buffer.ts"],"sourcesContent":["import { createMachineActor, type HandlerContext, type MessageActor } from '../../../core/actors/create-machine-actor';\nimport { SerialRunner, Task } from '../../../core/tasks/task';\nimport { type AppendData, appendSegment } from '../../../media/dom/mse/append-segment';\nimport { flushBuffer } from '../../../media/dom/mse/buffer-flusher';\nimport { SEGMENT_TIME_EPSILON, type Segment, type Track } from '../../../media/types';\n\n// =============================================================================\n// Types\n// =============================================================================\n\nexport interface BufferedRange {\n  start: number;\n  end: number;\n}\n\nexport type AppendSegmentMeta = Pick<Segment, 'id' | 'startTime' | 'duration'> & {\n  trackId: Track['id'];\n  /** Declared track bandwidth in bps (from playlist BANDWIDTH attribute). */\n  trackBandwidth?: number;\n};\n\nexport type { AppendData };\n\nexport type AppendInitMessage = {\n  type: 'append-init';\n  data: AppendData;\n  /**\n   * `language` is captured alongside `trackId` so downstream loaders can\n   * compare the buffered track's language to the newly-selected track's\n   * language and decide whether ahead-buffer flush is warranted on track\n   * switch (see `segment-loader`'s `planTasks`). Undefined for video and\n   * for audio without explicit `LANGUAGE` attribute.\n   */\n  meta: { trackId: Track['id']; language?: string };\n};\nexport type AppendSegmentMessage = { type: 'append-segment'; data: AppendData; meta: AppendSegmentMeta };\nexport type RemoveMessage = { type: 'remove'; start: number; end: number };\nexport type IndividualSourceBufferMessage = AppendInitMessage | AppendSegmentMessage | RemoveMessage;\nexport type BatchMessage = { type: 'batch'; messages: IndividualSourceBufferMessage[] };\nexport type CancelMessage = { type: 'cancel' };\n\n/** All messages accepted by a SourceBufferActor. */\nexport type SourceBufferMessage = IndividualSourceBufferMessage | BatchMessage | CancelMessage;\n\n/** Finite states of the actor. */\nexport type SourceBufferActorState = 'idle' | 'updating' | 'destroyed';\n\n/** Non-finite (extended) data managed by the actor — the XState \"context\". */\nexport interface SourceBufferActorContext {\n  initTrackId?: string | undefined;\n  /**\n   * Language of the most recently appended init segment's track (when\n   * present on the playlist). Used by the segment-loader's `planTasks`\n   * to detect cross-language switches and schedule ahead-buffer flush.\n   * Undefined for video and for language-less audio.\n   */\n  initTrackLanguage?: string | undefined;\n  segments: Array<\n    Pick<Segment, 'id' | 'startTime' | 'duration'> & {\n      trackId: Track['id'];\n      trackBandwidth?: number;\n      /**\n       * True while a streaming append is in progress for this segment.\n       * The segment's data is partially present in the SourceBuffer.\n       * Downstream code must not treat a partial segment as fully buffered.\n       */\n      partial?: boolean;\n    }\n  >;\n  bufferedRanges: BufferedRange[];\n}\n\n/** SourceBuffer actor: queues operations, owns its snapshot. */\nexport type SourceBufferActor = MessageActor<SourceBufferActorState, SourceBufferActorContext, SourceBufferMessage>;\n\n// =============================================================================\n// Helpers\n// =============================================================================\n\nfunction snapshotBuffered(buffered: TimeRanges): BufferedRange[] {\n  const ranges: BufferedRange[] = [];\n  for (let i = 0; i < buffered.length; i++) {\n    ranges.push({ start: buffered.start(i), end: buffered.end(i) });\n  }\n  return ranges;\n}\n\n// =============================================================================\n// Message task factories\n// =============================================================================\n\n// Context is read lazily via getContext at task execution time — not at creation\n// time — so each task always operates on the most recent context regardless of\n// when it was scheduled.\n\ninterface MessageTaskOptions {\n  getContext: () => SourceBufferActorContext;\n  sourceBuffer: SourceBuffer;\n  setContext: (ctx: SourceBufferActorContext) => void;\n}\n\nfunction appendInitTask(\n  message: AppendInitMessage,\n  { getContext, sourceBuffer }: MessageTaskOptions\n): Task<SourceBufferActorContext> {\n  return new Task(async (taskSignal) => {\n    const ctx = getContext();\n    if (taskSignal.aborted) return ctx;\n    await appendSegment(sourceBuffer, message.data);\n    // No abort check here: the physical SourceBuffer has been modified, so\n    // the model must be updated to match regardless of signal state.\n    return { ...ctx, initTrackId: message.meta.trackId, initTrackLanguage: message.meta.language };\n  });\n}\n\nfunction appendSegmentTask(\n  message: AppendSegmentMessage,\n  { getContext, sourceBuffer, setContext }: MessageTaskOptions\n): Task<SourceBufferActorContext> {\n  return new Task(async (taskSignal) => {\n    const ctx = getContext();\n    if (taskSignal.aborted) return ctx;\n\n    const { meta } = message;\n    // Remove any existing entry at the same start time (same \"slot\" in the\n    // timeline), then record the new segment. Assumes time-aligned segments\n    // across playlists. `SEGMENT_TIME_EPSILON` guards against floating-point\n    // drift in parsed timestamps (shared with the segment-loader quality\n    // filter — single source of truth).\n    const filtered = ctx.segments.filter((s) => Math.abs(s.startTime - meta.startTime) >= SEGMENT_TIME_EPSILON);\n\n    // For streaming data: emit partial state before the first chunk so\n    // downstream code can see the in-progress segment and treat it as\n    // incomplete. ArrayBuffer appends are atomic so no partial state is\n    // needed — context is updated once at task completion.\n    if (!(message.data instanceof ArrayBuffer)) {\n      setContext({\n        ...ctx,\n        segments: [\n          ...filtered,\n          {\n            id: meta.id,\n            startTime: meta.startTime,\n            duration: meta.duration,\n            trackId: meta.trackId,\n            ...(meta.trackBandwidth !== undefined && { trackBandwidth: meta.trackBandwidth }),\n            partial: true,\n          },\n        ],\n        bufferedRanges: ctx.bufferedRanges,\n      });\n    }\n\n    await appendSegment(sourceBuffer, message.data, taskSignal);\n    // No abort check here: the physical SourceBuffer has been modified, so\n    // the model must be updated to match regardless of signal state.\n    return {\n      ...ctx,\n      segments: [\n        ...filtered,\n        {\n          id: meta.id,\n          startTime: meta.startTime,\n          duration: meta.duration,\n          trackId: meta.trackId,\n          ...(meta.trackBandwidth !== undefined && { trackBandwidth: meta.trackBandwidth }),\n        },\n      ],\n      bufferedRanges: snapshotBuffered(sourceBuffer.buffered),\n    };\n  });\n}\n\nfunction removeTask(\n  message: RemoveMessage,\n  { getContext, sourceBuffer }: MessageTaskOptions\n): Task<SourceBufferActorContext> {\n  return new Task(async (taskSignal) => {\n    const ctx = getContext();\n    if (taskSignal.aborted) return ctx;\n    await flushBuffer(sourceBuffer, message.start, message.end);\n    // No abort check here: the physical SourceBuffer has been modified, so\n    // the model must be updated to match regardless of signal state.\n    //\n    // Use the post-flush buffered ranges as ground truth. A segment is kept\n    // in the model only if its midpoint falls within a buffered range.\n    // Midpoint-based membership handles flush boundaries that don't align\n    // exactly with segment edges without over-removing adjacent segments.\n    const bufferedRanges = snapshotBuffered(sourceBuffer.buffered);\n    const filtered = ctx.segments.filter((s) => {\n      const midpoint = s.startTime + s.duration / 2;\n      return bufferedRanges.some((r) => midpoint >= r.start && midpoint < r.end);\n    });\n    return { ...ctx, segments: filtered, bufferedRanges };\n  });\n}\n\ntype MessageTaskFactory<T extends IndividualSourceBufferMessage> = (\n  message: T,\n  options: MessageTaskOptions\n) => Task<SourceBufferActorContext>;\n\nconst messageTaskFactories = {\n  'append-init': appendInitTask,\n  'append-segment': appendSegmentTask,\n  remove: removeTask,\n} satisfies {\n  [K in IndividualSourceBufferMessage['type']]: MessageTaskFactory<Extract<IndividualSourceBufferMessage, { type: K }>>;\n};\n\nfunction messageToTask(\n  message: IndividualSourceBufferMessage,\n  options: MessageTaskOptions\n): Task<SourceBufferActorContext> {\n  const factory = messageTaskFactories[message.type] as MessageTaskFactory<typeof message>;\n  return factory(message, options);\n}\n\n// =============================================================================\n// Implementation\n// =============================================================================\n\nexport function createSourceBufferActor(\n  sourceBuffer: SourceBuffer,\n  initialContext?: Partial<SourceBufferActorContext>\n): SourceBufferActor {\n  type UserState = Exclude<SourceBufferActorState, 'destroyed'>;\n\n  const handleError = (e: unknown): void => {\n    if (!(e instanceof Error && e.name === 'AbortError')) {\n      console.error('SourceBuffer operation failed:', e);\n    }\n  };\n\n  type Ctx = HandlerContext<UserState, SourceBufferActorContext, () => SerialRunner>;\n\n  const onMessage = (msg: IndividualSourceBufferMessage, { transition, setContext, getContext, runner }: Ctx): void => {\n    transition('updating');\n    const task = messageToTask(msg, { getContext, sourceBuffer, setContext });\n    runner.schedule(task).then(setContext, handleError);\n  };\n\n  return createMachineActor<UserState, SourceBufferActorContext, SourceBufferMessage, () => SerialRunner>({\n    runner: () => new SerialRunner(),\n    initial: 'idle',\n    context: { segments: [], bufferedRanges: [], initTrackId: undefined, ...initialContext },\n    states: {\n      idle: {\n        on: {\n          'append-init': onMessage,\n          'append-segment': onMessage,\n          remove: onMessage,\n          batch: (msg, { transition, setContext, getContext, runner }) => {\n            const { messages } = msg;\n            if (messages.length === 0) return;\n\n            transition('updating');\n            messages.forEach((msg) => {\n              const task = messageToTask(msg, { getContext, sourceBuffer, setContext });\n              runner.schedule(task).then(setContext, handleError);\n            });\n          },\n        },\n      },\n      updating: {\n        // Automatically return to idle once all scheduled tasks settle.\n        onSettled: 'idle',\n        on: {\n          // Abort all in-progress and pending tasks. onSettled handles → 'idle'\n          // once the aborted tasks drain.\n          cancel: (_, { runner }) => {\n            runner.abortAll();\n          },\n        },\n      },\n    },\n  });\n}\n"],"mappings":"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"}

package/dist/dev/playback/behaviors/calculate-presentation-duration.d.ts

@@ -1,6 +1,14 @@
 import { MaybeResolvedPresentation } from "../../media/types/index.js";
 
 //#region src/playback/behaviors/calculate-presentation-duration.d.ts
+/**
+ * Input shape passed to the duration resolver. Represents the union of
+ * track-selection slots the default `getResolvedSelectedTrackDuration`
+ * resolver inspects to pick a representative resolved track. Variants
+ * that compose neither audio nor video selection still satisfy this
+ * shape — the missing fields read as `undefined` and the resolver
+ * falls through.
+ */
 interface PresentationDurationState {
   presentation?: MaybeResolvedPresentation;
   selectedVideoTrackId?: string;

package/dist/dev/playback/behaviors/calculate-presentation-duration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculate-presentation-duration.d.ts","names":[],"sources":["../../../../src/playback/behaviors/calculate-presentation-duration.ts"],"mappings":";;;UAkCiB,yBAAA;EACf,YAAA,GAAe,yBAAA;EACf,oBAAA;EACA,oBAAA;AAAA;;;;;;KAQU,4BAAA,IAAgC,KAAA,EAAO,yBAAA"}
+{"version":3,"file":"calculate-presentation-duration.d.ts","names":[],"sources":["../../../../src/playback/behaviors/calculate-presentation-duration.ts"],"mappings":";;;;;;;;;;;UA0CiB,yBAAA;EACf,YAAA,GAAe,yBAAA;EACf,oBAAA;EACA,oBAAA;AAAA;;;;;;KAQU,4BAAA,IAAgC,KAAA,EAAO,yBAAA"}

package/dist/dev/playback/behaviors/calculate-presentation-duration.js

@@ -1,57 +1,35 @@
-import { snapshot, untrack, update } from "../../core/signals/primitives.js";
-import { defineBehavior } from "../../core/composition/create-composition.js";
+import { untrack, update } from "../../core/signals/primitives.js";
 import { effect } from "../../core/signals/effect.js";
 //#region src/playback/behaviors/calculate-presentation-duration.ts
-/**
-* **Populate presentation duration via a config-supplied resolver.**
-*
-* Once a presentation is in place and its `duration` is still undefined,
-* calls `config.resolveDuration(state)` whenever a tracked slot changes. The
-* resolver decides what counts as "duration is now derivable" for the variant
-* in play; the behavior itself stays variant-agnostic:
-*
-* - **VoD** — derive from the first resolved selected track's `duration`
-*   (video preferred, audio fallback). The HLS engine wires
-*   `getResolvedSelectedTrackDuration` from `media/utils/track-selection.ts`
-*   as the default. Audio-only falls out of the same resolver naturally
-*   (no video selected → audio is the first resolved track).
-* - **Live** — return `Number.POSITIVE_INFINITY` once the presentation is
-*   established as live. This is the MSE-spec value for `mediaSource.duration`
-*   under live playback; downstream `updateMediaSourceDuration` propagates it through.
-*
-* Validation: writes whatever the resolver returns as long as it's a positive
-* number, including `Infinity`. `undefined` / `NaN` / `<= 0` are skipped.
-*
-* Fires at most once per presentation — an already-set `duration` is never
-* overwritten, and the next reset arrives structurally when a new
-* (unresolved) presentation replaces the current one. The resolver may
-* return `undefined` while duration is still indeterminate; subsequent
-* tracked-slot changes re-run the effect until the resolver commits a value.
-*
-* Downstream of `resolveVideoTrack` / `resolveAudioTrack`; upstream of
-* `updateMediaSourceDuration` (which writes the value through to `mediaSource.duration`).
-*/
 function calculatePresentationDurationSetup({ state, config }) {
 	return effect(() => {
 		const presentation = state.presentation.get();
 		if (!presentation || presentation.duration !== void 0) return;
-		const duration = config.resolveDuration(untrack(() => snapshot(state)));
+		const resolverInput = untrack(() => ({
+			presentation,
+			selectedVideoTrackId: state.selectedVideoTrackId?.get(),
+			selectedAudioTrackId: state.selectedAudioTrackId?.get()
+		}));
+		const duration = config.resolveDuration(resolverInput);
 		if (duration === void 0 || Number.isNaN(duration) || duration <= 0) return;
-		update(state.presentation, (current) => current ? {
-			...current,
-			duration
-		} : current);
+		update(state.presentation, { duration });
 	});
 }
-const calculatePresentationDuration = defineBehavior({
-	stateKeys: [
-		"presentation",
-		"selectedVideoTrackId",
-		"selectedAudioTrackId"
-	],
+/**
+* `calculatePresentationDuration` uses a manual `Behavior<>` literal
+* (rather than `defineBehavior`) so it can declare just `presentation`
+* in its stateKeys while the typed setup-param shape includes the
+* optional `selectedVideoTrackId` / `selectedAudioTrackId` reads used
+* at runtime. Mirrors the pattern in `endOfStream` for the same
+* reason: the behavior is uniform-across-tracks and reads slots
+* contributed by other behaviors, so it shouldn't leak those slot
+* declarations into variants that don't compose the contributors.
+*/
+const calculatePresentationDuration = {
+	stateKeys: ["presentation"],
 	contextKeys: [],
 	setup: calculatePresentationDurationSetup
-});
+};
 //#endregion
 export { calculatePresentationDuration };
 

package/dist/dev/playback/behaviors/calculate-presentation-duration.js.map

@@ -1 +1 @@
-{"version":3,"file":"calculate-presentation-duration.js","names":[],"sources":["../../../../src/playback/behaviors/calculate-presentation-duration.ts"],"sourcesContent":["/**\n * **Populate presentation duration via a config-supplied resolver.**\n *\n * Once a presentation is in place and its `duration` is still undefined,\n * calls `config.resolveDuration(state)` whenever a tracked slot changes. The\n * resolver decides what counts as \"duration is now derivable\" for the variant\n * in play; the behavior itself stays variant-agnostic:\n *\n * - **VoD** — derive from the first resolved selected track's `duration`\n *   (video preferred, audio fallback). The HLS engine wires\n *   `getResolvedSelectedTrackDuration` from `media/utils/track-selection.ts`\n *   as the default. Audio-only falls out of the same resolver naturally\n *   (no video selected → audio is the first resolved track).\n * - **Live** — return `Number.POSITIVE_INFINITY` once the presentation is\n *   established as live. This is the MSE-spec value for `mediaSource.duration`\n *   under live playback; downstream `updateMediaSourceDuration` propagates it through.\n *\n * Validation: writes whatever the resolver returns as long as it's a positive\n * number, including `Infinity`. `undefined` / `NaN` / `<= 0` are skipped.\n *\n * Fires at most once per presentation — an already-set `duration` is never\n * overwritten, and the next reset arrives structurally when a new\n * (unresolved) presentation replaces the current one. The resolver may\n * return `undefined` while duration is still indeterminate; subsequent\n * tracked-slot changes re-run the effect until the resolver commits a value.\n *\n * Downstream of `resolveVideoTrack` / `resolveAudioTrack`; upstream of\n * `updateMediaSourceDuration` (which writes the value through to `mediaSource.duration`).\n */\nimport { defineBehavior } from '../../core/composition/create-composition';\nimport { effect } from '../../core/signals/effect';\nimport { type ReadonlySignal, type Signal, snapshot, untrack, update } from '../../core/signals/primitives';\nimport type { MaybeResolvedPresentation } from '../../media/types';\n\nexport interface PresentationDurationState {\n  presentation?: MaybeResolvedPresentation;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n}\n\n/**\n * Resolver supplied via `config.resolveDuration`. Returns the duration to\n * write to `presentation.duration`, or `undefined` when it isn't yet\n * derivable. Positive `Infinity` is the canonical live value.\n */\nexport type PresentationDurationResolver = (state: PresentationDurationState) => number | undefined;\n\nexport interface PresentationDurationConfig {\n  resolveDuration: PresentationDurationResolver;\n}\n\nfunction calculatePresentationDurationSetup({\n  state,\n  config,\n}: {\n  state: {\n    presentation: Signal<PresentationDurationState['presentation']>;\n    selectedVideoTrackId: ReadonlySignal<PresentationDurationState['selectedVideoTrackId']>;\n    selectedAudioTrackId: ReadonlySignal<PresentationDurationState['selectedAudioTrackId']>;\n  };\n  config: PresentationDurationConfig;\n}): () => void {\n  return effect(() => {\n    const presentation = state.presentation.get();\n    if (!presentation || presentation.duration !== undefined) return;\n\n    // presentation drives the effect; selection-only changes can't yield a\n    // writable duration on their own (resolver returns undefined until a\n    // track resolves, at which point resolve-track writes back through\n    // state.presentation anyway), so we read the rest untracked.\n    const duration = config.resolveDuration(untrack(() => snapshot(state)));\n    if (duration === undefined || Number.isNaN(duration) || duration <= 0) return;\n\n    update(state.presentation, (current) => (current ? { ...current, duration } : current));\n  });\n}\n\nexport const calculatePresentationDuration = defineBehavior({\n  stateKeys: ['presentation', 'selectedVideoTrackId', 'selectedAudioTrackId'],\n  contextKeys: [],\n  setup: calculatePresentationDurationSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,SAAS,mCAAmC,EAC1C,OACA,UAQa;AACb,QAAO,aAAa;EAClB,MAAM,eAAe,MAAM,aAAa,KAAK;AAC7C,MAAI,CAAC,gBAAgB,aAAa,aAAa,KAAA,EAAW;EAM1D,MAAM,WAAW,OAAO,gBAAgB,cAAc,SAAS,MAAM,CAAC,CAAC;AACvE,MAAI,aAAa,KAAA,KAAa,OAAO,MAAM,SAAS,IAAI,YAAY,EAAG;AAEvE,SAAO,MAAM,eAAe,YAAa,UAAU;GAAE,GAAG;GAAS;GAAU,GAAG,QAAS;GACvF;;AAGJ,MAAa,gCAAgC,eAAe;CAC1D,WAAW;EAAC;EAAgB;EAAwB;EAAuB;CAC3E,aAAa,EAAE;CACf,OAAO;CACR,CAAC"}
+{"version":3,"file":"calculate-presentation-duration.js","names":[],"sources":["../../../../src/playback/behaviors/calculate-presentation-duration.ts"],"sourcesContent":["/**\n * **Populate presentation duration via a config-supplied resolver.**\n *\n * Once a presentation is in place and its `duration` is still undefined,\n * calls `config.resolveDuration(state)` whenever a tracked slot changes. The\n * resolver decides what counts as \"duration is now derivable\" for the variant\n * in play; the behavior itself stays variant-agnostic:\n *\n * - **VoD** — derive from the first resolved selected track's `duration`\n *   (video preferred, audio fallback). The HLS engine wires\n *   `getResolvedSelectedTrackDuration` from `media/utils/track-selection.ts`\n *   as the default. Audio-only falls out of the same resolver naturally\n *   (no video selected → audio is the first resolved track).\n * - **Live** — return `Number.POSITIVE_INFINITY` once the presentation is\n *   established as live. This is the MSE-spec value for `mediaSource.duration`\n *   under live playback; downstream `updateMediaSourceDuration` propagates it through.\n *\n * Validation: writes whatever the resolver returns as long as it's a positive\n * number, including `Infinity`. `undefined` / `NaN` / `<= 0` are skipped.\n *\n * Fires at most once per presentation — an already-set `duration` is never\n * overwritten, and the next reset arrives structurally when a new\n * (unresolved) presentation replaces the current one. The resolver may\n * return `undefined` while duration is still indeterminate; subsequent\n * tracked-slot changes re-run the effect until the resolver commits a value.\n *\n * Downstream of `resolveVideoTrack` / `resolveAudioTrack`; upstream of\n * `updateMediaSourceDuration` (which writes the value through to `mediaSource.duration`).\n */\nimport type { Behavior } from '../../core/composition/create-composition';\nimport { effect } from '../../core/signals/effect';\nimport { type ReadonlySignal, type Signal, untrack, update } from '../../core/signals/primitives';\nimport type { MaybeResolvedPresentation } from '../../media/types';\n\n/**\n * Input shape passed to the duration resolver. Represents the union of\n * track-selection slots the default `getResolvedSelectedTrackDuration`\n * resolver inspects to pick a representative resolved track. Variants\n * that compose neither audio nor video selection still satisfy this\n * shape — the missing fields read as `undefined` and the resolver\n * falls through.\n */\nexport interface PresentationDurationState {\n  presentation?: MaybeResolvedPresentation;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n}\n\n/**\n * Resolver supplied via `config.resolveDuration`. Returns the duration to\n * write to `presentation.duration`, or `undefined` when it isn't yet\n * derivable. Positive `Infinity` is the canonical live value.\n */\nexport type PresentationDurationResolver = (state: PresentationDurationState) => number | undefined;\n\nexport interface PresentationDurationConfig {\n  resolveDuration: PresentationDurationResolver;\n}\n\nfunction calculatePresentationDurationSetup({\n  state,\n  config,\n}: {\n  state: {\n    presentation: Signal<PresentationDurationState['presentation']>;\n    // selectedVideoTrackId / selectedAudioTrackId are read defensively —\n    // they are *not* declared in this behavior's stateKeys. The slots are\n    // contributed by other behaviors (`switchVideoTrack` writes the\n    // video slot in the default engine; `selectAudioTrack` writes the\n    // audio slot) which compose conditionally per engine variant. Treating\n    // each signal as optional lets calculatePresentationDuration stay\n    // variant-agnostic — it feeds whatever's present to the resolver and\n    // lets the resolver decide.\n    selectedVideoTrackId?: ReadonlySignal<PresentationDurationState['selectedVideoTrackId']>;\n    selectedAudioTrackId?: ReadonlySignal<PresentationDurationState['selectedAudioTrackId']>;\n  };\n  config: PresentationDurationConfig;\n}): () => void {\n  return effect(() => {\n    const presentation = state.presentation.get();\n    if (!presentation || presentation.duration !== undefined) return;\n\n    // presentation drives the effect; selection-only changes can't yield a\n    // writable duration on their own (resolver returns undefined until a\n    // track resolves, at which point resolve-track writes back through\n    // state.presentation anyway), so we read the rest untracked.\n    const resolverInput: PresentationDurationState = untrack(() => ({\n      presentation,\n      selectedVideoTrackId: state.selectedVideoTrackId?.get(),\n      selectedAudioTrackId: state.selectedAudioTrackId?.get(),\n    }));\n    const duration = config.resolveDuration(resolverInput);\n    if (duration === undefined || Number.isNaN(duration) || duration <= 0) return;\n\n    // Patch-object form requires `T extends object`; `state.presentation`'s\n    // T is `MaybeResolvedPresentation | undefined`, which doesn't satisfy\n    // the constraint. The guard at the top of the effect already\n    // established that the slot holds a defined value, so cast to narrow\n    // the signal type and use the cleaner merge form.\n    update(state.presentation as Signal<MaybeResolvedPresentation>, { duration });\n  });\n}\n\n/**\n * `calculatePresentationDuration` uses a manual `Behavior<>` literal\n * (rather than `defineBehavior`) so it can declare just `presentation`\n * in its stateKeys while the typed setup-param shape includes the\n * optional `selectedVideoTrackId` / `selectedAudioTrackId` reads used\n * at runtime. Mirrors the pattern in `endOfStream` for the same\n * reason: the behavior is uniform-across-tracks and reads slots\n * contributed by other behaviors, so it shouldn't leak those slot\n * declarations into variants that don't compose the contributors.\n */\nexport const calculatePresentationDuration: Behavior<\n  { presentation: Signal<PresentationDurationState['presentation']> },\n  Record<string, never>,\n  PresentationDurationConfig\n> = {\n  stateKeys: ['presentation'],\n  contextKeys: [],\n  setup: calculatePresentationDurationSetup,\n};\n"],"mappings":";;;AA2DA,SAAS,mCAAmC,EAC1C,OACA,UAgBa;AACb,QAAO,aAAa;EAClB,MAAM,eAAe,MAAM,aAAa,KAAK;AAC7C,MAAI,CAAC,gBAAgB,aAAa,aAAa,KAAA,EAAW;EAM1D,MAAM,gBAA2C,eAAe;GAC9D;GACA,sBAAsB,MAAM,sBAAsB,KAAK;GACvD,sBAAsB,MAAM,sBAAsB,KAAK;GACxD,EAAE;EACH,MAAM,WAAW,OAAO,gBAAgB,cAAc;AACtD,MAAI,aAAa,KAAA,KAAa,OAAO,MAAM,SAAS,IAAI,YAAY,EAAG;AAOvE,SAAO,MAAM,cAAmD,EAAE,UAAU,CAAC;GAC7E;;;;;;;;;;;;AAaJ,MAAa,gCAIT;CACF,WAAW,CAAC,eAAe;CAC3B,aAAa,EAAE;CACf,OAAO;CACR"}

package/dist/dev/playback/behaviors/derive-cdn-priority.js

@@ -0,0 +1,68 @@
+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 { isResolvedPresentation } from "../../media/types/index.js";
+import { getCdnId, getOrderedCdnIds } from "../../media/utils/cdn.js";
+//#region src/playback/behaviors/derive-cdn-priority.ts
+/**
+* **Session-level CDN priority.** While a presentation is resolved, owns the
+* `cdnPriority` signal: the distinct CDNs the source is served from (origin of
+* each track's URL), in manifest priority order — most-preferred first. Cleared
+* on src unload. The name mirrors HLS content steering's `PATHWAY-PRIORITY`.
+*
+* Redundant-stream sources (e.g. Mux's `?redundant_streams=true`) list the same
+* content on multiple hosts, so the candidate tracks already include one variant
+* per CDN. This behavior publishes *which* CDNs exist and their priority; the
+* `preferActiveCdn` scope rule in `track-switching` reads `cdnPriority` and
+* narrows each type's candidates to the first CDN with surviving tracks — so
+* video / audio / text all resolve from one host (the shared list is the
+* per-presentation coherence guarantee).
+*
+* The "active" CDN is not stored — it's derived by the scope as the
+* highest-priority entry in `cdnPriority` that still has tracks after the
+* constraints pre-pass. That makes failover a pure consequence of the (future)
+* failed-CDN constraint: when the primary's tracks are pruned during cooldown,
+* the scope falls to the next CDN; when the primary recovers, it snaps back.
+* Content steering, when it lands, reorders `cdnPriority` (pathway priority as a
+* sort key).
+*
+* Lifecycle: `'presentation-unresolved'` ↔ `'presentation-resolved'`, mirroring
+* `setupTrackSwitching`. The resolved state owns the signal; its entry-returned
+* cleanup clears it on exit (canonical cleanup-binds-to-setup per `reactors.md`).
+*/
+const samePriority = (a, b) => !!a && a.length === b.length && a.every((cdn, i) => cdn === b[i]);
+/**
+* Manage `cdnPriority`: publish the manifest-ordered CDN list on src load, clear
+* on src unload.
+*
+* @example
+* const reactor = deriveCdnPriority.setup({ state });
+*/
+const deriveCdnPriority = defineBehavior({
+	stateKeys: ["presentation", "cdnPriority"],
+	contextKeys: [],
+	setup: ({ state, config = {} }) => {
+		const getCdnId$1 = config.getCdnId ?? getCdnId;
+		const derivedStateSignal = computed(() => isResolvedPresentation(state.presentation.get()) ? "presentation-resolved" : "presentation-unresolved");
+		return createMachineReactor({
+			initial: "presentation-unresolved",
+			monitor: () => derivedStateSignal.get(),
+			states: {
+				"presentation-unresolved": {},
+				"presentation-resolved": {
+					entry: () => () => state.cdnPriority.set(void 0),
+					effects: [() => {
+						const presentation = state.presentation.get();
+						if (!isResolvedPresentation(presentation)) return;
+						const next = getOrderedCdnIds(presentation, getCdnId$1);
+						if (!samePriority(peek(state.cdnPriority), next)) state.cdnPriority.set(next);
+					}]
+				}
+			}
+		});
+	}
+});
+//#endregion
+export { deriveCdnPriority };
+
+//# sourceMappingURL=derive-cdn-priority.js.map

package/dist/dev/playback/behaviors/derive-cdn-priority.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive-cdn-priority.js","names":["getCdnId","defaultGetCdnId"],"sources":["../../../../src/playback/behaviors/derive-cdn-priority.ts"],"sourcesContent":["/**\n * **Session-level CDN priority.** While a presentation is resolved, owns the\n * `cdnPriority` signal: the distinct CDNs the source is served from (origin of\n * each track's URL), in manifest priority order — most-preferred first. Cleared\n * on src unload. The name mirrors HLS content steering's `PATHWAY-PRIORITY`.\n *\n * Redundant-stream sources (e.g. Mux's `?redundant_streams=true`) list the same\n * content on multiple hosts, so the candidate tracks already include one variant\n * per CDN. This behavior publishes *which* CDNs exist and their priority; the\n * `preferActiveCdn` scope rule in `track-switching` reads `cdnPriority` and\n * narrows each type's candidates to the first CDN with surviving tracks — so\n * video / audio / text all resolve from one host (the shared list is the\n * per-presentation coherence guarantee).\n *\n * The \"active\" CDN is not stored — it's derived by the scope as the\n * highest-priority entry in `cdnPriority` that still has tracks after the\n * constraints pre-pass. That makes failover a pure consequence of the (future)\n * failed-CDN constraint: when the primary's tracks are pruned during cooldown,\n * the scope falls to the next CDN; when the primary recovers, it snaps back.\n * Content steering, when it lands, reorders `cdnPriority` (pathway priority as a\n * sort key).\n *\n * Lifecycle: `'presentation-unresolved'` ↔ `'presentation-resolved'`, mirroring\n * `setupTrackSwitching`. The resolved state owns the signal; its entry-returned\n * cleanup clears it on exit (canonical cleanup-binds-to-setup per `reactors.md`).\n */\n\nimport { defineBehavior } from '../../core/composition/create-composition';\nimport { createMachineReactor } from '../../core/reactors/create-machine-reactor';\nimport { computed, peek, type ReadonlySignal, type Signal } from '../../core/signals/primitives';\nimport { isResolvedPresentation, type MaybeResolvedPresentation } from '../../media/types';\nimport { getCdnId as defaultGetCdnId, type GetCdnId, getOrderedCdnIds } from '../../media/utils/cdn';\n\nexport interface DeriveCdnPriorityState {\n  presentation?: MaybeResolvedPresentation;\n  cdnPriority?: string[];\n}\n\nconst samePriority = (a: string[] | undefined, b: string[]): boolean =>\n  !!a && a.length === b.length && a.every((cdn, i) => cdn === b[i]);\n\n/**\n * Manage `cdnPriority`: publish the manifest-ordered CDN list on src load, clear\n * on src unload.\n *\n * @example\n * const reactor = deriveCdnPriority.setup({ state });\n */\nexport const deriveCdnPriority = defineBehavior({\n  stateKeys: ['presentation', 'cdnPriority'],\n  contextKeys: [],\n  setup: ({\n    state,\n    config = {},\n  }: {\n    state: {\n      presentation: ReadonlySignal<DeriveCdnPriorityState['presentation']>;\n      cdnPriority: Signal<DeriveCdnPriorityState['cdnPriority']>;\n    };\n    config?: { getCdnId?: GetCdnId };\n  }) => {\n    const getCdnId = config.getCdnId ?? defaultGetCdnId;\n    const derivedStateSignal = computed(() =>\n      isResolvedPresentation(state.presentation.get())\n        ? ('presentation-resolved' as const)\n        : ('presentation-unresolved' as const)\n    );\n\n    return createMachineReactor({\n      initial: 'presentation-unresolved',\n      monitor: () => derivedStateSignal.get(),\n      states: {\n        'presentation-unresolved': {},\n        'presentation-resolved': {\n          // Cleanup-binds-to-setup: the CDN priority list is valid for exactly\n          // 'presentation-resolved'. Clear fires on exit (src unload + destroy).\n          entry: () => () => state.cdnPriority.set(undefined),\n          effects: [\n            () => {\n              const presentation = state.presentation.get();\n              if (!isResolvedPresentation(presentation)) return;\n              const next = getOrderedCdnIds(presentation, getCdnId);\n              // Skip the write when the CDN set is unchanged — a live reload swaps\n              // in a new presentation object with the same hosts, and re-setting a\n              // fresh array would re-fire the scope for an identical result.\n              // `peek` reads without subscribing, so this never self-triggers.\n              if (!samePriority(peek(state.cdnPriority), next)) state.cdnPriority.set(next);\n            },\n          ],\n        },\n      },\n    });\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,MAAM,gBAAgB,GAAyB,MAC7C,CAAC,CAAC,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,KAAK,MAAM,QAAQ,EAAE,GAAG;;;;;;;;AASnE,MAAa,oBAAoB,eAAe;CAC9C,WAAW,CAAC,gBAAgB,cAAc;CAC1C,aAAa,EAAE;CACf,QAAQ,EACN,OACA,SAAS,EAAE,OAOP;EACJ,MAAMA,aAAW,OAAO,YAAYC;EACpC,MAAM,qBAAqB,eACzB,uBAAuB,MAAM,aAAa,KAAK,CAAC,GAC3C,0BACA,0BACN;AAED,SAAO,qBAAqB;GAC1B,SAAS;GACT,eAAe,mBAAmB,KAAK;GACvC,QAAQ;IACN,2BAA2B,EAAE;IAC7B,yBAAyB;KAGvB,mBAAmB,MAAM,YAAY,IAAI,KAAA,EAAU;KACnD,SAAS,OACD;MACJ,MAAM,eAAe,MAAM,aAAa,KAAK;AAC7C,UAAI,CAAC,uBAAuB,aAAa,CAAE;MAC3C,MAAM,OAAO,iBAAiB,cAAcD,WAAS;AAKrD,UAAI,CAAC,aAAa,KAAK,MAAM,YAAY,EAAE,KAAK,CAAE,OAAM,YAAY,IAAI,KAAK;OAEhF;KACF;IACF;GACF,CAAC;;CAEL,CAAC"}

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

@@ -1,106 +1,12 @@
 import { computed, signal } from "../../../core/signals/primitives.js";
-import { defineBehavior } from "../../../core/composition/create-composition.js";
 import { effect } from "../../../core/signals/effect.js";
 import { createMachineReactor } from "../../../core/reactors/create-machine-reactor.js";
 import { isResolvedTrack } from "../../../media/types/index.js";
 import { findTrackById } from "../../../media/utils/tracks.js";
+import { onMediaSourceReadyStateChange } from "../../../media/dom/mse/mediasource-setup.js";
 import { getMaxBufferedEnd, waitForSourceBuffersReady } from "../../../media/dom/mse/duration.js";
 import { isLastSegmentAppended } from "../../../media/dom/mse/end-of-stream.js";
-import { onMediaSourceReadyStateChange } from "../../../media/dom/mse/mediasource-setup.js";
 //#region src/playback/behaviors/dom/end-of-stream.ts
-/**
-* **Drive each `open → ended` transition of the MediaSource.** Calls
-* `MediaSource.endOfStream()` once the temporally last segments of every
-* active buffer actor's currently-loading track are fully appended and
-* the user has reached them — letting the browser finalize duration and
-* fire `ended` on the media element.
-*
-* Re-fires on every subsequent `open → ended → open` cycle. Per the MSE
-* spec, `appendBuffer()` after `endOfStream()` transitions the MediaSource
-* back to `'open'`; seek-back replays and back-buffer refills that re-load
-* earlier segments take this path, so the behavior must call
-* `endOfStream()` again once the last segments are reappended. The reactor's
-* `'preconditions-unmet'` ↔ `'eos-ready'` cycle *is* the re-arm mechanism:
-* a successful `endOfStream()` flips `mediaSource.readyState` to `'ended'`,
-* which (via the local `msIsOpen` signal) exits `'eos-ready'`; the next
-* `'open'` re-evaluates preconditions and may re-enter.
-*
-* # Tracking what's in the buffer
-*
-* Each `SourceBufferActor` knows which track it's currently loading via
-* `initTrackId` (set on the most recent `append-init` message) and which
-* segments it has appended. `deriveState` iterates over the available
-* buffer actors (`[videoBufferActor, audioBufferActor].filter(Boolean)`),
-* resolves each to its track via `findTrackById`, and checks that track's
-* last segment is appended. This means audio-only / video-only / mixed
-* configurations compose uniformly — the body iterates whatever's in
-* scope. No reliance on `selectedTrackId` slots: the actor's view IS the
-* source of truth for "what's being loaded into this buffer."
-*
-* **Two-fire on mid-end ABR switches**: when a quality switch occurs near
-* end-of-stream, the actor's `initTrackId` still reflects the *old* track
-* until the new init segment is appended. The reactor may fire
-* `endOfStream()` against the old track's last-segment-appended state,
-* then the new init's `appendBuffer()` re-opens the MS, which re-arms us
-* to fire again once the new track's last segment lands. Functionally
-* correct (the browser re-fires `ended` after the re-arm), at the cost of
-* one extra call. Accepted as the price of dropping `selectedTrackId`
-* dependence.
-*
-* # Buffer-actor idle gate
-*
-* Each actor must be `'idle'` (no queued or in-flight tasks) before we
-* fire. `buffer.updating === false` alone is insufficient: for chunked
-* fMP4 streaming, `updateend` fires after each chunk while the actor's
-* for-await loop synchronously enqueues the next `appendBuffer()` — so
-* the buffer flips `!updating → updating` across a microtask boundary.
-* The actor's `'updating'` state spans the entire multi-chunk append, so
-* `actor.snapshot.value === 'idle'` is the canonical "no more pending or
-* in-flight work" oracle.
-*
-* This bet (actor models the pipeline; `mediaSource.sourceBuffers` models
-* DOM state) is durable as long as the segment loader is the sole writer
-* of `appendBuffer()` calls. A future loop-mode that auto-fetches earlier
-* segments mid-`ended` would require a broader coordination story
-* between SourceBuffers and the MediaSource — possibly via a
-* `MediaSourceActor` — and that's where this gate would want
-* re-evaluating.
-*
-* # currentTime gate
-*
-* `currentTime` must have reached at least one active track's last
-* segment startTime. Prevents `'eos-ready'` entry when a back-buffer
-* `remove()` / `appendBuffer()` briefly re-opens the MediaSource while
-* the user is mid-stream. HLS rendition time-alignment means any active
-* track works as the reference.
-*
-* # MS readyState — local subscription
-*
-* The behavior subscribes to `mediaSource`'s readyState changes inside
-* its setup (via `onMediaSourceReadyStateChange`) and mirrors `'open'` to
-* a behavior-local `msIsOpen` signal that `deriveState` reads. No shared
-* `mediaSourceReadyState` slot dependency. Anticipates a future
-* `MediaSourceActor` whose snapshot would expose the same signal — the
-* consumer code wouldn't change.
-*
-* # `endOfStream` entry sequence
-*
-* 1. Wait for all SourceBuffers to be idle (DOM-level — defensive,
-*    should already hold given the actor-idle gate in `deriveState`).
-* 2. Set `mediaSource.duration` from `getMaxBufferedEnd` to match actual
-*    container timestamps (`endOfStream()` only clamps up implicitly;
-*    setting it explicitly here keeps the final value deterministic).
-* 3. Call `mediaSource.endOfStream()`.
-*
-* State-exit cleanup (`controller.abort()`) cancels any in-flight wait
-* on source unload, presentation replace, or behavior destroy.
-*
-* # Coordination with `updateMediaSourceDuration`
-*
-* `updateMediaSourceDuration` writes the initial `mediaSource.duration`
-* from `presentation.duration` once per source; this behavior writes the
-* final value from the buffered end. Decision domains don't overlap.
-*/
 function deriveState(presentation, mediaSource, msIsOpen, videoBufferActor, audioBufferActor, currentTime) {
 	if (!mediaSource || !presentation || !msIsOpen) return "preconditions-unmet";
 	const actors = [videoBufferActor, audioBufferActor].filter((a) => a !== void 0);
@@ -137,7 +43,7 @@ function endOfStreamSetup({ state, context }) {
 		});
 		return () => controller.abort();
 	});
-	const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaSource.get(), msIsOpen.get(), context.videoBufferActor.get(), context.audioBufferActor.get(), state.currentTime.get()));
+	const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaSource.get(), msIsOpen.get(), context.videoBufferActor?.get(), context.audioBufferActor?.get(), state.currentTime.get()));
 	const reactor = createMachineReactor({
 		initial: "preconditions-unmet",
 		monitor: () => derivedStateSignal.get(),
@@ -163,15 +69,21 @@ function endOfStreamSetup({ state, context }) {
 		reactor.destroy();
 	};
 }
-const endOfStream = defineBehavior({
+/**
+* `endOfStream` uses a manual `Behavior<>` literal (rather than
+* `defineBehavior`) because it reads `videoBufferActor` /
+* `audioBufferActor` defensively without declaring them in its
+* contextKeys — those slots are contributed by other behaviors and
+* compose conditionally per engine variant. The `Behavior<>` literal
+* opts out of the exhaustiveness check so the typed context shape can
+* include the optional fields used at runtime. See the comment on
+* `endOfStreamSetup`'s context param for the discipline.
+*/
+const endOfStream = {
 	stateKeys: ["presentation", "currentTime"],
-	contextKeys: [
-		"mediaSource",
-		"videoBufferActor",
-		"audioBufferActor"
-	],
+	contextKeys: ["mediaSource"],
 	setup: endOfStreamSetup
-});
+};
 //#endregion
 export { endOfStream };
 

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

@@ -1 +1 @@
-{"version":3,"file":"end-of-stream.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/end-of-stream.ts"],"sourcesContent":["/**\n * **Drive each `open → ended` transition of the MediaSource.** Calls\n * `MediaSource.endOfStream()` once the temporally last segments of every\n * active buffer actor's currently-loading track are fully appended and\n * the user has reached them — letting the browser finalize duration and\n * fire `ended` on the media element.\n *\n * Re-fires on every subsequent `open → ended → open` cycle. Per the MSE\n * spec, `appendBuffer()` after `endOfStream()` transitions the MediaSource\n * back to `'open'`; seek-back replays and back-buffer refills that re-load\n * earlier segments take this path, so the behavior must call\n * `endOfStream()` again once the last segments are reappended. The reactor's\n * `'preconditions-unmet'` ↔ `'eos-ready'` cycle *is* the re-arm mechanism:\n * a successful `endOfStream()` flips `mediaSource.readyState` to `'ended'`,\n * which (via the local `msIsOpen` signal) exits `'eos-ready'`; the next\n * `'open'` re-evaluates preconditions and may re-enter.\n *\n * # Tracking what's in the buffer\n *\n * Each `SourceBufferActor` knows which track it's currently loading via\n * `initTrackId` (set on the most recent `append-init` message) and which\n * segments it has appended. `deriveState` iterates over the available\n * buffer actors (`[videoBufferActor, audioBufferActor].filter(Boolean)`),\n * resolves each to its track via `findTrackById`, and checks that track's\n * last segment is appended. This means audio-only / video-only / mixed\n * configurations compose uniformly — the body iterates whatever's in\n * scope. No reliance on `selectedTrackId` slots: the actor's view IS the\n * source of truth for \"what's being loaded into this buffer.\"\n *\n * **Two-fire on mid-end ABR switches**: when a quality switch occurs near\n * end-of-stream, the actor's `initTrackId` still reflects the *old* track\n * until the new init segment is appended. The reactor may fire\n * `endOfStream()` against the old track's last-segment-appended state,\n * then the new init's `appendBuffer()` re-opens the MS, which re-arms us\n * to fire again once the new track's last segment lands. Functionally\n * correct (the browser re-fires `ended` after the re-arm), at the cost of\n * one extra call. Accepted as the price of dropping `selectedTrackId`\n * dependence.\n *\n * # Buffer-actor idle gate\n *\n * Each actor must be `'idle'` (no queued or in-flight tasks) before we\n * fire. `buffer.updating === false` alone is insufficient: for chunked\n * fMP4 streaming, `updateend` fires after each chunk while the actor's\n * for-await loop synchronously enqueues the next `appendBuffer()` — so\n * the buffer flips `!updating → updating` across a microtask boundary.\n * The actor's `'updating'` state spans the entire multi-chunk append, so\n * `actor.snapshot.value === 'idle'` is the canonical \"no more pending or\n * in-flight work\" oracle.\n *\n * This bet (actor models the pipeline; `mediaSource.sourceBuffers` models\n * DOM state) is durable as long as the segment loader is the sole writer\n * of `appendBuffer()` calls. A future loop-mode that auto-fetches earlier\n * segments mid-`ended` would require a broader coordination story\n * between SourceBuffers and the MediaSource — possibly via a\n * `MediaSourceActor` — and that's where this gate would want\n * re-evaluating.\n *\n * # currentTime gate\n *\n * `currentTime` must have reached at least one active track's last\n * segment startTime. Prevents `'eos-ready'` entry when a back-buffer\n * `remove()` / `appendBuffer()` briefly re-opens the MediaSource while\n * the user is mid-stream. HLS rendition time-alignment means any active\n * track works as the reference.\n *\n * # MS readyState — local subscription\n *\n * The behavior subscribes to `mediaSource`'s readyState changes inside\n * its setup (via `onMediaSourceReadyStateChange`) and mirrors `'open'` to\n * a behavior-local `msIsOpen` signal that `deriveState` reads. No shared\n * `mediaSourceReadyState` slot dependency. Anticipates a future\n * `MediaSourceActor` whose snapshot would expose the same signal — the\n * consumer code wouldn't change.\n *\n * # `endOfStream` entry sequence\n *\n * 1. Wait for all SourceBuffers to be idle (DOM-level — defensive,\n *    should already hold given the actor-idle gate in `deriveState`).\n * 2. Set `mediaSource.duration` from `getMaxBufferedEnd` to match actual\n *    container timestamps (`endOfStream()` only clamps up implicitly;\n *    setting it explicitly here keeps the final value deterministic).\n * 3. Call `mediaSource.endOfStream()`.\n *\n * State-exit cleanup (`controller.abort()`) cancels any in-flight wait\n * on source unload, presentation replace, or behavior destroy.\n *\n * # Coordination with `updateMediaSourceDuration`\n *\n * `updateMediaSourceDuration` writes the initial `mediaSource.duration`\n * from `presentation.duration` once per source; this behavior writes the\n * final value from the buffered end. Decision domains don't overlap.\n */\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { effect } from '../../../core/signals/effect';\nimport { computed, type ReadonlySignal, signal } from '../../../core/signals/primitives';\nimport { getMaxBufferedEnd, waitForSourceBuffersReady } from '../../../media/dom/mse/duration';\nimport { isLastSegmentAppended } from '../../../media/dom/mse/end-of-stream';\nimport { onMediaSourceReadyStateChange } from '../../../media/dom/mse/mediasource-setup';\nimport type { MaybeResolvedPresentation } from '../../../media/types';\nimport { isResolvedTrack } from '../../../media/types';\nimport { findTrackById } from '../../../media/utils/tracks';\nimport type { SourceBufferActor } from '../../actors/dom/source-buffer';\n\nexport interface EndOfStreamState {\n  presentation?: MaybeResolvedPresentation;\n  currentTime?: number;\n}\n\nexport interface EndOfStreamContext {\n  mediaSource?: MediaSource;\n  videoBufferActor?: SourceBufferActor;\n  audioBufferActor?: SourceBufferActor;\n}\n\ntype EndOfStreamFsmState = 'preconditions-unmet' | 'eos-ready';\n\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined,\n  msIsOpen: boolean,\n  videoBufferActor: SourceBufferActor | undefined,\n  audioBufferActor: SourceBufferActor | undefined,\n  currentTime: number | undefined\n): EndOfStreamFsmState {\n  if (!mediaSource || !presentation || !msIsOpen) return 'preconditions-unmet';\n\n  const actors = [videoBufferActor, audioBufferActor].filter((a): a is SourceBufferActor => a !== undefined);\n  // No active buffer actors means setup hasn't completed wiring yet.\n  if (actors.length === 0) return 'preconditions-unmet';\n\n  // Track the latest last-segment startTime across actors as the\n  // currentTime reference. HLS rendition time-alignment makes any active\n  // track usable; using the max is safest when timings drift slightly.\n  let lastSegStart: number | undefined;\n\n  for (const actor of actors) {\n    const snapshot = actor.snapshot.get();\n    if (snapshot.value !== 'idle') return 'preconditions-unmet';\n\n    const { initTrackId, segments: appended } = snapshot.context;\n    if (!initTrackId) return 'preconditions-unmet';\n\n    const track = findTrackById(presentation, initTrackId);\n    if (!track || !isResolvedTrack(track)) return 'preconditions-unmet';\n    if (!isLastSegmentAppended(track.segments, appended)) return 'preconditions-unmet';\n\n    if (track.segments.length > 0) {\n      const start = track.segments[track.segments.length - 1]!.startTime;\n      if (lastSegStart === undefined || start > lastSegStart) lastSegStart = start;\n    }\n  }\n\n  if (lastSegStart !== undefined && (currentTime ?? 0) < lastSegStart) {\n    return 'preconditions-unmet';\n  }\n\n  return 'eos-ready';\n}\n\nfunction endOfStreamSetup({\n  state,\n  context,\n}: {\n  state: {\n    presentation: ReadonlySignal<EndOfStreamState['presentation']>;\n    currentTime: ReadonlySignal<EndOfStreamState['currentTime']>;\n  };\n  context: {\n    mediaSource: ReadonlySignal<EndOfStreamContext['mediaSource']>;\n    videoBufferActor: ReadonlySignal<EndOfStreamContext['videoBufferActor']>;\n    audioBufferActor: ReadonlySignal<EndOfStreamContext['audioBufferActor']>;\n  };\n}): () => void {\n  // Behavior-local mirror of `mediaSource.readyState === 'open'`. Subscribes\n  // to MS events whenever a MediaSource is in scope; tears down when the\n  // MS is swapped or the behavior destroys. Anticipates a future\n  // `MediaSourceActor` whose snapshot would expose the same value — the\n  // consumer code (deriveState) wouldn't change.\n  const msIsOpen = signal(false);\n  const cleanupMsListener = effect(() => {\n    const mediaSource = context.mediaSource.get();\n    if (!mediaSource) {\n      msIsOpen.set(false);\n      return;\n    }\n    msIsOpen.set(mediaSource.readyState === 'open');\n    const controller = new AbortController();\n    onMediaSourceReadyStateChange(mediaSource, controller.signal, (rs) => {\n      msIsOpen.set(rs === 'open');\n    });\n    return () => controller.abort();\n  });\n\n  const derivedStateSignal = computed(() =>\n    deriveState(\n      state.presentation.get(),\n      context.mediaSource.get(),\n      msIsOpen.get(),\n      context.videoBufferActor.get(),\n      context.audioBufferActor.get(),\n      state.currentTime.get()\n    )\n  );\n\n  const reactor = createMachineReactor<EndOfStreamFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'eos-ready': {\n        // entry body is auto-untracked. deriveState handles source resets\n        // and the MS readyState flip from 'open' to 'ended' that\n        // endOfStream() produces; this entry resolves the MSE-spec\n        // preconditions and binds its cleanup (abort) to state exit +\n        // destroy.\n        entry: () => {\n          const mediaSource = context.mediaSource.get()!;\n          const controller = new AbortController();\n\n          const endStreamWhenReady = async () => {\n            // Defensive: the actor-idle gate in deriveState should mean\n            // buffers are already settled, but a microtask boundary\n            // between deriveState's read and entry firing leaves a thin\n            // gap. The DOM-level wait closes it.\n            await waitForSourceBuffersReady(mediaSource.sourceBuffers, controller.signal);\n            if (controller.signal.aborted) return;\n\n            // MSE spec: duration cannot be less than any buffered range, and\n            // endOfStream() will only clamp up implicitly. Setting it\n            // explicitly here from actual container timestamps keeps the\n            // final value deterministic for assets whose declared duration\n            // disagrees with the buffered end (common with CMAF).\n            const bufferedEnd = getMaxBufferedEnd(mediaSource.sourceBuffers);\n            if (bufferedEnd > 0) mediaSource.duration = bufferedEnd;\n\n            mediaSource.endOfStream();\n          };\n\n          endStreamWhenReady().catch((err) => console.error('Failed to call endOfStream:', err));\n\n          return () => controller.abort();\n        },\n      },\n    },\n  });\n\n  return () => {\n    cleanupMsListener();\n    reactor.destroy();\n  };\n}\n\nexport const endOfStream = defineBehavior({\n  stateKeys: ['presentation', 'currentTime'],\n  contextKeys: ['mediaSource', 'videoBufferActor', 'audioBufferActor'],\n  setup: endOfStreamSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsHA,SAAS,YACP,cACA,aACA,UACA,kBACA,kBACA,aACqB;AACrB,KAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC,SAAU,QAAO;CAEvD,MAAM,SAAS,CAAC,kBAAkB,iBAAiB,CAAC,QAAQ,MAA8B,MAAM,KAAA,EAAU;AAE1G,KAAI,OAAO,WAAW,EAAG,QAAO;CAKhC,IAAI;AAEJ,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,MAAM,SAAS,KAAK;AACrC,MAAI,SAAS,UAAU,OAAQ,QAAO;EAEtC,MAAM,EAAE,aAAa,UAAU,aAAa,SAAS;AACrD,MAAI,CAAC,YAAa,QAAO;EAEzB,MAAM,QAAQ,cAAc,cAAc,YAAY;AACtD,MAAI,CAAC,SAAS,CAAC,gBAAgB,MAAM,CAAE,QAAO;AAC9C,MAAI,CAAC,sBAAsB,MAAM,UAAU,SAAS,CAAE,QAAO;AAE7D,MAAI,MAAM,SAAS,SAAS,GAAG;GAC7B,MAAM,QAAQ,MAAM,SAAS,MAAM,SAAS,SAAS,GAAI;AACzD,OAAI,iBAAiB,KAAA,KAAa,QAAQ,aAAc,gBAAe;;;AAI3E,KAAI,iBAAiB,KAAA,MAAc,eAAe,KAAK,aACrD,QAAO;AAGT,QAAO;;AAGT,SAAS,iBAAiB,EACxB,OACA,WAWa;CAMb,MAAM,WAAW,OAAO,MAAM;CAC9B,MAAM,oBAAoB,aAAa;EACrC,MAAM,cAAc,QAAQ,YAAY,KAAK;AAC7C,MAAI,CAAC,aAAa;AAChB,YAAS,IAAI,MAAM;AACnB;;AAEF,WAAS,IAAI,YAAY,eAAe,OAAO;EAC/C,MAAM,aAAa,IAAI,iBAAiB;AACxC,gCAA8B,aAAa,WAAW,SAAS,OAAO;AACpE,YAAS,IAAI,OAAO,OAAO;IAC3B;AACF,eAAa,WAAW,OAAO;GAC/B;CAEF,MAAM,qBAAqB,eACzB,YACE,MAAM,aAAa,KAAK,EACxB,QAAQ,YAAY,KAAK,EACzB,SAAS,KAAK,EACd,QAAQ,iBAAiB,KAAK,EAC9B,QAAQ,iBAAiB,KAAK,EAC9B,MAAM,YAAY,KAAK,CACxB,CACF;CAED,MAAM,UAAU,qBAA0C;EACxD,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,uBAAuB,EAAE;GAEzB,aAAa,EAMX,aAAa;IACX,MAAM,cAAc,QAAQ,YAAY,KAAK;IAC7C,MAAM,aAAa,IAAI,iBAAiB;IAExC,MAAM,qBAAqB,YAAY;AAKrC,WAAM,0BAA0B,YAAY,eAAe,WAAW,OAAO;AAC7E,SAAI,WAAW,OAAO,QAAS;KAO/B,MAAM,cAAc,kBAAkB,YAAY,cAAc;AAChE,SAAI,cAAc,EAAG,aAAY,WAAW;AAE5C,iBAAY,aAAa;;AAG3B,wBAAoB,CAAC,OAAO,QAAQ,QAAQ,MAAM,+BAA+B,IAAI,CAAC;AAEtF,iBAAa,WAAW,OAAO;MAElC;GACF;EACF,CAAC;AAEF,cAAa;AACX,qBAAmB;AACnB,UAAQ,SAAS;;;AAIrB,MAAa,cAAc,eAAe;CACxC,WAAW,CAAC,gBAAgB,cAAc;CAC1C,aAAa;EAAC;EAAe;EAAoB;EAAmB;CACpE,OAAO;CACR,CAAC"}
+{"version":3,"file":"end-of-stream.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/end-of-stream.ts"],"sourcesContent":["/**\n * **Drive each `open → ended` transition of the MediaSource.** Calls\n * `MediaSource.endOfStream()` once the temporally last segments of every\n * active buffer actor's currently-loading track are fully appended and\n * the user has reached them — letting the browser finalize duration and\n * fire `ended` on the media element.\n *\n * Re-fires on every subsequent `open → ended → open` cycle. Per the MSE\n * spec, `appendBuffer()` after `endOfStream()` transitions the MediaSource\n * back to `'open'`; seek-back replays and back-buffer refills that re-load\n * earlier segments take this path, so the behavior must call\n * `endOfStream()` again once the last segments are reappended. The reactor's\n * `'preconditions-unmet'` ↔ `'eos-ready'` cycle *is* the re-arm mechanism:\n * a successful `endOfStream()` flips `mediaSource.readyState` to `'ended'`,\n * which (via the local `msIsOpen` signal) exits `'eos-ready'`; the next\n * `'open'` re-evaluates preconditions and may re-enter.\n *\n * # Tracking what's in the buffer\n *\n * Each `SourceBufferActor` knows which track it's currently loading via\n * `initTrackId` (set on the most recent `append-init` message) and which\n * segments it has appended. `deriveState` iterates over the available\n * buffer actors (`[videoBufferActor, audioBufferActor].filter(Boolean)`),\n * resolves each to its track via `findTrackById`, and checks that track's\n * last segment is appended. This means audio-only / video-only / mixed\n * configurations compose uniformly — the body iterates whatever's in\n * scope. No reliance on `selectedTrackId` slots: the actor's view IS the\n * source of truth for \"what's being loaded into this buffer.\"\n *\n * **Two-fire on mid-end ABR switches**: when a quality switch occurs near\n * end-of-stream, the actor's `initTrackId` still reflects the *old* track\n * until the new init segment is appended. The reactor may fire\n * `endOfStream()` against the old track's last-segment-appended state,\n * then the new init's `appendBuffer()` re-opens the MS, which re-arms us\n * to fire again once the new track's last segment lands. Functionally\n * correct (the browser re-fires `ended` after the re-arm), at the cost of\n * one extra call. Accepted as the price of dropping `selectedTrackId`\n * dependence.\n *\n * # Buffer-actor idle gate\n *\n * Each actor must be `'idle'` (no queued or in-flight tasks) before we\n * fire. `buffer.updating === false` alone is insufficient: for chunked\n * fMP4 streaming, `updateend` fires after each chunk while the actor's\n * for-await loop synchronously enqueues the next `appendBuffer()` — so\n * the buffer flips `!updating → updating` across a microtask boundary.\n * The actor's `'updating'` state spans the entire multi-chunk append, so\n * `actor.snapshot.value === 'idle'` is the canonical \"no more pending or\n * in-flight work\" oracle.\n *\n * This bet (actor models the pipeline; `mediaSource.sourceBuffers` models\n * DOM state) is durable as long as the segment loader is the sole writer\n * of `appendBuffer()` calls. A future loop-mode that auto-fetches earlier\n * segments mid-`ended` would require a broader coordination story\n * between SourceBuffers and the MediaSource — possibly via a\n * `MediaSourceActor` — and that's where this gate would want\n * re-evaluating.\n *\n * # currentTime gate\n *\n * `currentTime` must have reached at least one active track's last\n * segment startTime. Prevents `'eos-ready'` entry when a back-buffer\n * `remove()` / `appendBuffer()` briefly re-opens the MediaSource while\n * the user is mid-stream. HLS rendition time-alignment means any active\n * track works as the reference.\n *\n * # MS readyState — local subscription\n *\n * The behavior subscribes to `mediaSource`'s readyState changes inside\n * its setup (via `onMediaSourceReadyStateChange`) and mirrors `'open'` to\n * a behavior-local `msIsOpen` signal that `deriveState` reads. No shared\n * `mediaSourceReadyState` slot dependency. Anticipates a future\n * `MediaSourceActor` whose snapshot would expose the same signal — the\n * consumer code wouldn't change.\n *\n * # `endOfStream` entry sequence\n *\n * 1. Wait for all SourceBuffers to be idle (DOM-level — defensive,\n *    should already hold given the actor-idle gate in `deriveState`).\n * 2. Set `mediaSource.duration` from `getMaxBufferedEnd` to match actual\n *    container timestamps (`endOfStream()` only clamps up implicitly;\n *    setting it explicitly here keeps the final value deterministic).\n * 3. Call `mediaSource.endOfStream()`.\n *\n * State-exit cleanup (`controller.abort()`) cancels any in-flight wait\n * on source unload, presentation replace, or behavior destroy.\n *\n * # Coordination with `updateMediaSourceDuration`\n *\n * `updateMediaSourceDuration` writes the initial `mediaSource.duration`\n * from `presentation.duration` once per source; this behavior writes the\n * final value from the buffered end. Decision domains don't overlap.\n */\nimport type { Behavior } from '../../../core/composition/create-composition';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { effect } from '../../../core/signals/effect';\nimport { computed, type ReadonlySignal, signal } from '../../../core/signals/primitives';\nimport { getMaxBufferedEnd, waitForSourceBuffersReady } from '../../../media/dom/mse/duration';\nimport { isLastSegmentAppended } from '../../../media/dom/mse/end-of-stream';\nimport { onMediaSourceReadyStateChange } from '../../../media/dom/mse/mediasource-setup';\nimport type { MaybeResolvedPresentation } from '../../../media/types';\nimport { isResolvedTrack } from '../../../media/types';\nimport { findTrackById } from '../../../media/utils/tracks';\nimport type { SourceBufferActor } from '../../actors/dom/source-buffer';\n\nexport interface EndOfStreamState {\n  presentation?: MaybeResolvedPresentation;\n  currentTime?: number;\n}\n\nexport interface EndOfStreamContext {\n  mediaSource?: MediaSource;\n  videoBufferActor?: SourceBufferActor;\n  audioBufferActor?: SourceBufferActor;\n}\n\ntype EndOfStreamFsmState = 'preconditions-unmet' | 'eos-ready';\n\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined,\n  msIsOpen: boolean,\n  videoBufferActor: SourceBufferActor | undefined,\n  audioBufferActor: SourceBufferActor | undefined,\n  currentTime: number | undefined\n): EndOfStreamFsmState {\n  if (!mediaSource || !presentation || !msIsOpen) return 'preconditions-unmet';\n\n  const actors = [videoBufferActor, audioBufferActor].filter((a): a is SourceBufferActor => a !== undefined);\n  // No active buffer actors means setup hasn't completed wiring yet.\n  if (actors.length === 0) return 'preconditions-unmet';\n\n  // Track the latest last-segment startTime across actors as the\n  // currentTime reference. HLS rendition time-alignment makes any active\n  // track usable; using the max is safest when timings drift slightly.\n  let lastSegStart: number | undefined;\n\n  for (const actor of actors) {\n    const snapshot = actor.snapshot.get();\n    if (snapshot.value !== 'idle') return 'preconditions-unmet';\n\n    const { initTrackId, segments: appended } = snapshot.context;\n    if (!initTrackId) return 'preconditions-unmet';\n\n    const track = findTrackById(presentation, initTrackId);\n    if (!track || !isResolvedTrack(track)) return 'preconditions-unmet';\n    if (!isLastSegmentAppended(track.segments, appended)) return 'preconditions-unmet';\n\n    if (track.segments.length > 0) {\n      const start = track.segments[track.segments.length - 1]!.startTime;\n      if (lastSegStart === undefined || start > lastSegStart) lastSegStart = start;\n    }\n  }\n\n  if (lastSegStart !== undefined && (currentTime ?? 0) < lastSegStart) {\n    return 'preconditions-unmet';\n  }\n\n  return 'eos-ready';\n}\n\nfunction endOfStreamSetup({\n  state,\n  context,\n}: {\n  state: {\n    presentation: ReadonlySignal<EndOfStreamState['presentation']>;\n    currentTime: ReadonlySignal<EndOfStreamState['currentTime']>;\n  };\n  context: {\n    mediaSource: ReadonlySignal<EndOfStreamContext['mediaSource']>;\n    // See behavior definition for details on these optional context signals.\n    videoBufferActor?: ReadonlySignal<SourceBufferActor | undefined>;\n    audioBufferActor?: ReadonlySignal<SourceBufferActor | undefined>;\n  };\n}): () => void {\n  // Behavior-local mirror of `mediaSource.readyState === 'open'`. Subscribes\n  // to MS events whenever a MediaSource is in scope; tears down when the\n  // MS is swapped or the behavior destroys. Anticipates a future\n  // `MediaSourceActor` whose snapshot would expose the same value — the\n  // consumer code (deriveState) wouldn't change.\n  const msIsOpen = signal(false);\n  const cleanupMsListener = effect(() => {\n    const mediaSource = context.mediaSource.get();\n    if (!mediaSource) {\n      msIsOpen.set(false);\n      return;\n    }\n    msIsOpen.set(mediaSource.readyState === 'open');\n    const controller = new AbortController();\n    onMediaSourceReadyStateChange(mediaSource, controller.signal, (rs) => {\n      msIsOpen.set(rs === 'open');\n    });\n    return () => controller.abort();\n  });\n\n  const derivedStateSignal = computed(() =>\n    deriveState(\n      state.presentation.get(),\n      context.mediaSource.get(),\n      msIsOpen.get(),\n      context.videoBufferActor?.get(),\n      context.audioBufferActor?.get(),\n      state.currentTime.get()\n    )\n  );\n\n  const reactor = createMachineReactor<EndOfStreamFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'eos-ready': {\n        // entry body is auto-untracked. deriveState handles source resets\n        // and the MS readyState flip from 'open' to 'ended' that\n        // endOfStream() produces; this entry resolves the MSE-spec\n        // preconditions and binds its cleanup (abort) to state exit +\n        // destroy.\n        entry: () => {\n          const mediaSource = context.mediaSource.get()!;\n          const controller = new AbortController();\n\n          const endStreamWhenReady = async () => {\n            // Defensive: the actor-idle gate in deriveState should mean\n            // buffers are already settled, but a microtask boundary\n            // between deriveState's read and entry firing leaves a thin\n            // gap. The DOM-level wait closes it.\n            await waitForSourceBuffersReady(mediaSource.sourceBuffers, controller.signal);\n            if (controller.signal.aborted) return;\n\n            // MSE spec: duration cannot be less than any buffered range, and\n            // endOfStream() will only clamp up implicitly. Setting it\n            // explicitly here from actual container timestamps keeps the\n            // final value deterministic for assets whose declared duration\n            // disagrees with the buffered end (common with CMAF).\n            const bufferedEnd = getMaxBufferedEnd(mediaSource.sourceBuffers);\n            if (bufferedEnd > 0) mediaSource.duration = bufferedEnd;\n\n            mediaSource.endOfStream();\n          };\n\n          endStreamWhenReady().catch((err) => console.error('Failed to call endOfStream:', err));\n\n          return () => controller.abort();\n        },\n      },\n    },\n  });\n\n  return () => {\n    cleanupMsListener();\n    reactor.destroy();\n  };\n}\n\n/**\n * `endOfStream` uses a manual `Behavior<>` literal (rather than\n * `defineBehavior`) because it reads `videoBufferActor` /\n * `audioBufferActor` defensively without declaring them in its\n * contextKeys — those slots are contributed by other behaviors and\n * compose conditionally per engine variant. The `Behavior<>` literal\n * opts out of the exhaustiveness check so the typed context shape can\n * include the optional fields used at runtime. See the comment on\n * `endOfStreamSetup`'s context param for the discipline.\n */\nexport const endOfStream: Behavior<\n  {\n    presentation: ReadonlySignal<EndOfStreamState['presentation']>;\n    currentTime: ReadonlySignal<EndOfStreamState['currentTime']>;\n  },\n  { mediaSource: ReadonlySignal<EndOfStreamContext['mediaSource']> }\n> = {\n  stateKeys: ['presentation', 'currentTime'],\n  contextKeys: ['mediaSource'],\n  setup: endOfStreamSetup,\n};\n"],"mappings":";;;;;;;;;AAsHA,SAAS,YACP,cACA,aACA,UACA,kBACA,kBACA,aACqB;AACrB,KAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC,SAAU,QAAO;CAEvD,MAAM,SAAS,CAAC,kBAAkB,iBAAiB,CAAC,QAAQ,MAA8B,MAAM,KAAA,EAAU;AAE1G,KAAI,OAAO,WAAW,EAAG,QAAO;CAKhC,IAAI;AAEJ,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,MAAM,SAAS,KAAK;AACrC,MAAI,SAAS,UAAU,OAAQ,QAAO;EAEtC,MAAM,EAAE,aAAa,UAAU,aAAa,SAAS;AACrD,MAAI,CAAC,YAAa,QAAO;EAEzB,MAAM,QAAQ,cAAc,cAAc,YAAY;AACtD,MAAI,CAAC,SAAS,CAAC,gBAAgB,MAAM,CAAE,QAAO;AAC9C,MAAI,CAAC,sBAAsB,MAAM,UAAU,SAAS,CAAE,QAAO;AAE7D,MAAI,MAAM,SAAS,SAAS,GAAG;GAC7B,MAAM,QAAQ,MAAM,SAAS,MAAM,SAAS,SAAS,GAAI;AACzD,OAAI,iBAAiB,KAAA,KAAa,QAAQ,aAAc,gBAAe;;;AAI3E,KAAI,iBAAiB,KAAA,MAAc,eAAe,KAAK,aACrD,QAAO;AAGT,QAAO;;AAGT,SAAS,iBAAiB,EACxB,OACA,WAYa;CAMb,MAAM,WAAW,OAAO,MAAM;CAC9B,MAAM,oBAAoB,aAAa;EACrC,MAAM,cAAc,QAAQ,YAAY,KAAK;AAC7C,MAAI,CAAC,aAAa;AAChB,YAAS,IAAI,MAAM;AACnB;;AAEF,WAAS,IAAI,YAAY,eAAe,OAAO;EAC/C,MAAM,aAAa,IAAI,iBAAiB;AACxC,gCAA8B,aAAa,WAAW,SAAS,OAAO;AACpE,YAAS,IAAI,OAAO,OAAO;IAC3B;AACF,eAAa,WAAW,OAAO;GAC/B;CAEF,MAAM,qBAAqB,eACzB,YACE,MAAM,aAAa,KAAK,EACxB,QAAQ,YAAY,KAAK,EACzB,SAAS,KAAK,EACd,QAAQ,kBAAkB,KAAK,EAC/B,QAAQ,kBAAkB,KAAK,EAC/B,MAAM,YAAY,KAAK,CACxB,CACF;CAED,MAAM,UAAU,qBAA0C;EACxD,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,uBAAuB,EAAE;GAEzB,aAAa,EAMX,aAAa;IACX,MAAM,cAAc,QAAQ,YAAY,KAAK;IAC7C,MAAM,aAAa,IAAI,iBAAiB;IAExC,MAAM,qBAAqB,YAAY;AAKrC,WAAM,0BAA0B,YAAY,eAAe,WAAW,OAAO;AAC7E,SAAI,WAAW,OAAO,QAAS;KAO/B,MAAM,cAAc,kBAAkB,YAAY,cAAc;AAChE,SAAI,cAAc,EAAG,aAAY,WAAW;AAE5C,iBAAY,aAAa;;AAG3B,wBAAoB,CAAC,OAAO,QAAQ,QAAQ,MAAM,+BAA+B,IAAI,CAAC;AAEtF,iBAAa,WAAW,OAAO;MAElC;GACF;EACF,CAAC;AAEF,cAAa;AACX,qBAAmB;AACnB,UAAQ,SAAS;;;;;;;;;;;;;AAcrB,MAAa,cAMT;CACF,WAAW,CAAC,gBAAgB,cAAc;CAC1C,aAAa,CAAC,cAAc;CAC5B,OAAO;CACR"}

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

@@ -3,7 +3,7 @@ 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 "../track-types.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 /

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

@@ -1 +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"}
+{"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 '../../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  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"}