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

package/dist/dev/playback/actors/text-track-segment-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-track-segment-loader.js","names":[],"sources":["../../../../src/playback/actors/text-track-segment-loader.ts"],"sourcesContent":["import { createMachineActor, type HandlerContext, type MessageActor } from '../../core/actors/create-machine-actor';\nimport { peek } from '../../core/signals/primitives';\nimport { SerialRunner, Task } from '../../core/tasks/task';\nimport {\n  DEFAULT_FORWARD_BUFFER_CONFIG,\n  type ForwardBufferConfig,\n  getSegmentsToLoad,\n} from '../../media/buffer/forward-buffer';\nimport type { Cue, Segment, TextTrack } from '../../media/types';\nimport type { TextTracksActor } from './text-tracks';\n\n// =============================================================================\n// Message / actor types\n// =============================================================================\n\n/**\n * Mirrors the v/a `SegmentLoaderMessage` shape. `range` carries the\n * forward-window anchor (`range.start` is treated as the load anchor;\n * the actor computes its own forward window internally via\n * `getSegmentsToLoad`). When `range` is omitted (metadata mode), this\n * actor is a no-op — text tracks have no init-segment concept.\n */\nexport type TextTrackSegmentLoaderMessage = {\n  type: 'load';\n  track: TextTrack;\n  range?: { start: number; end: number };\n};\n\n/** Finite states of the actor. */\nexport type TextTrackSegmentLoaderActorState = 'idle' | 'loading' | 'destroyed';\n\n/** Non-finite (extended) data managed by the actor. */\nexport interface TextTrackSegmentLoaderActorContext {\n  /**\n   * Track ID of the segment currently being fetched, or null. Paired\n   * with `inFlightSegmentId` so the continue-vs-preempt check survives\n   * cross-track segment-id collisions (e.g. each track starts at\n   * `seg-0`).\n   */\n  inFlightTrackId: string | null;\n  /**\n   * Segment ID currently being fetched, or null. Used together with\n   * `inFlightTrackId` by the `loading` state's `load` handler.\n   */\n  inFlightSegmentId: string | null;\n}\n\nexport type TextTrackSegmentLoaderActor = MessageActor<\n  TextTrackSegmentLoaderActorState,\n  TextTrackSegmentLoaderActorContext,\n  TextTrackSegmentLoaderMessage\n>;\n\n/**\n * Resolves a text-track segment URL into the array of cues it contains.\n *\n * \"Resolve\" because the fn covers both network fetch and parse into the\n * domain model. Host-agnostic — the concrete resolver (e.g. the\n * browser's native VTT resolver) is supplied at engine-assembly time,\n * so this actor stays DOM-free.\n */\nexport type TextTrackSegmentResolver<C extends Cue = Cue> = (url: string) => Promise<C[]>;\n\n/**\n * Configuration for `createTextTrackSegmentLoaderActor`. Spread over\n * `DEFAULT_FORWARD_BUFFER_CONFIG` to override individual forward-window\n * fields (e.g. `bufferDuration`). Text tracks don't have a back-buffer\n * concern — cues evict by their playhead-relative window at runtime —\n * so no `backBuffer` config field.\n */\nexport interface TextTrackSegmentLoaderActorConfig {\n  forwardBuffer?: Partial<ForwardBufferConfig>;\n}\n\n// =============================================================================\n// Implementation\n// =============================================================================\n\n/** Internal load-task descriptor — one segment fetch + dispatch unit. */\ninterface TextLoadTask {\n  segment: Segment;\n  trackId: string;\n}\n\n/**\n * Loads text-track segments for a track and delegates cue management\n * to a TextTracksActor. Mirrors the v/a `SegmentLoaderActor` shape (FSM\n * with `idle` / `loading` and `inFlight*` context for continue-vs-preempt),\n * adapted to text:\n *\n * - No init segment, no flush ops (text cues don't need eviction — they're\n *   small and the playhead-relative window is enforced by the runtime).\n * - Single in-flight identity (`inFlightSegmentId`) — text has only the\n *   media-segment path, no init-segment path.\n *\n * Planning is done in the load handler on every incoming message:\n * `getSegmentsToLoad` filters to the forward window, then the segments\n * not already in `TextTracksActor`'s context are scheduled. When a new\n * `load` arrives mid-run, the handler replans and either:\n *\n * - **Continues**: the in-flight segment is still in the new plan →\n *   `abortPending` only, schedule the rest of the plan (minus the\n *   in-flight item, which covers its slot).\n * - **Preempts**: in-flight segment is no longer wanted (track switch,\n *   large seek out of window) → `abortAll`, schedule the new plan\n *   from scratch.\n *\n * The cue parser is injected so this factory is host-agnostic. A DOM\n * host supplies a VTT parser backed by `<track>`/`TextTrack` APIs; a\n * non-DOM host (worker, test fake, alternate runtime) supplies its own.\n */\nexport function createTextTrackSegmentLoaderActor<C extends Cue>(\n  textTracksActor: TextTracksActor<C>,\n  resolveSegment: TextTrackSegmentResolver<C>,\n  config: TextTrackSegmentLoaderActorConfig = {}\n): TextTrackSegmentLoaderActor {\n  type UserState = Exclude<TextTrackSegmentLoaderActorState, 'destroyed'>;\n  type Ctx = HandlerContext<UserState, TextTrackSegmentLoaderActorContext, () => SerialRunner>;\n\n  const forwardBufferConfig: ForwardBufferConfig = { ...DEFAULT_FORWARD_BUFFER_CONFIG, ...config.forwardBuffer };\n\n  /**\n   * Translate a load message into an ordered TextLoadTask list based on\n   * committed actor state. In-flight awareness is handled separately in\n   * the `loading` state's load handler.\n   *\n   * Metadata mode (no `range`) is a no-op for text — text tracks have\n   * no init-segment concept, so there's nothing to load until a range\n   * arrives via `'full-range'` dispatch.\n   */\n  const planTasks = (message: TextTrackSegmentLoaderMessage): TextLoadTask[] => {\n    const { track, range } = message;\n    if (!range) return [];\n    const trackId = track.id;\n    // Peek (don't track) the snapshot: the loader's `send` is typically\n    // invoked from inside the dispatcher's effect body, so a tracked\n    // `.get()` here would leak the textTracksActor snapshot into the\n    // dispatcher's dep set — every `add-cues` would re-fire the dispatcher\n    // and schedule duplicate loads.\n    const bufferedSegments = peek(textTracksActor.snapshot).context.segments[trackId] ?? [];\n    // `getSegmentsToLoad` uses the actor's threaded `forwardBufferConfig`\n    // to compute its forward-window; only `range.start` is consulted\n    // here as the playhead anchor. `range.end` is informational — it\n    // carries the dispatcher's intended window upper bound but doesn't\n    // override the actor's planning.\n    const segmentsToLoad = getSegmentsToLoad(track.segments, bufferedSegments, range.start, forwardBufferConfig);\n    return segmentsToLoad.map((segment) => ({ segment, trackId }));\n  };\n\n  /**\n   * Wraps a TextLoadTask into a Task that fetches + dispatches `add-cues`.\n   * Updates `inFlightSegmentId` around the fetch so the load handler can\n   * make accurate continue/preempt decisions.\n   */\n  const makeLoadTask = (op: TextLoadTask, { getContext, setContext }: Ctx): Task<void> => {\n    return new Task(async (signal) => {\n      if (signal.aborted) return;\n      setContext({ ...getContext(), inFlightTrackId: op.trackId, inFlightSegmentId: op.segment.id });\n      try {\n        const cues = await resolveSegment(op.segment.url);\n        if (signal.aborted) return;\n        textTracksActor.send({\n          type: 'add-cues',\n          meta: {\n            trackId: op.trackId,\n            id: op.segment.id,\n            startTime: op.segment.startTime,\n            duration: op.segment.duration,\n          },\n          cues,\n        });\n      } catch (error) {\n        // Graceful degradation: log and continue to the next segment.\n        console.error('Failed to load text-track segment:', error);\n      } finally {\n        setContext({ ...getContext(), inFlightTrackId: null, inFlightSegmentId: null });\n      }\n    });\n  };\n\n  const scheduleAll = (tasks: TextLoadTask[], ctx: Ctx): void => {\n    for (const op of tasks) {\n      ctx.runner.schedule(makeLoadTask(op, ctx)).then(undefined, (e: unknown) => {\n        if (e instanceof Error && e.name === 'AbortError') return;\n        console.error('Unexpected error in text-track segment loader:', e);\n        ctx.runner.abortPending();\n      });\n    }\n  };\n\n  return createMachineActor<\n    UserState,\n    TextTrackSegmentLoaderActorContext,\n    TextTrackSegmentLoaderMessage,\n    () => SerialRunner\n  >({\n    runner: () => new SerialRunner(),\n    initial: 'idle',\n    context: { inFlightTrackId: null, inFlightSegmentId: null },\n    states: {\n      idle: {\n        on: {\n          load: (msg, ctx) => {\n            const tasks = planTasks(msg);\n            if (tasks.length === 0) return;\n            ctx.transition('loading');\n            scheduleAll(tasks, ctx);\n          },\n        },\n      },\n      loading: {\n        onSettled: 'idle',\n        on: {\n          load: (msg, ctx) => {\n            const { context, runner } = ctx;\n            const tasks = planTasks(msg);\n\n            const inFlightStillNeeded =\n              context.inFlightTrackId !== null &&\n              context.inFlightSegmentId !== null &&\n              tasks.some((t) => t.trackId === context.inFlightTrackId && t.segment.id === context.inFlightSegmentId);\n\n            if (inFlightStillNeeded) {\n              // Continue: keep the in-flight fetch, schedule the rest.\n              runner.abortPending();\n              scheduleAll(\n                tasks.filter(\n                  (t) => !(t.trackId === context.inFlightTrackId && t.segment.id === context.inFlightSegmentId)\n                ),\n                ctx\n              );\n            } else {\n              // Preempt: abort everything (including in-flight) and replan.\n              runner.abortAll();\n              scheduleAll(tasks, ctx);\n            }\n          },\n        },\n      },\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+GA,SAAgB,kCACd,iBACA,gBACA,SAA4C,EAAE,EACjB;CAI7B,MAAM,sBAA2C;EAAE,GAAG;EAA+B,GAAG,OAAO;EAAe;;;;;;;;;;CAW9G,MAAM,aAAa,YAA2D;EAC5E,MAAM,EAAE,OAAO,UAAU;AACzB,MAAI,CAAC,MAAO,QAAO,EAAE;EACrB,MAAM,UAAU,MAAM;EAMtB,MAAM,mBAAmB,KAAK,gBAAgB,SAAS,CAAC,QAAQ,SAAS,YAAY,EAAE;AAOvF,SADuB,kBAAkB,MAAM,UAAU,kBAAkB,MAAM,OAAO,oBAAoB,CACtF,KAAK,aAAa;GAAE;GAAS;GAAS,EAAE;;;;;;;CAQhE,MAAM,gBAAgB,IAAkB,EAAE,YAAY,iBAAkC;AACtF,SAAO,IAAI,KAAK,OAAO,WAAW;AAChC,OAAI,OAAO,QAAS;AACpB,cAAW;IAAE,GAAG,YAAY;IAAE,iBAAiB,GAAG;IAAS,mBAAmB,GAAG,QAAQ;IAAI,CAAC;AAC9F,OAAI;IACF,MAAM,OAAO,MAAM,eAAe,GAAG,QAAQ,IAAI;AACjD,QAAI,OAAO,QAAS;AACpB,oBAAgB,KAAK;KACnB,MAAM;KACN,MAAM;MACJ,SAAS,GAAG;MACZ,IAAI,GAAG,QAAQ;MACf,WAAW,GAAG,QAAQ;MACtB,UAAU,GAAG,QAAQ;MACtB;KACD;KACD,CAAC;YACK,OAAO;AAEd,YAAQ,MAAM,sCAAsC,MAAM;aAClD;AACR,eAAW;KAAE,GAAG,YAAY;KAAE,iBAAiB;KAAM,mBAAmB;KAAM,CAAC;;IAEjF;;CAGJ,MAAM,eAAe,OAAuB,QAAmB;AAC7D,OAAK,MAAM,MAAM,MACf,KAAI,OAAO,SAAS,aAAa,IAAI,IAAI,CAAC,CAAC,KAAK,KAAA,IAAY,MAAe;AACzE,OAAI,aAAa,SAAS,EAAE,SAAS,aAAc;AACnD,WAAQ,MAAM,kDAAkD,EAAE;AAClE,OAAI,OAAO,cAAc;IACzB;;AAIN,QAAO,mBAKL;EACA,cAAc,IAAI,cAAc;EAChC,SAAS;EACT,SAAS;GAAE,iBAAiB;GAAM,mBAAmB;GAAM;EAC3D,QAAQ;GACN,MAAM,EACJ,IAAI,EACF,OAAO,KAAK,QAAQ;IAClB,MAAM,QAAQ,UAAU,IAAI;AAC5B,QAAI,MAAM,WAAW,EAAG;AACxB,QAAI,WAAW,UAAU;AACzB,gBAAY,OAAO,IAAI;MAE1B,EACF;GACD,SAAS;IACP,WAAW;IACX,IAAI,EACF,OAAO,KAAK,QAAQ;KAClB,MAAM,EAAE,SAAS,WAAW;KAC5B,MAAM,QAAQ,UAAU,IAAI;AAO5B,SAJE,QAAQ,oBAAoB,QAC5B,QAAQ,sBAAsB,QAC9B,MAAM,MAAM,MAAM,EAAE,YAAY,QAAQ,mBAAmB,EAAE,QAAQ,OAAO,QAAQ,kBAAkB,EAE/E;AAEvB,aAAO,cAAc;AACrB,kBACE,MAAM,QACH,MAAM,EAAE,EAAE,YAAY,QAAQ,mBAAmB,EAAE,QAAQ,OAAO,QAAQ,mBAC5E,EACD,IACD;YACI;AAEL,aAAO,UAAU;AACjB,kBAAY,OAAO,IAAI;;OAG5B;IACF;GACF;EACF,CAAC"}

