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

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

@@ -0,0 +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 = {\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":";;;;;;AA+EA,SAAS,iBAAiB,UAAuC;CAC/D,MAAM,SAA0B,EAAE;AAClC,MAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,IACnC,QAAO,KAAK;EAAE,OAAO,SAAS,MAAM,EAAE;EAAE,KAAK,SAAS,IAAI,EAAE;EAAE,CAAC;AAEjE,QAAO;;AAiBT,SAAS,eACP,SACA,EAAE,YAAY,gBACkB;AAChC,QAAO,IAAI,KAAK,OAAO,eAAe;EACpC,MAAM,MAAM,YAAY;AACxB,MAAI,WAAW,QAAS,QAAO;AAC/B,QAAM,cAAc,cAAc,QAAQ,KAAK;AAG/C,SAAO;GAAE,GAAG;GAAK,aAAa,QAAQ,KAAK;GAAS,mBAAmB,QAAQ,KAAK;GAAU;GAC9F;;AAGJ,SAAS,kBACP,SACA,EAAE,YAAY,cAAc,cACI;AAChC,QAAO,IAAI,KAAK,OAAO,eAAe;EACpC,MAAM,MAAM,YAAY;AACxB,MAAI,WAAW,QAAS,QAAO;EAE/B,MAAM,EAAE,SAAS;EAMjB,MAAM,WAAW,IAAI,SAAS,QAAQ,MAAM,KAAK,IAAI,EAAE,YAAY,KAAK,UAAU,IAAI,qBAAqB;AAM3G,MAAI,EAAE,QAAQ,gBAAgB,aAC5B,YAAW;GACT,GAAG;GACH,UAAU,CACR,GAAG,UACH;IACE,IAAI,KAAK;IACT,WAAW,KAAK;IAChB,UAAU,KAAK;IACf,SAAS,KAAK;IACd,GAAI,KAAK,mBAAmB,KAAA,KAAa,EAAE,gBAAgB,KAAK,gBAAgB;IAChF,SAAS;IACV,CACF;GACD,gBAAgB,IAAI;GACrB,CAAC;AAGJ,QAAM,cAAc,cAAc,QAAQ,MAAM,WAAW;AAG3D,SAAO;GACL,GAAG;GACH,UAAU,CACR,GAAG,UACH;IACE,IAAI,KAAK;IACT,WAAW,KAAK;IAChB,UAAU,KAAK;IACf,SAAS,KAAK;IACd,GAAI,KAAK,mBAAmB,KAAA,KAAa,EAAE,gBAAgB,KAAK,gBAAgB;IACjF,CACF;GACD,gBAAgB,iBAAiB,aAAa,SAAS;GACxD;GACD;;AAGJ,SAAS,WACP,SACA,EAAE,YAAY,gBACkB;AAChC,QAAO,IAAI,KAAK,OAAO,eAAe;EACpC,MAAM,MAAM,YAAY;AACxB,MAAI,WAAW,QAAS,QAAO;AAC/B,QAAM,YAAY,cAAc,QAAQ,OAAO,QAAQ,IAAI;EAQ3D,MAAM,iBAAiB,iBAAiB,aAAa,SAAS;EAC9D,MAAM,WAAW,IAAI,SAAS,QAAQ,MAAM;GAC1C,MAAM,WAAW,EAAE,YAAY,EAAE,WAAW;AAC5C,UAAO,eAAe,MAAM,MAAM,YAAY,EAAE,SAAS,WAAW,EAAE,IAAI;IAC1E;AACF,SAAO;GAAE,GAAG;GAAK,UAAU;GAAU;GAAgB;GACrD;;AAQJ,MAAM,uBAAuB;CAC3B,eAAe;CACf,kBAAkB;CAClB,QAAQ;CACT;AAID,SAAS,cACP,SACA,SACgC;CAChC,MAAM,UAAU,qBAAqB,QAAQ;AAC7C,QAAO,QAAQ,SAAS,QAAQ;;AAOlC,SAAgB,wBACd,cACA,gBACmB;CAGnB,MAAM,eAAe,MAAqB;AACxC,MAAI,EAAE,aAAa,SAAS,EAAE,SAAS,cACrC,SAAQ,MAAM,kCAAkC,EAAE;;CAMtD,MAAM,aAAa,KAAoC,EAAE,YAAY,YAAY,YAAY,aAAwB;AACnH,aAAW,WAAW;EACtB,MAAM,OAAO,cAAc,KAAK;GAAE;GAAY;GAAc;GAAY,CAAC;AACzE,SAAO,SAAS,KAAK,CAAC,KAAK,YAAY,YAAY;;AAGrD,QAAO,mBAAiG;EACtG,cAAc,IAAI,cAAc;EAChC,SAAS;EACT,SAAS;GAAE,UAAU,EAAE;GAAE,gBAAgB,EAAE;GAAE,aAAa,KAAA;GAAW,GAAG;GAAgB;EACxF,QAAQ;GACN,MAAM,EACJ,IAAI;IACF,eAAe;IACf,kBAAkB;IAClB,QAAQ;IACR,QAAQ,KAAK,EAAE,YAAY,YAAY,YAAY,aAAa;KAC9D,MAAM,EAAE,aAAa;AACrB,SAAI,SAAS,WAAW,EAAG;AAE3B,gBAAW,WAAW;AACtB,cAAS,SAAS,QAAQ;MACxB,MAAM,OAAO,cAAc,KAAK;OAAE;OAAY;OAAc;OAAY,CAAC;AACzE,aAAO,SAAS,KAAK,CAAC,KAAK,YAAY,YAAY;OACnD;;IAEL,EACF;GACD,UAAU;IAER,WAAW;IACX,IAAI,EAGF,SAAS,GAAG,EAAE,aAAa;AACzB,YAAO,UAAU;OAEpB;IACF;GACF;EACF,CAAC"}

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

@@ -0,0 +1 @@
+import { AddCuesMessage, ClearMessage, CueSegmentMeta, TextTracksActor, TextTracksActorContext, TextTracksActorMessage } from "../text-tracks.js";

package/dist/{default/dom/features/text-tracks-actor.js → dev/playback/actors/dom/text-tracks.js}

@@ -1,5 +1,5 @@
-import { createTransitionActor } from "../../core/create-transition-actor.js";
-//#region src/dom/features/text-tracks-actor.ts
+import { createTransitionActor } from "../../../core/actors/create-transition-actor.js";
+//#region src/playback/actors/dom/text-tracks.ts
 function isDuplicateCue(cue, existing) {
 	return existing.some((r) => r.startTime === cue.startTime && r.endTime === cue.endTime && r.text === cue.text);
 }
@@ -9,6 +9,10 @@ function createTextTracksActor(mediaElement) {
 		loaded: {},
 		segments: {}
 	}, (context, message) => {
+		if (message.type === "clear") return {
+			loaded: {},
+			segments: {}
+		};
 		const { meta, cues } = message;
 		const { trackId, id: segmentId, startTime, duration } = meta;
 		const textTrack = Array.from(mediaElement.textTracks).find((t) => t.id === trackId);
@@ -39,4 +43,4 @@ function createTextTracksActor(mediaElement) {
 //#endregion
 export { createTextTracksActor };
 
-//# sourceMappingURL=text-tracks-actor.js.map
+//# sourceMappingURL=text-tracks.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-tracks.js","names":[],"sources":["../../../../../src/playback/actors/dom/text-tracks.ts"],"sourcesContent":["import { createTransitionActor } from '../../../core/actors/create-transition-actor';\nimport type { Cue } from '../../../media/types';\nimport type {\n  AddCuesMessage,\n  ClearMessage,\n  CueSegmentMeta,\n  TextTracksActor,\n  TextTracksActorContext,\n  TextTracksActorMessage,\n} from '../text-tracks';\n\n// Re-export the host-agnostic types so existing dom-side consumers can keep\n// importing from this module.\nexport type {\n  AddCuesMessage,\n  ClearMessage,\n  CueSegmentMeta,\n  TextTracksActor,\n  TextTracksActorContext,\n  TextTracksActorMessage,\n};\n\n// =============================================================================\n// Helpers\n// =============================================================================\n\nfunction isDuplicateCue(cue: VTTCue, existing: Cue[]): boolean {\n  return existing.some((r) => r.startTime === cue.startTime && r.endTime === cue.endTime && r.text === cue.text);\n}\n\n// =============================================================================\n// Implementation\n// =============================================================================\n\n/** TextTrack actor: wraps all text tracks on a media element, owns cue operations. */\nexport function createTextTracksActor(mediaElement: HTMLMediaElement): TextTracksActor<VTTCue> {\n  return createTransitionActor({ loaded: {}, segments: {} } as TextTracksActorContext, (context, message) => {\n    if (message.type === 'clear') {\n      // Reset the cue + segment cache. DOM cleanup is the caller's job —\n      // by the time we get here, `syncTextTracks` has already removed\n      // the `<track>` children (and their cues) via\n      // `removeAllSubtitlesTracksFromMedia`.\n      return { loaded: {}, segments: {} };\n    }\n\n    // NOTE: Currently assumes cues are applied to a non-disabled TextTrack. Discuss different approaches here, including:\n    // - Making the message responsible for auto-selection of the textTrack (changes logic in sync-text-tracks)\n    // - Silent gating/console warning + early bail\n    // - throwing a domain-specific error\n    // - accepting as is (which would result in errors, but also \"shouldn't ever happen\" unless a bug is introduced)\n    // (CJP)\n    const { meta, cues } = message;\n    const { trackId, id: segmentId, startTime, duration } = meta;\n    const textTrack = Array.from(mediaElement.textTracks).find((t) => t.id === trackId);\n    if (!textTrack) return context;\n\n    const existingCues = context.loaded[trackId] ?? [];\n    const existingSegments = context.segments[trackId] ?? [];\n    const prunedCues = cues.filter((cue) => !isDuplicateCue(cue, existingCues));\n    const segmentAlreadyLoaded = existingSegments.some((s) => s.id === segmentId);\n\n    if (prunedCues.length === 0 && segmentAlreadyLoaded) return context;\n\n    for (const cue of prunedCues) textTrack.addCue(cue);\n    return {\n      ...context,\n      loaded: {\n        ...context.loaded,\n        [trackId]: [...existingCues, ...prunedCues],\n      },\n      segments: segmentAlreadyLoaded\n        ? context.segments\n        : {\n            ...context.segments,\n            [trackId]: [...existingSegments, { id: segmentId, startTime, duration }],\n          },\n    };\n  });\n}\n"],"mappings":";;AA0BA,SAAS,eAAe,KAAa,UAA0B;AAC7D,QAAO,SAAS,MAAM,MAAM,EAAE,cAAc,IAAI,aAAa,EAAE,YAAY,IAAI,WAAW,EAAE,SAAS,IAAI,KAAK;;;AAQhH,SAAgB,sBAAsB,cAAyD;AAC7F,QAAO,sBAAsB;EAAE,QAAQ,EAAE;EAAE,UAAU,EAAE;EAAE,GAA6B,SAAS,YAAY;AACzG,MAAI,QAAQ,SAAS,QAKnB,QAAO;GAAE,QAAQ,EAAE;GAAE,UAAU,EAAE;GAAE;EASrC,MAAM,EAAE,MAAM,SAAS;EACvB,MAAM,EAAE,SAAS,IAAI,WAAW,WAAW,aAAa;EACxD,MAAM,YAAY,MAAM,KAAK,aAAa,WAAW,CAAC,MAAM,MAAM,EAAE,OAAO,QAAQ;AACnF,MAAI,CAAC,UAAW,QAAO;EAEvB,MAAM,eAAe,QAAQ,OAAO,YAAY,EAAE;EAClD,MAAM,mBAAmB,QAAQ,SAAS,YAAY,EAAE;EACxD,MAAM,aAAa,KAAK,QAAQ,QAAQ,CAAC,eAAe,KAAK,aAAa,CAAC;EAC3E,MAAM,uBAAuB,iBAAiB,MAAM,MAAM,EAAE,OAAO,UAAU;AAE7E,MAAI,WAAW,WAAW,KAAK,qBAAsB,QAAO;AAE5D,OAAK,MAAM,OAAO,WAAY,WAAU,OAAO,IAAI;AACnD,SAAO;GACL,GAAG;GACH,QAAQ;IACN,GAAG,QAAQ;KACV,UAAU,CAAC,GAAG,cAAc,GAAG,WAAW;IAC5C;GACD,UAAU,uBACN,QAAQ,WACR;IACE,GAAG,QAAQ;KACV,UAAU,CAAC,GAAG,kBAAkB;KAAE,IAAI;KAAW;KAAW;KAAU,CAAC;IACzE;GACN;GACD"}

package/dist/dev/playback/actors/text-track-segment-loader.d.ts

@@ -0,0 +1,59 @@
+import { MessageActor } from "../../core/actors/create-machine-actor.js";
+import { Cue, TextTrack } from "../../media/types/index.js";
+import { ForwardBufferConfig } from "../../media/buffer/forward-buffer.js";
+//#region src/playback/actors/text-track-segment-loader.d.ts
+/**
+ * Mirrors the v/a `SegmentLoaderMessage` shape. `range` carries the
+ * forward-window anchor (`range.start` is treated as the load anchor;
+ * the actor computes its own forward window internally via
+ * `getSegmentsToLoad`). When `range` is omitted (metadata mode), this
+ * actor is a no-op — text tracks have no init-segment concept.
+ */
+type TextTrackSegmentLoaderMessage = {
+  type: 'load';
+  track: TextTrack;
+  range?: {
+    start: number;
+    end: number;
+  };
+};
+/** Finite states of the actor. */
+type TextTrackSegmentLoaderActorState = 'idle' | 'loading' | 'destroyed';
+/** Non-finite (extended) data managed by the actor. */
+interface TextTrackSegmentLoaderActorContext {
+  /**
+   * Track ID of the segment currently being fetched, or null. Paired
+   * with `inFlightSegmentId` so the continue-vs-preempt check survives
+   * cross-track segment-id collisions (e.g. each track starts at
+   * `seg-0`).
+   */
+  inFlightTrackId: string | null;
+  /**
+   * Segment ID currently being fetched, or null. Used together with
+   * `inFlightTrackId` by the `loading` state's `load` handler.
+   */
+  inFlightSegmentId: string | null;
+}
+type TextTrackSegmentLoaderActor = MessageActor<TextTrackSegmentLoaderActorState, TextTrackSegmentLoaderActorContext, TextTrackSegmentLoaderMessage>;
+/**
+ * Resolves a text-track segment URL into the array of cues it contains.
+ *
+ * "Resolve" because the fn covers both network fetch and parse into the
+ * domain model. Host-agnostic — the concrete resolver (e.g. the
+ * browser's native VTT resolver) is supplied at engine-assembly time,
+ * so this actor stays DOM-free.
+ */
+type TextTrackSegmentResolver<C extends Cue = Cue> = (url: string) => Promise<C[]>;
+/**
+ * Configuration for `createTextTrackSegmentLoaderActor`. Spread over
+ * `DEFAULT_FORWARD_BUFFER_CONFIG` to override individual forward-window
+ * fields (e.g. `bufferDuration`). Text tracks don't have a back-buffer
+ * concern — cues evict by their playhead-relative window at runtime —
+ * so no `backBuffer` config field.
+ */
+interface TextTrackSegmentLoaderActorConfig {
+  forwardBuffer?: Partial<ForwardBufferConfig>;
+}
+//#endregion
+export { TextTrackSegmentLoaderActor, TextTrackSegmentLoaderActorConfig, TextTrackSegmentResolver };
+//# sourceMappingURL=text-track-segment-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-track-segment-loader.d.ts","names":[],"sources":["../../../../src/playback/actors/text-track-segment-loader.ts"],"mappings":";;;;;;AAsBA;;;;;KAAY,6BAAA;EACV,IAAA;EACA,KAAA,EAAO,SAAA;EACP,KAAA;IAAU,KAAA;IAAe,GAAA;EAAA;AAAA;;KAIf,gCAAA;;UAGK,kCAAA;EAAA;;;;;AAejB;EARE,eAAA;;;;;EAKA,iBAAA;AAAA;AAAA,KAGU,2BAAA,GAA8B,YAAA,CACxC,gCAAA,EACA,kCAAA,EACA,6BAAA;;;;;;;AAWF;;KAAY,wBAAA,WAAmC,GAAA,GAAM,GAAA,KAAQ,GAAA,aAAgB,OAAA,CAAQ,CAAA;;;;;;;;UASpE,iCAAA;EACf,aAAA,GAAgB,OAAA,CAAQ,mBAAA;AAAA"}

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

@@ -0,0 +1,135 @@
+import { peek } from "../../core/signals/primitives.js";
+import { SerialRunner, Task } from "../../core/tasks/task.js";
+import { createMachineActor } from "../../core/actors/create-machine-actor.js";
+import { DEFAULT_FORWARD_BUFFER_CONFIG, getSegmentsToLoad } from "../../media/buffer/forward-buffer.js";
+//#region src/playback/actors/text-track-segment-loader.ts
+/**
+* Loads text-track segments for a track and delegates cue management
+* to a TextTracksActor. Mirrors the v/a `SegmentLoaderActor` shape (FSM
+* with `idle` / `loading` and `inFlight*` context for continue-vs-preempt),
+* adapted to text:
+*
+* - No init segment, no flush ops (text cues don't need eviction — they're
+*   small and the playhead-relative window is enforced by the runtime).
+* - Single in-flight identity (`inFlightSegmentId`) — text has only the
+*   media-segment path, no init-segment path.
+*
+* Planning is done in the load handler on every incoming message:
+* `getSegmentsToLoad` filters to the forward window, then the segments
+* not already in `TextTracksActor`'s context are scheduled. When a new
+* `load` arrives mid-run, the handler replans and either:
+*
+* - **Continues**: the in-flight segment is still in the new plan →
+*   `abortPending` only, schedule the rest of the plan (minus the
+*   in-flight item, which covers its slot).
+* - **Preempts**: in-flight segment is no longer wanted (track switch,
+*   large seek out of window) → `abortAll`, schedule the new plan
+*   from scratch.
+*
+* The cue parser is injected so this factory is host-agnostic. A DOM
+* host supplies a VTT parser backed by `<track>`/`TextTrack` APIs; a
+* non-DOM host (worker, test fake, alternate runtime) supplies its own.
+*/
+function createTextTrackSegmentLoaderActor(textTracksActor, resolveSegment, config = {}) {
+	const forwardBufferConfig = {
+		...DEFAULT_FORWARD_BUFFER_CONFIG,
+		...config.forwardBuffer
+	};
+	/**
+	* Translate a load message into an ordered TextLoadTask list based on
+	* committed actor state. In-flight awareness is handled separately in
+	* the `loading` state's load handler.
+	*
+	* Metadata mode (no `range`) is a no-op for text — text tracks have
+	* no init-segment concept, so there's nothing to load until a range
+	* arrives via `'full-range'` dispatch.
+	*/
+	const planTasks = (message) => {
+		const { track, range } = message;
+		if (!range) return [];
+		const trackId = track.id;
+		const bufferedSegments = peek(textTracksActor.snapshot).context.segments[trackId] ?? [];
+		return getSegmentsToLoad(track.segments, bufferedSegments, range.start, forwardBufferConfig).map((segment) => ({
+			segment,
+			trackId
+		}));
+	};
+	/**
+	* Wraps a TextLoadTask into a Task that fetches + dispatches `add-cues`.
+	* Updates `inFlightSegmentId` around the fetch so the load handler can
+	* make accurate continue/preempt decisions.
+	*/
+	const makeLoadTask = (op, { getContext, setContext }) => {
+		return new Task(async (signal) => {
+			if (signal.aborted) return;
+			setContext({
+				...getContext(),
+				inFlightTrackId: op.trackId,
+				inFlightSegmentId: op.segment.id
+			});
+			try {
+				const cues = await resolveSegment(op.segment.url);
+				if (signal.aborted) return;
+				textTracksActor.send({
+					type: "add-cues",
+					meta: {
+						trackId: op.trackId,
+						id: op.segment.id,
+						startTime: op.segment.startTime,
+						duration: op.segment.duration
+					},
+					cues
+				});
+			} catch (error) {
+				console.error("Failed to load text-track segment:", error);
+			} finally {
+				setContext({
+					...getContext(),
+					inFlightTrackId: null,
+					inFlightSegmentId: null
+				});
+			}
+		});
+	};
+	const scheduleAll = (tasks, ctx) => {
+		for (const op of tasks) ctx.runner.schedule(makeLoadTask(op, ctx)).then(void 0, (e) => {
+			if (e instanceof Error && e.name === "AbortError") return;
+			console.error("Unexpected error in text-track segment loader:", e);
+			ctx.runner.abortPending();
+		});
+	};
+	return createMachineActor({
+		runner: () => new SerialRunner(),
+		initial: "idle",
+		context: {
+			inFlightTrackId: null,
+			inFlightSegmentId: null
+		},
+		states: {
+			idle: { on: { load: (msg, ctx) => {
+				const tasks = planTasks(msg);
+				if (tasks.length === 0) return;
+				ctx.transition("loading");
+				scheduleAll(tasks, ctx);
+			} } },
+			loading: {
+				onSettled: "idle",
+				on: { load: (msg, ctx) => {
+					const { context, runner } = ctx;
+					const tasks = planTasks(msg);
+					if (context.inFlightTrackId !== null && context.inFlightSegmentId !== null && tasks.some((t) => t.trackId === context.inFlightTrackId && t.segment.id === context.inFlightSegmentId)) {
+						runner.abortPending();
+						scheduleAll(tasks.filter((t) => !(t.trackId === context.inFlightTrackId && t.segment.id === context.inFlightSegmentId)), ctx);
+					} else {
+						runner.abortAll();
+						scheduleAll(tasks, ctx);
+					}
+				} }
+			}
+		}
+	});
+}
+//#endregion
+export { createTextTrackSegmentLoaderActor };
+
+//# sourceMappingURL=text-track-segment-loader.js.map

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,25 @@
+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;
+  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":";;;;;;;;;;;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

@@ -0,0 +1,36 @@
+import { untrack, update } from "../../core/signals/primitives.js";
+import { effect } from "../../core/signals/effect.js";
+//#region src/playback/behaviors/calculate-presentation-duration.ts
+function calculatePresentationDurationSetup({ state, config }) {
+	return effect(() => {
+		const presentation = state.presentation.get();
+		if (!presentation || presentation.duration !== void 0) return;
+		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, { duration });
+	});
+}
+/**
+* `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 };
+
+//# 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 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

@@ -0,0 +1,90 @@
+import { computed, signal } from "../../../core/signals/primitives.js";
+import { effect } from "../../../core/signals/effect.js";
+import { createMachineReactor } from "../../../core/reactors/create-machine-reactor.js";
+import { isResolvedTrack } from "../../../media/types/index.js";
+import { findTrackById } from "../../../media/utils/tracks.js";
+import { onMediaSourceReadyStateChange } from "../../../media/dom/mse/mediasource-setup.js";
+import { getMaxBufferedEnd, waitForSourceBuffersReady } from "../../../media/dom/mse/duration.js";
+import { isLastSegmentAppended } from "../../../media/dom/mse/end-of-stream.js";
+//#region src/playback/behaviors/dom/end-of-stream.ts
+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();
+	};
+}
+/**
+* `endOfStream` uses a manual `Behavior<>` literal (rather than
+* `defineBehavior`) because it reads `videoBufferActor` /
+* `audioBufferActor` defensively without declaring them in its
+* contextKeys — those slots are contributed by other behaviors and
+* compose conditionally per engine variant. The `Behavior<>` literal
+* opts out of the exhaustiveness check so the typed context shape can
+* include the optional fields used at runtime. See the comment on
+* `endOfStreamSetup`'s context param for the discipline.
+*/
+const endOfStream = {
+	stateKeys: ["presentation", "currentTime"],
+	contextKeys: ["mediaSource"],
+	setup: endOfStreamSetup
+};
+//#endregion
+export { endOfStream };
+
+//# sourceMappingURL=end-of-stream.js.map