package/dist/dev/playback/actors/text-tracks.d.ts

@@ -0,0 +1,42 @@
+import { TransitionActor } from "../../core/actors/create-transition-actor.js";
+import { Cue, Segment } from "../../media/types/index.js";
+
+//#region src/playback/actors/text-tracks.d.ts
+/** Segment identity and timing — mirrors AppendSegmentMeta without trackId (keyed separately). */
+type CueSegmentMeta = Pick<Segment, 'id' | 'startTime' | 'duration'> & {
+  trackId: string;
+};
+/** Non-finite (extended) data managed by the actor — the XState "context". */
+interface TextTracksActorContext {
+  /** Cues added per track ID. Used for duplicate detection and snapshot observability. */
+  loaded: Record<string, Cue[]>;
+  /** Segments whose cues have been fully added, keyed by track ID. Used for load planning. */
+  segments: Record<string, Array<Pick<Segment, 'id' | 'startTime' | 'duration'>>>;
+}
+interface AddCuesMessage<C extends Cue = Cue> {
+  type: 'add-cues';
+  meta: CueSegmentMeta;
+  cues: C[];
+}
+/**
+ * Wipe the actor's `loaded` + `segments` context. Sent on source reset
+ * (typically by `syncTextTracks` on state exit) so a subsequent
+ * presentation starts with a fresh cue+segment cache. Without this, a
+ * new presentation reusing trackIds from the prior source would have
+ * `getSegmentsToLoad` treat its segments as already-buffered and skip
+ * loading them.
+ */
+interface ClearMessage {
+  type: 'clear';
+}
+type TextTracksActorMessage<C extends Cue = Cue> = AddCuesMessage<C> | ClearMessage;
+/**
+ * Host-agnostic text-track actor type.
+ *
+ * Generic over the concrete cue shape `C` so DOM hosts (using `VTTCue`)
+ * and non-DOM hosts (custom cue representations) can both satisfy it.
+ */
+type TextTracksActor<C extends Cue = Cue> = TransitionActor<TextTracksActorContext, TextTracksActorMessage<C>>;
+//#endregion
+export { AddCuesMessage, ClearMessage, CueSegmentMeta, TextTracksActor, TextTracksActorContext, TextTracksActorMessage };
+//# sourceMappingURL=text-tracks.d.ts.map

package/dist/dev/playback/actors/text-tracks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-tracks.d.ts","names":[],"sources":["../../../../src/playback/actors/text-tracks.ts"],"mappings":";;;;;KAQY,cAAA,GAAiB,IAAA,CAAK,OAAA;EAA8C,OAAA;AAAA;;UAG/D,sBAAA;EAHY;EAK3B,MAAA,EAAQ,MAAA,SAAe,GAAA;EALuD;EAO9E,QAAA,EAAU,MAAA,SAAe,KAAA,CAAM,IAAA,CAAK,OAAA;AAAA;AAAA,UAGrB,cAAA,WAAyB,GAAA,GAAM,GAAA;EAC9C,IAAA;EACA,IAAA,EAAM,cAAA;EACN,IAAA,EAAM,CAAA;AAAA;;;;;;;;;UAWS,YAAA;EACf,IAAA;AAAA;AAAA,KAGU,sBAAA,WAAiC,GAAA,GAAM,GAAA,IAAO,cAAA,CAAe,CAAA,IAAK,YAAA;;;;;AAlB9E;;KA0BY,eAAA,WAA0B,GAAA,GAAM,GAAA,IAAO,eAAA,CAAgB,sBAAA,EAAwB,sBAAA,CAAuB,CAAA"}

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

@@ -0,0 +1,17 @@
+import { MaybeResolvedPresentation } from "../../media/types/index.js";
+
+//#region src/playback/behaviors/calculate-presentation-duration.d.ts
+interface PresentationDurationState {
+  presentation?: MaybeResolvedPresentation;
+  selectedVideoTrackId?: string;
+  selectedAudioTrackId?: string;
+}
+/**
+ * Resolver supplied via `config.resolveDuration`. Returns the duration to
+ * write to `presentation.duration`, or `undefined` when it isn't yet
+ * derivable. Positive `Infinity` is the canonical live value.
+ */
+type PresentationDurationResolver = (state: PresentationDurationState) => number | undefined;
+//#endregion
+export { PresentationDurationResolver };
+//# sourceMappingURL=calculate-presentation-duration.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,58 @@
+import { snapshot, untrack, update } from "../../core/signals/primitives.js";
+import { defineBehavior } from "../../core/composition/create-composition.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)));
+		if (duration === void 0 || Number.isNaN(duration) || duration <= 0) return;
+		update(state.presentation, (current) => current ? {
+			...current,
+			duration
+		} : current);
+	});
+}
+const calculatePresentationDuration = defineBehavior({
+	stateKeys: [
+		"presentation",
+		"selectedVideoTrackId",
+		"selectedAudioTrackId"
+	],
+	contextKeys: [],
+	setup: calculatePresentationDurationSetup
+});
+//#endregion
+export { calculatePresentationDuration };
+
+//# sourceMappingURL=calculate-presentation-duration.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,178 @@
+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 { 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);
+	if (actors.length === 0) return "preconditions-unmet";
+	let lastSegStart;
+	for (const actor of actors) {
+		const snapshot = actor.snapshot.get();
+		if (snapshot.value !== "idle") return "preconditions-unmet";
+		const { initTrackId, segments: appended } = snapshot.context;
+		if (!initTrackId) return "preconditions-unmet";
+		const track = findTrackById(presentation, initTrackId);
+		if (!track || !isResolvedTrack(track)) return "preconditions-unmet";
+		if (!isLastSegmentAppended(track.segments, appended)) return "preconditions-unmet";
+		if (track.segments.length > 0) {
+			const start = track.segments[track.segments.length - 1].startTime;
+			if (lastSegStart === void 0 || start > lastSegStart) lastSegStart = start;
+		}
+	}
+	if (lastSegStart !== void 0 && (currentTime ?? 0) < lastSegStart) return "preconditions-unmet";
+	return "eos-ready";
+}
+function endOfStreamSetup({ state, context }) {
+	const msIsOpen = signal(false);
+	const cleanupMsListener = effect(() => {
+		const mediaSource = context.mediaSource.get();
+		if (!mediaSource) {
+			msIsOpen.set(false);
+			return;
+		}
+		msIsOpen.set(mediaSource.readyState === "open");
+		const controller = new AbortController();
+		onMediaSourceReadyStateChange(mediaSource, controller.signal, (rs) => {
+			msIsOpen.set(rs === "open");
+		});
+		return () => controller.abort();
+	});
+	const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaSource.get(), msIsOpen.get(), context.videoBufferActor.get(), context.audioBufferActor.get(), state.currentTime.get()));
+	const reactor = createMachineReactor({
+		initial: "preconditions-unmet",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"preconditions-unmet": {},
+			"eos-ready": { entry: () => {
+				const mediaSource = context.mediaSource.get();
+				const controller = new AbortController();
+				const endStreamWhenReady = async () => {
+					await waitForSourceBuffersReady(mediaSource.sourceBuffers, controller.signal);
+					if (controller.signal.aborted) return;
+					const bufferedEnd = getMaxBufferedEnd(mediaSource.sourceBuffers);
+					if (bufferedEnd > 0) mediaSource.duration = bufferedEnd;
+					mediaSource.endOfStream();
+				};
+				endStreamWhenReady().catch((err) => console.error("Failed to call endOfStream:", err));
+				return () => controller.abort();
+			} }
+		}
+	});
+	return () => {
+		cleanupMsListener();
+		reactor.destroy();
+	};
+}
+const endOfStream = defineBehavior({
+	stateKeys: ["presentation", "currentTime"],
+	contextKeys: [
+		"mediaSource",
+		"videoBufferActor",
+		"audioBufferActor"
+	],
+	setup: endOfStreamSetup
+});
+//#endregion
+export { endOfStream };
+
+//# sourceMappingURL=end-of-stream.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"end-of-stream.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/end-of-stream.ts"],"sourcesContent":["/**\n * **Drive each `open → ended` transition of the MediaSource.** Calls\n * `MediaSource.endOfStream()` once 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"}

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

@@ -0,0 +1,62 @@
+import { ReadonlySignal } from "../../../core/signals/primitives.js";
+import { Reactor } from "../../../core/reactors/create-machine-reactor.js";
+import { MaybeResolvedPresentation } from "../../../media/types/index.js";
+import { SegmentLoaderActor } from "../../actors/dom/segment-loader.js";
+import { TextTrackSegmentLoaderActor } from "../../actors/text-track-segment-loader.js";
+
+//#region src/playback/behaviors/dom/load-segments.d.ts
+/** State shape for segment loading. */
+interface SegmentLoadingState {
+  presentation?: MaybeResolvedPresentation;
+  preload?: string;
+  /** Current playback position in seconds. Defaults to 0 when undefined. */
+  currentTime?: number;
+  /** True once a preload-overriding event has fired for the current source. */
+  loadActivated?: boolean;
+  selectedVideoTrackId?: string;
+  selectedAudioTrackId?: string;
+  selectedTextTrackId?: string;
+}
+/** Context shape for segment loading. Each variant only consumes its own type's loader actor. */
+interface SegmentLoadingContext {
+  videoSegmentLoaderActor?: SegmentLoaderActor;
+  audioSegmentLoaderActor?: SegmentLoaderActor;
+  textTrackSegmentLoaderActor?: TextTrackSegmentLoaderActor;
+}
+type SegmentLoadingFsmState = 'preconditions-unmet' | 'dormant' | 'metadata-only' | 'full-range';
+type SelectedTrackKey = 'selectedVideoTrackId' | 'selectedAudioTrackId' | 'selectedTextTrackId';
+type SegmentLoadingStateMap<K extends SelectedTrackKey> = {
+  presentation: ReadonlySignal<SegmentLoadingState['presentation']>;
+  preload: ReadonlySignal<SegmentLoadingState['preload']>;
+  currentTime: ReadonlySignal<SegmentLoadingState['currentTime']>;
+  loadActivated: ReadonlySignal<SegmentLoadingState['loadActivated']>;
+} & { [P in K]: ReadonlySignal<SegmentLoadingState[P]> };
+declare const loadVideoSegments: {
+  stateKeys: readonly ["presentation", "preload", "currentTime", "loadActivated", "selectedVideoTrackId"];
+  contextKeys: readonly ["videoSegmentLoaderActor"];
+  setup: (deps: {
+    state: SegmentLoadingStateMap<"selectedVideoTrackId">;
+  } & {
+    context: {
+      videoSegmentLoaderActor: ReadonlySignal<SegmentLoadingContext['videoSegmentLoaderActor']>;
+    };
+  } & {
+    config?: object;
+  }) => Reactor<"destroyed" | "destroying" | SegmentLoadingFsmState>;
+};
+declare const loadAudioSegments: {
+  stateKeys: readonly ["presentation", "preload", "currentTime", "loadActivated", "selectedAudioTrackId"];
+  contextKeys: readonly ["audioSegmentLoaderActor"];
+  setup: (deps: {
+    state: SegmentLoadingStateMap<"selectedAudioTrackId">;
+  } & {
+    context: {
+      audioSegmentLoaderActor: ReadonlySignal<SegmentLoadingContext['audioSegmentLoaderActor']>;
+    };
+  } & {
+    config?: object;
+  }) => Reactor<"destroyed" | "destroying" | SegmentLoadingFsmState>;
+};
+//#endregion
+export { loadAudioSegments, loadVideoSegments };
+//# sourceMappingURL=load-segments.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"load-segments.d.ts","names":[],"sources":["../../../../../src/playback/behaviors/dom/load-segments.ts"],"mappings":";;;;;;;;UAoEiB,mBAAA;EACf,YAAA,GAAe,yBAAA;EACf,OAAA;EADwC;EAGxC,WAAA;EAHe;EAKf,aAAA;EACA,oBAAA;EACA,oBAAA;EACA,mBAAA;AAAA;;UAIe,qBAAA;EACf,uBAAA,GAA0B,kBAAA;EAC1B,uBAAA,GAA0B,kBAAA;EAC1B,2BAAA,GAA8B,2BAAA;AAAA;AAAA,KAO3B,sBAAA;AAAA,KAEA,gBAAA;AAAA,KAGA,sBAAA,WAAiC,gBAAA;EACpC,YAAA,EAAc,cAAA,CAAe,mBAAA;EAC7B,OAAA,EAAS,cAAA,CAAe,mBAAA;EACxB,WAAA,EAAa,cAAA,CAAe,mBAAA;EAC5B,aAAA,EAAe,cAAA,CAAe,mBAAA;AAAA,YACpB,CAAA,GAAI,cAAA,CAAe,mBAAA,CAAoB,CAAA;AAAA,cAiItC,iBAAA;;;;;;;+BAUkB,cAAA,CAAe,qBAAA;IAAA;EAAA;;;;cAWjC,iBAAA;;;;;;;+BAUkB,cAAA,CAAe,qBAAA;IAAA;EAAA"}

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

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