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

package/dist/dev/playback/primitives/report-track-conditions.js

@@ -0,0 +1,86 @@
+import { getMediaPlaylistMetadata } from "../../media/types/index.js";
+import { SVTA_UNSUPPORTED_AUDIO_FORMAT, SVTA_UNSUPPORTED_DRM_SYSTEM, SVTA_UNSUPPORTED_VIDEO_FORMAT } from "../../media/errors.js";
+import { NON_FMP4_CONTAINER_MIMES } from "../../media/hls/parse-media-playlist.js";
+//#region src/playback/primitives/report-track-conditions.ts
+/**
+* The seam `resolve-track` uses to report conditions discovered in a freshly
+* parsed media playlist.
+*
+* Injected rather than baked in so `resolve-track` stays free of format and
+* policy knowledge: it parses and commits, and whatever the composition wants
+* noticed about the result is this function's business. Which conditions matter,
+* and which codes they carry, therefore vary per composition — a provider that
+* never ships MPEG-TS can drop that check, and future playlist-derived notices
+* (LL-HLS or DVR support that's partial rather than absent) attach here without
+* touching the resolver.
+*
+* Reported **per rendition, as it resolves**, which is why these are causes and
+* not verdicts: one rendition being unplayable doesn't make the source
+* unplayable. The verdict is `track-switching`'s, which reports
+* `SVTA_NO_SUPPORTED_{VIDEO,AUDIO}_TRACK` when a type's candidates actually
+* empty. Keeping the two apart is what lets a mixed source — some renditions
+* encrypted or MPEG-TS, others playable — log its causes and still play.
+*/
+/** Unsupported-format code per type; text has none — absent captions aren't a failure. */
+const UNSUPPORTED_FORMAT_CODE = {
+	video: SVTA_UNSUPPORTED_VIDEO_FORMAT,
+	audio: SVTA_UNSUPPORTED_AUDIO_FORMAT
+};
+/**
+* The types a reported cause can legitimately describe: the ones whose candidates
+* `canPlayTrack` actually prunes, via `track-switching`'s `excludeUnplayableTracks`
+* pre-pass.
+*
+* Text is outside it by design — its switching chain runs failed-CDN constraints
+* alone, because an MSE codec probe is the wrong question for a WebVTT rendition
+* (see `track-switching.ts`). So nothing prunes a text rendition, no verdict can
+* follow from one, and a cause reported against it would be an orphan: the
+* adapter's unsupported-feature substitution scans the sequence as a whole, so a
+* lone encrypted subtitle would otherwise recode an unrelated verdict — an
+* all-CDN cooldown among them — as "this engine can't play the source".
+*/
+const CAPABILITY_PRUNED_TYPES = /* @__PURE__ */ new Set(["video", "audio"]);
+/**
+* The default: report what makes a rendition unplayable *to this engine* — a
+* container MSE can't accept, or encryption with no decryption pipeline. Both
+* mirror what `canPlayTrack` prunes on, so a reported cause always has a
+* corresponding exclusion.
+*
+* A condition carries its code and its context, not copy. `data.mimeType` is
+* what preserves the specificity — the format codes cover every non-fMP4
+* container, so "which one" lives there for a consumer that wants to say, rather
+* than being flattened into an English sentence here.
+*
+* Both carry `trackType`, redundantly for the format codes (1004/1005 are
+* already per type) but not for 4008, which isn't per type — SVTA has one
+* content-protection code for both. Nothing branches on the tag: it's diagnostic
+* context, reaching a developer through the logged sequence and `error.data`,
+* which is why it goes on every condition rather than only where the code can't
+* carry it. `trackId` alongside it is what distinguishes two renditions of the
+* same type.
+*/
+function reportUnsupportedTrackConditions(track) {
+	if (!CAPABILITY_PRUNED_TYPES.has(track.type)) return [];
+	const conditions = [];
+	const data = {
+		trackType: track.type,
+		trackId: track.id
+	};
+	const formatCode = UNSUPPORTED_FORMAT_CODE[track.type];
+	if (formatCode !== void 0 && NON_FMP4_CONTAINER_MIMES.has(track.mimeType)) conditions.push({
+		code: formatCode,
+		data: {
+			...data,
+			mimeType: track.mimeType
+		}
+	});
+	if (getMediaPlaylistMetadata(track)?.encrypted) conditions.push({
+		code: SVTA_UNSUPPORTED_DRM_SYSTEM,
+		data
+	});
+	return conditions;
+}
+//#endregion
+export { reportUnsupportedTrackConditions };
+
+//# sourceMappingURL=report-track-conditions.js.map

package/dist/dev/playback/primitives/report-track-conditions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"report-track-conditions.js","names":[],"sources":["../../../../src/playback/primitives/report-track-conditions.ts"],"sourcesContent":["/**\n * The seam `resolve-track` uses to report conditions discovered in a freshly\n * parsed media playlist.\n *\n * Injected rather than baked in so `resolve-track` stays free of format and\n * policy knowledge: it parses and commits, and whatever the composition wants\n * noticed about the result is this function's business. Which conditions matter,\n * and which codes they carry, therefore vary per composition — a provider that\n * never ships MPEG-TS can drop that check, and future playlist-derived notices\n * (LL-HLS or DVR support that's partial rather than absent) attach here without\n * touching the resolver.\n *\n * Reported **per rendition, as it resolves**, which is why these are causes and\n * not verdicts: one rendition being unplayable doesn't make the source\n * unplayable. The verdict is `track-switching`'s, which reports\n * `SVTA_NO_SUPPORTED_{VIDEO,AUDIO}_TRACK` when a type's candidates actually\n * empty. Keeping the two apart is what lets a mixed source — some renditions\n * encrypted or MPEG-TS, others playable — log its causes and still play.\n */\nimport {\n  SVTA_UNSUPPORTED_AUDIO_FORMAT,\n  SVTA_UNSUPPORTED_DRM_SYSTEM,\n  SVTA_UNSUPPORTED_VIDEO_FORMAT,\n  type SvtaError,\n} from '../../media/errors';\nimport { NON_FMP4_CONTAINER_MIMES } from '../../media/hls/parse-media-playlist';\nimport { getMediaPlaylistMetadata, type ResolvedTrack, type TrackType } from '../../media/types';\n\n/**\n * Conditions worth reporting about a just-resolved track. Return an empty array\n * (or omit the seam) to report nothing.\n */\nexport type ReportUnsupportedTrackConditions = (track: ResolvedTrack) => readonly SvtaError[];\n\n/** Unsupported-format code per type; text has none — absent captions aren't a failure. */\nconst UNSUPPORTED_FORMAT_CODE: Partial<Record<TrackType, number>> = {\n  video: SVTA_UNSUPPORTED_VIDEO_FORMAT,\n  audio: SVTA_UNSUPPORTED_AUDIO_FORMAT,\n};\n\n/**\n * The types a reported cause can legitimately describe: the ones whose candidates\n * `canPlayTrack` actually prunes, via `track-switching`'s `excludeUnplayableTracks`\n * pre-pass.\n *\n * Text is outside it by design — its switching chain runs failed-CDN constraints\n * alone, because an MSE codec probe is the wrong question for a WebVTT rendition\n * (see `track-switching.ts`). So nothing prunes a text rendition, no verdict can\n * follow from one, and a cause reported against it would be an orphan: the\n * adapter's unsupported-feature substitution scans the sequence as a whole, so a\n * lone encrypted subtitle would otherwise recode an unrelated verdict — an\n * all-CDN cooldown among them — as \"this engine can't play the source\".\n */\nconst CAPABILITY_PRUNED_TYPES: ReadonlySet<TrackType> = new Set<TrackType>(['video', 'audio']);\n\n/**\n * The default: report what makes a rendition unplayable *to this engine* — a\n * container MSE can't accept, or encryption with no decryption pipeline. Both\n * mirror what `canPlayTrack` prunes on, so a reported cause always has a\n * corresponding exclusion.\n *\n * A condition carries its code and its context, not copy. `data.mimeType` is\n * what preserves the specificity — the format codes cover every non-fMP4\n * container, so \"which one\" lives there for a consumer that wants to say, rather\n * than being flattened into an English sentence here.\n *\n * Both carry `trackType`, redundantly for the format codes (1004/1005 are\n * already per type) but not for 4008, which isn't per type — SVTA has one\n * content-protection code for both. Nothing branches on the tag: it's diagnostic\n * context, reaching a developer through the logged sequence and `error.data`,\n * which is why it goes on every condition rather than only where the code can't\n * carry it. `trackId` alongside it is what distinguishes two renditions of the\n * same type.\n */\nexport function reportUnsupportedTrackConditions(track: ResolvedTrack): readonly SvtaError[] {\n  if (!CAPABILITY_PRUNED_TYPES.has(track.type)) return [];\n\n  const conditions: SvtaError[] = [];\n  const data = { trackType: track.type, trackId: track.id };\n\n  const formatCode = UNSUPPORTED_FORMAT_CODE[track.type];\n  if (formatCode !== undefined && NON_FMP4_CONTAINER_MIMES.has(track.mimeType)) {\n    conditions.push({ code: formatCode, data: { ...data, mimeType: track.mimeType } });\n  }\n  if (getMediaPlaylistMetadata(track)?.encrypted) {\n    conditions.push({ code: SVTA_UNSUPPORTED_DRM_SYSTEM, data });\n  }\n  return conditions;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAmCA,MAAM,0BAA8D;CAClE,OAAO;CACP,OAAO;AACT;;;;;;;;;;;;;;AAeA,MAAM,0CAAkD,IAAI,IAAe,CAAC,SAAS,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;AAqB7F,SAAgB,iCAAiC,OAA4C;CAC3F,IAAI,CAAC,wBAAwB,IAAI,MAAM,IAAI,GAAG,OAAO,CAAC;CAEtD,MAAM,aAA0B,CAAC;CACjC,MAAM,OAAO;EAAE,WAAW,MAAM;EAAM,SAAS,MAAM;CAAG;CAExD,MAAM,aAAa,wBAAwB,MAAM;CACjD,IAAI,eAAe,KAAA,KAAa,yBAAyB,IAAI,MAAM,QAAQ,GACzE,WAAW,KAAK;EAAE,MAAM;EAAY,MAAM;GAAE,GAAG;GAAM,UAAU,MAAM;EAAS;CAAE,CAAC;CAEnF,IAAI,yBAAyB,KAAK,CAAC,EAAE,WACnC,WAAW,KAAK;EAAE,MAAM;EAA6B;CAAK,CAAC;CAE7D,OAAO;AACT"}

package/dist/dev/playback/primitives/segment-load-pipeline.d.ts

@@ -0,0 +1,2 @@
+import "../../core/signals/primitives.js";
+import "../../core/composition/create-composition.js";

package/dist/dev/playback/primitives/segment-load-pipeline.js

@@ -0,0 +1,96 @@
+import { effect } from "../../core/signals/effect.js";
+//#region src/playback/primitives/segment-load-pipeline.ts
+/**
+* Base-step view of the loader's own wiring. `createSegmentLoaderActor` folds its
+* `sourceBufferActor` + `fetch` into the threaded `config` so base steps read them
+* from the uniform passthrough — present whether the loader runs inside a composition
+* or standalone. `config` is loose (`object`), so assert the shape here (one cast, like
+* relocation's `containerSlot`).
+*/
+function stepWiring(deps) {
+	return deps.config;
+}
+/**
+* Resolves when the SourceBufferActor snapshot reaches 'idle'.
+* Rejects if the signal is aborted or the actor is destroyed.
+*
+* Used to sequence SourceBufferActor operations without awaiting send()
+* directly — send() is fire-and-forget; callers observe completion via
+* state transition.
+*/
+function waitForIdle(snapshot, signal) {
+	return new Promise((resolve, reject) => {
+		if (snapshot.get().value === "idle") {
+			resolve();
+			return;
+		}
+		if (snapshot.get().value === "destroyed") {
+			reject(new DOMException("Aborted", "AbortError"));
+			return;
+		}
+		if (signal.aborted) {
+			reject(signal.reason);
+			return;
+		}
+		let stop;
+		const cleanup = (fn) => {
+			stop?.();
+			signal.removeEventListener("abort", onAbort);
+			fn();
+		};
+		const onAbort = () => cleanup(() => reject(signal.reason));
+		stop = effect(() => {
+			const value = snapshot.get().value;
+			if (value === "idle") cleanup(resolve);
+			else if (value === "destroyed") cleanup(() => reject(new DOMException("Aborted", "AbortError")));
+		});
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/** Build the SourceBuffer message a completed frame dispatches. `fetchStep` always precedes `dispatchStep` in append pipelines, so `data` is set by now. */
+function toMessage({ op, data, meta }) {
+	switch (op.type) {
+		case "remove": return op;
+		case "append-init": return {
+			type: "append-init",
+			data,
+			meta: op.meta
+		};
+		case "append-segment": return {
+			type: "append-segment",
+			data,
+			meta: meta ?? op.meta
+		};
+	}
+}
+/**
+* Fetch this op's bytes into the frame. Init segments need the full body
+* (`minChunkSize: Infinity`) before appending; media segments stream so chunks
+* append as they arrive. Awaiting headers eagerly also starts the HTTP
+* connection (and records the fetch in observers like tests).
+*/
+const fetchStep = async (frame, signal, deps) => {
+	const { op } = frame;
+	if (op.type === "remove") return;
+	const { fetch } = stepWiring(deps);
+	frame.data = await fetch(op, op.type === "append-init" ? {
+		signal,
+		minChunkSize: Infinity
+	} : { signal });
+};
+/** Dispatch the frame's message to the SourceBufferActor and await its return to idle. */
+const dispatchStep = async (frame, signal, deps) => {
+	const { sourceBufferActor } = stepWiring(deps);
+	sourceBufferActor.send(toMessage(frame));
+	await waitForIdle(sourceBufferActor.snapshot, signal);
+};
+/** Tier 0 default: fetch (for ops that carry bytes) then dispatch. No relocation vocabulary. */
+const DEFAULT_MESSAGE_PIPELINES = () => ({
+	remove: [dispatchStep],
+	"append-init": [fetchStep, dispatchStep],
+	"append-segment": [fetchStep, dispatchStep]
+});
+//#endregion
+export { DEFAULT_MESSAGE_PIPELINES, dispatchStep, fetchStep };
+
+//# sourceMappingURL=segment-load-pipeline.js.map

package/dist/dev/playback/primitives/segment-load-pipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment-load-pipeline.js","names":[],"sources":["../../../../src/playback/primitives/segment-load-pipeline.ts"],"sourcesContent":["/**\n * The v/a segment **load pipeline** — the step vocabulary and base steps a segment\n * loader runs, extracted from the loader actor so the \"what\" (the composable steps)\n * is separable from the \"how\" (the actor's scheduling). A pipeline is a per-op list\n * of {@link LoadStep}s the loader drains in order; the default is `fetch → dispatch`,\n * and a composition can insert its own steps between them (e.g. non-zero-PTS\n * relocation) without the loader knowing.\n *\n * The base steps reach their SourceBuffer sink through the structural {@link AppendSink}\n * seam rather than the concrete actor type — the loader folds the real actor into\n * `config` at construction, and it satisfies the seam by structure — so this module\n * carries no dependency on the actor implementation, and no dependency on the DOM.\n */\nimport type { AnySlotMap } from '../../core/composition/create-composition';\nimport { effect } from '../../core/signals/effect';\nimport type { ReadonlySignal } from '../../core/signals/primitives';\nimport type { AddressableObject } from '../../media/types';\nimport type {\n  AppendInitMessage,\n  AppendSegmentMessage,\n  IndividualSourceBufferMessage,\n  RemoveMessage,\n} from './source-buffer-messages';\n\n// ============================================================================\n// SINK SEAM\n// ============================================================================\n\n/**\n * The structural view of a SourceBuffer sink the base steps use — just the ops\n * {@link dispatchStep} needs (`send` + a `snapshot` to await idle). The concrete\n * `SourceBufferActor` satisfies it by structure, so the pipeline names no actor.\n */\nexport interface AppendSink {\n  send(message: IndividualSourceBufferMessage): void;\n  snapshot: ReadonlySignal<{ value: string }>;\n}\n\n// ============================================================================\n// STEP MODEL\n// ============================================================================\n\n/**\n * A LoadTask is the intent to perform one unit of SegmentLoader work.\n * Unlike SourceBufferMessage, fetch-based tasks carry a URL rather than\n * pre-fetched data — the runner fetches and appends them in sequence.\n *\n * Derived from SourceBufferMessage types by removing `data` and adding\n * a fetch URL via AddressableObject.\n *\n * @todo Rename — \"LoadTask\" risks confusion with the `Task` class used for\n * SourceBufferActor scheduling. These are closer to operation descriptors or\n * messages than tasks in that sense.\n */\nexport type LoadTask =\n  | (Omit<AppendInitMessage, 'data'> & AddressableObject)\n  | (Omit<AppendSegmentMessage, 'data'> & AddressableObject)\n  | RemoveMessage;\n\n/**\n * A {@link LoadTask} mid-reassembly into its append message. `LoadTask` is a\n * message with `data` omitted and a URL added; the pipeline reverses that —\n * `fetchStep` produces `data`, `dispatchStep` reassembles the message. `data` is\n * the omitted payload (kept as the fetched stream — the loader never produces the\n * `ArrayBuffer` arm of `SegmentData` — widened back at dispatch). `meta` overrides\n * `op.meta` for `append-segment` (e.g. a stamped `timestampOffset`); an\n * `append-init` dispatches `op.meta` directly.\n */\nexport interface Frame {\n  readonly op: LoadTask;\n  data?: AsyncIterable<Uint8Array>;\n  meta?: AppendSegmentMessage['meta'];\n}\n\n/**\n * One stage of a message pipeline. Mutates the {@link Frame} in place and may be\n * async; the runner checks `signal.aborted` before each step and passes the\n * actor's {@link StepDeps} on every call, so a stateless step (e.g.\n * {@link fetchStep}) is a plain value, and a step that needs composition signals\n * (relocation's discover/stamp) reads them from `deps` at call time.\n */\nexport type LoadStep = (frame: Frame, signal: AbortSignal, deps: StepDeps) => void | Promise<void>;\n\n/**\n * The uniform passthrough handed to every {@link LoadStep} on every call — the\n * composition triple, nothing more. `state`/`context` are the full composition signal\n * maps; `config` is the threaded config with the loader's own wiring folded in (see\n * {@link stepWiring} + `createSegmentLoaderActor`). All three are typed loose: the\n * loader is a conduit and never reads them; a step asserts the slots it knows are\n * present (composition steps read `state`; base steps read the folded wiring off\n * `config`).\n */\nexport interface StepDeps {\n  state: AnySlotMap;\n  context: AnySlotMap;\n  config: object;\n}\n\n/**\n * Base-step view of the loader's own wiring. `createSegmentLoaderActor` folds its\n * `sourceBufferActor` + `fetch` into the threaded `config` so base steps read them\n * from the uniform passthrough — present whether the loader runs inside a composition\n * or standalone. `config` is loose (`object`), so assert the shape here (one cast, like\n * relocation's `containerSlot`).\n */\nfunction stepWiring(deps: StepDeps): { sourceBufferActor: AppendSink; fetch: FetchBytes } {\n  return deps.config as { sourceBufferActor: AppendSink; fetch: FetchBytes };\n}\n\n/**\n * Builds the ordered step list for each message type. Called **once per actor**\n * — its role is per-actor instantiation, so stateful steps (relocation's origin\n * discoverer) get fresh state per source reset; deps arrive at step-call time,\n * not here. The default ({@link DEFAULT_MESSAGE_PIPELINES}) is `fetch → dispatch`;\n * a non-zero-PTS composition returns a map that inserts its own discover/stamp\n * steps between them (see `establishStartMediaTime`), so the loader stays oblivious\n * to relocation and the Tier 0 pipeline carries no relocation vocabulary at all.\n */\nexport type MessagePipelines = () => Record<LoadTask['type'], LoadStep[]>;\n\n// ============================================================================\n// BASE STEPS\n// ============================================================================\n\nexport type FetchBytes = (\n  addressable: AddressableObject,\n  options?: RequestInit & { minChunkSize?: number }\n) => Promise<AsyncIterable<Uint8Array>>;\n\n/**\n * Resolves when the SourceBufferActor snapshot reaches 'idle'.\n * Rejects if the signal is aborted or the actor is destroyed.\n *\n * Used to sequence SourceBufferActor operations without awaiting send()\n * directly — send() is fire-and-forget; callers observe completion via\n * state transition.\n */\nfunction waitForIdle(snapshot: AppendSink['snapshot'], signal: AbortSignal): Promise<void> {\n  return new Promise((resolve, reject) => {\n    if (snapshot.get().value === 'idle') {\n      resolve();\n      return;\n    }\n    if (snapshot.get().value === 'destroyed') {\n      reject(new DOMException('Aborted', 'AbortError'));\n      return;\n    }\n    if (signal.aborted) {\n      reject(signal.reason);\n      return;\n    }\n\n    let stop: (() => void) | undefined;\n\n    const cleanup = (fn: () => void) => {\n      stop?.();\n      signal.removeEventListener('abort', onAbort);\n      fn();\n    };\n\n    const onAbort = () => cleanup(() => reject(signal.reason));\n\n    stop = effect(() => {\n      const value = snapshot.get().value;\n      if (value === 'idle') cleanup(resolve);\n      else if (value === 'destroyed') cleanup(() => reject(new DOMException('Aborted', 'AbortError')));\n    });\n\n    signal.addEventListener('abort', onAbort, { once: true });\n  });\n}\n\n/** Build the SourceBuffer message a completed frame dispatches. `fetchStep` always precedes `dispatchStep` in append pipelines, so `data` is set by now. */\nfunction toMessage({ op, data, meta }: Frame): IndividualSourceBufferMessage {\n  switch (op.type) {\n    case 'remove':\n      return op;\n    case 'append-init':\n      return { type: 'append-init', data: data!, meta: op.meta };\n    case 'append-segment':\n      return { type: 'append-segment', data: data!, meta: meta ?? op.meta };\n  }\n}\n\n/**\n * Fetch this op's bytes into the frame. Init segments need the full body\n * (`minChunkSize: Infinity`) before appending; media segments stream so chunks\n * append as they arrive. Awaiting headers eagerly also starts the HTTP\n * connection (and records the fetch in observers like tests).\n */\nexport const fetchStep: LoadStep = async (frame, signal, deps) => {\n  const { op } = frame;\n  if (op.type === 'remove') return; // fetchStep only appears in append pipelines\n  const { fetch } = stepWiring(deps);\n  frame.data = await fetch(op, op.type === 'append-init' ? { signal, minChunkSize: Infinity } : { signal });\n};\n\n/** Dispatch the frame's message to the SourceBufferActor and await its return to idle. */\nexport const dispatchStep: LoadStep = async (frame, signal, deps) => {\n  const { sourceBufferActor } = stepWiring(deps);\n  sourceBufferActor.send(toMessage(frame));\n  await waitForIdle(sourceBufferActor.snapshot, signal);\n};\n\n/** Tier 0 default: fetch (for ops that carry bytes) then dispatch. No relocation vocabulary. */\nexport const DEFAULT_MESSAGE_PIPELINES: MessagePipelines = () => ({\n  remove: [dispatchStep],\n  'append-init': [fetchStep, dispatchStep],\n  'append-segment': [fetchStep, dispatchStep],\n});\n"],"mappings":";;;;;;;;;AAyGA,SAAS,WAAW,MAAsE;CACxF,OAAO,KAAK;AACd;;;;;;;;;AA8BA,SAAS,YAAY,UAAkC,QAAoC;CACzF,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,IAAI,SAAS,IAAI,CAAC,CAAC,UAAU,QAAQ;GACnC,QAAQ;GACR;EACF;EACA,IAAI,SAAS,IAAI,CAAC,CAAC,UAAU,aAAa;GACxC,OAAO,IAAI,aAAa,WAAW,YAAY,CAAC;GAChD;EACF;EACA,IAAI,OAAO,SAAS;GAClB,OAAO,OAAO,MAAM;GACpB;EACF;EAEA,IAAI;EAEJ,MAAM,WAAW,OAAmB;GAClC,OAAO;GACP,OAAO,oBAAoB,SAAS,OAAO;GAC3C,GAAG;EACL;EAEA,MAAM,gBAAgB,cAAc,OAAO,OAAO,MAAM,CAAC;EAEzD,OAAO,aAAa;GAClB,MAAM,QAAQ,SAAS,IAAI,CAAC,CAAC;GAC7B,IAAI,UAAU,QAAQ,QAAQ,OAAO;QAChC,IAAI,UAAU,aAAa,cAAc,OAAO,IAAI,aAAa,WAAW,YAAY,CAAC,CAAC;EACjG,CAAC;EAED,OAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;CAC1D,CAAC;AACH;;AAGA,SAAS,UAAU,EAAE,IAAI,MAAM,QAA8C;CAC3E,QAAQ,GAAG,MAAX;EACE,KAAK,UACH,OAAO;EACT,KAAK,eACH,OAAO;GAAE,MAAM;GAAqB;GAAO,MAAM,GAAG;EAAK;EAC3D,KAAK,kBACH,OAAO;GAAE,MAAM;GAAwB;GAAO,MAAM,QAAQ,GAAG;EAAK;CACxE;AACF;;;;;;;AAQA,MAAa,YAAsB,OAAO,OAAO,QAAQ,SAAS;CAChE,MAAM,EAAE,OAAO;CACf,IAAI,GAAG,SAAS,UAAU;CAC1B,MAAM,EAAE,UAAU,WAAW,IAAI;CACjC,MAAM,OAAO,MAAM,MAAM,IAAI,GAAG,SAAS,gBAAgB;EAAE;EAAQ,cAAc;CAAS,IAAI,EAAE,OAAO,CAAC;AAC1G;;AAGA,MAAa,eAAyB,OAAO,OAAO,QAAQ,SAAS;CACnE,MAAM,EAAE,sBAAsB,WAAW,IAAI;CAC7C,kBAAkB,KAAK,UAAU,KAAK,CAAC;CACvC,MAAM,YAAY,kBAAkB,UAAU,MAAM;AACtD;;AAGA,MAAa,mCAAqD;CAChE,QAAQ,CAAC,YAAY;CACrB,eAAe,CAAC,WAAW,YAAY;CACvC,kBAAkB,CAAC,WAAW,YAAY;AAC5C"}

package/dist/dev/playback/primitives/source-buffer-messages.d.ts

@@ -0,0 +1,43 @@
+import { Segment, SegmentData, Track } from "../../media/types/index.js";
+//#region src/playback/primitives/source-buffer-messages.d.ts
+type AppendSegmentMeta = Pick<Segment, 'id' | 'startTime' | 'duration'> & {
+  trackId: Track['id'];
+  /** Declared track bandwidth in bps (from playlist BANDWIDTH attribute). */
+  trackBandwidth?: number;
+  /**
+   * Non-zero-PTS relocation: when present, applied as `SourceBuffer.timestampOffset`
+   * before this append so native PTS is relocated onto a 0-based presentation
+   * timeline. A relocating composition stamps it (constant per source) onto each
+   * media segment's meta; the apply is idempotent-guarded. Absent = no relocation.
+   */
+  timestampOffset?: number;
+};
+type AppendInitMessage = {
+  type: 'append-init';
+  data: SegmentData;
+  /**
+   * `language` is captured alongside `trackId` so downstream loaders can
+   * compare the buffered track's language to the newly-selected track's
+   * language and decide whether ahead-buffer flush is warranted on track
+   * switch (see `segment-loader`'s `planTasks`). Undefined for video and
+   * for audio without explicit `LANGUAGE` attribute.
+   */
+  meta: {
+    trackId: Track['id'];
+    language?: string;
+  };
+};
+type AppendSegmentMessage = {
+  type: 'append-segment';
+  data: SegmentData;
+  meta: AppendSegmentMeta;
+};
+type RemoveMessage = {
+  type: 'remove';
+  start: number;
+  end: number;
+};
+type IndividualSourceBufferMessage = AppendInitMessage | AppendSegmentMessage | RemoveMessage;
+//#endregion
+export { AppendInitMessage, AppendSegmentMessage, AppendSegmentMeta, IndividualSourceBufferMessage, RemoveMessage };
+//# sourceMappingURL=source-buffer-messages.d.ts.map

package/dist/dev/playback/primitives/source-buffer-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-buffer-messages.d.ts","names":[],"sources":["../../../../src/playback/primitives/source-buffer-messages.ts"],"mappings":";;KAUY,oBAAoB,KAAK;EACnC,SAAS;;EAET;;;;;;;EAOA;;KAGU;EACV;EACA,MAAM;;;;;;;;EAQN;IAAQ,SAAS;IAAa;;;KAEpB;EAAyB;EAAwB,MAAM;EAAa,MAAM;;KAC1E;EAAkB;EAAgB;EAAe;;KACjD,gCAAgC,oBAAoB,uBAAuB"}

package/dist/dev/playback/primitives/text-segment-load-pipeline.d.ts

@@ -0,0 +1,65 @@
+import { Cue, Segment } from "../../media/types/index.js";
+import { AnySlotMap } from "../../core/composition/create-composition.js";
+//#region src/playback/primitives/text-segment-load-pipeline.d.ts
+/**
+ * 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 stays DOM-free. A pure `url → cues` primitive (the text
+ * analog of the v/a loader's `fetchBytes`); composition-awareness lives in
+ * the injected {@link TextLoadStep}s, not here.
+ */
+type TextTrackSegmentResolver<C extends Cue = Cue> = (url: string) => Promise<C[]>;
+/** Internal load-task descriptor — one segment fetch + dispatch unit. */
+interface TextLoadTask {
+  segment: Segment;
+  trackId: string;
+}
+/**
+ * A text load in mid-pipeline — the text analog of the v/a loader's `Frame`.
+ * `resolveCuesStep` fills `cues`; `dispatchCuesStep` sends them. `metadata` is
+ * opaque header metadata a resolve step may attach for a later step to read
+ * (e.g. relocation stashes the `X-TIMESTAMP-MAP` correlation here for its rebase
+ * step). Typed `unknown` so the generic loader stays host-agnostic — the step
+ * that reads it knows its concrete shape (mirrors `StepDeps.state`).
+ */
+interface TextFrame<C extends Cue = Cue> {
+  readonly op: TextLoadTask;
+  cues?: C[];
+  metadata?: unknown;
+}
+/**
+ * One stage of a text message pipeline — the text analog of the v/a loader's
+ * `LoadStep`. Mutates the {@link TextFrame} in place and may be async; the runner
+ * checks `signal.aborted` before each step and passes the actor's
+ * {@link TextStepDeps} on every call, so a stateless step (`resolveCuesStep`) is a
+ * plain value and a step that needs composition signals (relocation's cue rebase)
+ * reads them from `deps` at call time.
+ */
+type TextLoadStep<C extends Cue = Cue> = (frame: TextFrame<C>, signal: AbortSignal, deps: TextStepDeps) => void | Promise<void>;
+/**
+ * The uniform passthrough handed to each {@link TextLoadStep} — the composition triple,
+ * the text analog of `StepDeps`. `state`/`context` are the composition signal maps;
+ * `config` is the threaded config with the loader's wiring folded in (see
+ * {@link textStepWiring} + `createTextTrackSegmentLoaderActor`). Typed loose: composition
+ * steps read `state`; base steps read the folded wiring off `config`.
+ */
+interface TextStepDeps {
+  state: AnySlotMap;
+  context: AnySlotMap;
+  config: object;
+}
+/**
+ * Builds the ordered step list, called **once per actor** (mirrors the v/a loader's
+ * `MessagePipelines`, but text has a single op type so it's a flat array, not a
+ * `Record`). The default ({@link DEFAULT_TEXT_MESSAGE_PIPELINES}) is
+ * `resolveCues → dispatchCues`; a non-zero-PTS composition returns a list that
+ * inserts a cue-rebase step (see `relocatingTextPipelines`), so the loader stays
+ * oblivious to relocation.
+ */
+type TextMessagePipelines<C extends Cue = Cue> = () => TextLoadStep<C>[];
+//#endregion
+export { TextFrame, TextLoadStep, TextLoadTask, TextMessagePipelines, TextStepDeps, TextTrackSegmentResolver };
+//# sourceMappingURL=text-segment-load-pipeline.d.ts.map

package/dist/dev/playback/primitives/text-segment-load-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-segment-load-pipeline.d.ts","names":[],"sources":["../../../../src/playback/primitives/text-segment-load-pipeline.ts"],"mappings":";;;;;;;;;;;;;KA6CY,yBAAyB,UAAU,MAAM,QAAQ,gBAAgB,QAAQ;;UAGpE;EACf,SAAS;EACT;;;;;;;;;;UAWe,UAAU,UAAU,MAAM;WAChC,IAAI;EACb,OAAO;EACP;;;;;;;;;;KAWU,aAAa,UAAU,MAAM,QACvC,OAAO,UAAU,IACjB,QAAQ,aACR,MAAM,wBACI;;;;;;;;UASK;EACf,OAAO;EACP,SAAS;EACT;;;;;;;;;;KAwBU,qBAAqB,UAAU,MAAM,aAAa,aAAa"}

package/dist/dev/playback/primitives/text-segment-load-pipeline.js

@@ -0,0 +1,37 @@
+//#region src/playback/primitives/text-segment-load-pipeline.ts
+/**
+* Base-step view of the loader's wiring, folded into `config` by
+* `createTextTrackSegmentLoaderActor` so base steps read it from the uniform passthrough
+* — present in both composition and standalone use. `config` is loose (`object`), so
+* assert the shape here (mirrors the v/a loader's `stepWiring`). The sink is the
+* structural {@link CueSink}, not the concrete actor.
+*/
+function textStepWiring(deps) {
+	return deps.config;
+}
+/** Resolve the op's cues (via the injected host primitive) into the frame. The text analog of `fetchStep`. */
+const resolveCuesStep = async (frame, signal, deps) => {
+	const cues = await textStepWiring(deps).resolveSegment(frame.op.segment.url);
+	if (signal.aborted) return;
+	frame.cues = cues;
+};
+/** Dispatch the frame's cues to the TextTracksActor as `add-cues`. The text analog of `dispatchStep`. */
+const dispatchCuesStep = (frame, _signal, deps) => {
+	const { op } = frame;
+	textStepWiring(deps).textTracksActor.send({
+		type: "add-cues",
+		meta: {
+			trackId: op.trackId,
+			id: op.segment.id,
+			startTime: op.segment.startTime,
+			duration: op.segment.duration
+		},
+		cues: frame.cues ?? []
+	});
+};
+/** Tier 0 default: resolve then dispatch. No relocation vocabulary. */
+const DEFAULT_TEXT_MESSAGE_PIPELINES = () => [resolveCuesStep, dispatchCuesStep];
+//#endregion
+export { DEFAULT_TEXT_MESSAGE_PIPELINES, dispatchCuesStep, resolveCuesStep, textStepWiring };
+
+//# sourceMappingURL=text-segment-load-pipeline.js.map

package/dist/dev/playback/primitives/text-segment-load-pipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-segment-load-pipeline.js","names":[],"sources":["../../../../src/playback/primitives/text-segment-load-pipeline.ts"],"sourcesContent":["/**\n * The text-track **load pipeline** — the step vocabulary and base steps a text-segment\n * loader runs, the text mirror of `segment-load-pipeline`. Extracted from the loader\n * actor so the \"what\" (the composable steps) is separable from the \"how\" (scheduling).\n * A pipeline is a flat, ordered list of {@link TextLoadStep}s (text has a single op\n * type, so no per-type `Record`); the default is `resolveCues → dispatchCues`, and a\n * composition can insert its own steps (e.g. non-zero-PTS cue rebase) without the\n * loader knowing.\n *\n * The dispatch step reaches its cue sink through the structural {@link CueSink} seam\n * rather than the concrete `TextTracksActor` type — the loader folds the real actor\n * into `config`, and it satisfies the seam by structure — so this module names no\n * actor and stays DOM-free (generic over the cue type `C`).\n */\nimport type { AnySlotMap } from '../../core/composition/create-composition';\nimport type { Cue, Segment } from '../../media/types';\nimport type { AddCuesMessage } from './text-track-messages';\n\n// ============================================================================\n// SINK SEAM\n// ============================================================================\n\n/**\n * The structural view of a cue sink the base steps use — just the `send`\n * {@link dispatchCuesStep} needs. The concrete `TextTracksActor` satisfies it by\n * structure, so the pipeline names no actor.\n */\nexport interface CueSink<C extends Cue = Cue> {\n  send(message: AddCuesMessage<C>): void;\n}\n\n// ============================================================================\n// STEP MODEL\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 stays DOM-free. A pure `url → cues` primitive (the text\n * analog of the v/a loader's `fetchBytes`); composition-awareness lives in\n * the injected {@link TextLoadStep}s, not here.\n */\nexport type TextTrackSegmentResolver<C extends Cue = Cue> = (url: string) => Promise<C[]>;\n\n/** Internal load-task descriptor — one segment fetch + dispatch unit. */\nexport interface TextLoadTask {\n  segment: Segment;\n  trackId: string;\n}\n\n/**\n * A text load in mid-pipeline — the text analog of the v/a loader's `Frame`.\n * `resolveCuesStep` fills `cues`; `dispatchCuesStep` sends them. `metadata` is\n * opaque header metadata a resolve step may attach for a later step to read\n * (e.g. relocation stashes the `X-TIMESTAMP-MAP` correlation here for its rebase\n * step). Typed `unknown` so the generic loader stays host-agnostic — the step\n * that reads it knows its concrete shape (mirrors `StepDeps.state`).\n */\nexport interface TextFrame<C extends Cue = Cue> {\n  readonly op: TextLoadTask;\n  cues?: C[];\n  metadata?: unknown;\n}\n\n/**\n * One stage of a text message pipeline — the text analog of the v/a loader's\n * `LoadStep`. Mutates the {@link TextFrame} in place and may be async; the runner\n * checks `signal.aborted` before each step and passes the actor's\n * {@link TextStepDeps} on every call, so a stateless step (`resolveCuesStep`) is a\n * plain value and a step that needs composition signals (relocation's cue rebase)\n * reads them from `deps` at call time.\n */\nexport type TextLoadStep<C extends Cue = Cue> = (\n  frame: TextFrame<C>,\n  signal: AbortSignal,\n  deps: TextStepDeps\n) => void | Promise<void>;\n\n/**\n * The uniform passthrough handed to each {@link TextLoadStep} — the composition triple,\n * the text analog of `StepDeps`. `state`/`context` are the composition signal maps;\n * `config` is the threaded config with the loader's wiring folded in (see\n * {@link textStepWiring} + `createTextTrackSegmentLoaderActor`). Typed loose: composition\n * steps read `state`; base steps read the folded wiring off `config`.\n */\nexport interface TextStepDeps {\n  state: AnySlotMap;\n  context: AnySlotMap;\n  config: object;\n}\n\n/**\n * Base-step view of the loader's wiring, folded into `config` by\n * `createTextTrackSegmentLoaderActor` so base steps read it from the uniform passthrough\n * — present in both composition and standalone use. `config` is loose (`object`), so\n * assert the shape here (mirrors the v/a loader's `stepWiring`). The sink is the\n * structural {@link CueSink}, not the concrete actor.\n */\nexport function textStepWiring<C extends Cue>(\n  deps: TextStepDeps\n): { textTracksActor: CueSink<C>; resolveSegment: TextTrackSegmentResolver<C> } {\n  return deps.config as { textTracksActor: CueSink<C>; resolveSegment: TextTrackSegmentResolver<C> };\n}\n\n/**\n * Builds the ordered step list, called **once per actor** (mirrors the v/a loader's\n * `MessagePipelines`, but text has a single op type so it's a flat array, not a\n * `Record`). The default ({@link DEFAULT_TEXT_MESSAGE_PIPELINES}) is\n * `resolveCues → dispatchCues`; a non-zero-PTS composition returns a list that\n * inserts a cue-rebase step (see `relocatingTextPipelines`), so the loader stays\n * oblivious to relocation.\n */\nexport type TextMessagePipelines<C extends Cue = Cue> = () => TextLoadStep<C>[];\n\n// ============================================================================\n// BASE STEPS\n// ============================================================================\n\n// Base steps are generic over the cue type `C` (generic arrow consts, not\n// `TextLoadStep<Cue>` values): each touches `C` — `frame.cues: C[]` and the\n// `C`-typed `textStepWiring<C>` — so a `Cue`-typed const wouldn't slot into a\n// `VTTCue` pipeline. A generic function assigns to any `TextLoadStep<C>`.\n\n/** Resolve the op's cues (via the injected host primitive) into the frame. The text analog of `fetchStep`. */\nexport const resolveCuesStep = async <C extends Cue>(\n  frame: TextFrame<C>,\n  signal: AbortSignal,\n  deps: TextStepDeps\n): Promise<void> => {\n  const cues = await textStepWiring<C>(deps).resolveSegment(frame.op.segment.url);\n  if (signal.aborted) return;\n  frame.cues = cues;\n};\n\n/** Dispatch the frame's cues to the TextTracksActor as `add-cues`. The text analog of `dispatchStep`. */\nexport const dispatchCuesStep = <C extends Cue>(\n  frame: TextFrame<C>,\n  _signal: AbortSignal,\n  deps: TextStepDeps\n): void => {\n  const { op } = frame;\n  textStepWiring<C>(deps).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: frame.cues ?? [],\n  });\n};\n\n/** Tier 0 default: resolve then dispatch. No relocation vocabulary. */\nexport const DEFAULT_TEXT_MESSAGE_PIPELINES = <C extends Cue>(): TextLoadStep<C>[] => [\n  resolveCuesStep,\n  dispatchCuesStep,\n];\n"],"mappings":";;;;;;;;AAqGA,SAAgB,eACd,MAC8E;CAC9E,OAAO,KAAK;AACd;;AAsBA,MAAa,kBAAkB,OAC7B,OACA,QACA,SACkB;CAClB,MAAM,OAAO,MAAM,eAAkB,IAAI,CAAC,CAAC,eAAe,MAAM,GAAG,QAAQ,GAAG;CAC9E,IAAI,OAAO,SAAS;CACpB,MAAM,OAAO;AACf;;AAGA,MAAa,oBACX,OACA,SACA,SACS;CACT,MAAM,EAAE,OAAO;CACf,eAAkB,IAAI,CAAC,CAAC,gBAAgB,KAAK;EAC3C,MAAM;EACN,MAAM;GACJ,SAAS,GAAG;GACZ,IAAI,GAAG,QAAQ;GACf,WAAW,GAAG,QAAQ;GACtB,UAAU,GAAG,QAAQ;EACvB;EACA,MAAM,MAAM,QAAQ,CAAC;CACvB,CAAC;AACH;;AAGA,MAAa,uCAAyE,CACpF,iBACA,gBACF"}

package/dist/dev/playback/primitives/text-track-messages.d.ts

@@ -0,0 +1,14 @@
+import { Cue, Segment } from "../../media/types/index.js";
+//#region src/playback/primitives/text-track-messages.d.ts
+/** Segment identity and timing — mirrors AppendSegmentMeta without trackId (keyed separately). */
+type CueSegmentMeta = Pick<Segment, 'id' | 'startTime' | 'duration'> & {
+  trackId: string;
+};
+interface AddCuesMessage<C extends Cue = Cue> {
+  type: 'add-cues';
+  meta: CueSegmentMeta;
+  cues: C[];
+}
+//#endregion
+export { AddCuesMessage, CueSegmentMeta };
+//# sourceMappingURL=text-track-messages.d.ts.map

package/dist/dev/playback/primitives/text-track-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-track-messages.d.ts","names":[],"sources":["../../../../src/playback/primitives/text-track-messages.ts"],"mappings":";;;KASY,iBAAiB,KAAK;EAA8C;;UAE/D,eAAe,UAAU,MAAM;EAC9C;EACA,MAAM;EACN,MAAM"}

package/dist/dev/playback/primitives/track-types.js.map

@@ -1 +1 @@
-{"version":3,"file":"track-types.js","names":[],"sources":["../../../../src/playback/primitives/track-types.ts"],"sourcesContent":["/**\n * **Per-type config bundles for per-type behavior variants.**\n *\n * Each `*_TYPE_CONFIG` constant names the per-type slot keys that\n * per-type-variant setup-shape helpers consume. Variants reference the\n * shared constant at their `defineBehavior` setup body rather than\n * constructing the config inline, so the per-type identity (which state\n * slot, which context slot, which discriminant) lives in one place per\n * type.\n *\n * Variants spread their composition-time `config` over the defaults so\n * engines can layer composition-supplied additions on top (e.g. a\n * custom fetch closure, a non-default segment resolver). Defaults\n * first, engine config second.\n *\n * Helpers continue to consume their slice via the existing typed-key\n * generics (`<K extends SelectedTrackKey>` etc.); the extra fields on\n * the config object (carrying facets other helpers care about) are fine\n * under structural typing.\n */\n\n/**\n * Type-identity bundle for video-track-typed behaviors.\n *\n * @see setupVideoBufferActors, loadVideoSegments\n */\nexport const VIDEO_TYPE_CONFIG = {\n  type: 'video',\n  selectedKey: 'selectedVideoTrackId',\n  actorKey: 'videoBufferActor',\n  loaderKey: 'videoSegmentLoaderActor',\n} as const;\n\n/**\n * Type-identity bundle for audio-track-typed behaviors.\n *\n * @see setupAudioBufferActors, loadAudioSegments\n */\nexport const AUDIO_TYPE_CONFIG = {\n  type: 'audio',\n  selectedKey: 'selectedAudioTrackId',\n  actorKey: 'audioBufferActor',\n  loaderKey: 'audioSegmentLoaderActor',\n} as const;\n\n/**\n * Type-identity bundle for text-track-typed behaviors. Text tracks have\n * no `SourceBufferActor` (MSE doesn't apply), so this bundle omits\n * `actorKey`. The `loaderKey` points at the text-track-segment-loader\n * actor (a `MessageActor` with continue-vs-preempt semantics, parallel\n * to v/a's `SegmentLoaderActor`).\n *\n * @see loadTextTrackSegments, setupTextTrackActors\n */\nexport const TEXT_TYPE_CONFIG = {\n  type: 'text',\n  selectedKey: 'selectedTextTrackId',\n  loaderKey: 'textTrackSegmentLoaderActor',\n} as const;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,oBAAoB;CAC/B,MAAM;CACN,aAAa;CACb,UAAU;CACV,WAAW;CACZ;;;;;;AAOD,MAAa,oBAAoB;CAC/B,MAAM;CACN,aAAa;CACb,UAAU;CACV,WAAW;CACZ;;;;;;;;;;AAWD,MAAa,mBAAmB;CAC9B,MAAM;CACN,aAAa;CACb,WAAW;CACZ"}
+{"version":3,"file":"track-types.js","names":[],"sources":["../../../../src/playback/primitives/track-types.ts"],"sourcesContent":["/**\n * **Per-type config bundles for per-type behavior variants.**\n *\n * Each `*_TYPE_CONFIG` constant names the per-type slot keys that\n * per-type-variant setup-shape helpers consume. Variants reference the\n * shared constant at their `defineBehavior` setup body rather than\n * constructing the config inline, so the per-type identity (which state\n * slot, which context slot, which discriminant) lives in one place per\n * type.\n *\n * Variants spread their composition-time `config` over the defaults so\n * engines can layer composition-supplied additions on top (e.g. a\n * custom fetch closure, a non-default segment resolver). Defaults\n * first, engine config second.\n *\n * Helpers continue to consume their slice via the existing typed-key\n * generics (`<K extends SelectedTrackKey>` etc.); the extra fields on\n * the config object (carrying facets other helpers care about) are fine\n * under structural typing.\n */\n\n/**\n * Type-identity bundle for video-track-typed behaviors.\n *\n * @see setupVideoBufferActors, loadVideoSegments\n */\nexport const VIDEO_TYPE_CONFIG = {\n  type: 'video',\n  selectedKey: 'selectedVideoTrackId',\n  actorKey: 'videoBufferActor',\n  loaderKey: 'videoSegmentLoaderActor',\n} as const;\n\n/**\n * Type-identity bundle for audio-track-typed behaviors.\n *\n * @see setupAudioBufferActors, loadAudioSegments\n */\nexport const AUDIO_TYPE_CONFIG = {\n  type: 'audio',\n  selectedKey: 'selectedAudioTrackId',\n  actorKey: 'audioBufferActor',\n  loaderKey: 'audioSegmentLoaderActor',\n} as const;\n\n/**\n * Type-identity bundle for text-track-typed behaviors. Text tracks have\n * no `SourceBufferActor` (MSE doesn't apply), so this bundle omits\n * `actorKey`. The `loaderKey` points at the text-track-segment-loader\n * actor (a `MessageActor` with continue-vs-preempt semantics, parallel\n * to v/a's `SegmentLoaderActor`).\n *\n * @see loadTextTrackSegments, setupTextTrackActors\n */\nexport const TEXT_TYPE_CONFIG = {\n  type: 'text',\n  selectedKey: 'selectedTextTrackId',\n  loaderKey: 'textTrackSegmentLoaderActor',\n} as const;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,oBAAoB;CAC/B,MAAM;CACN,aAAa;CACb,UAAU;CACV,WAAW;AACb;;;;;;AAOA,MAAa,oBAAoB;CAC/B,MAAM;CACN,aAAa;CACb,UAAU;CACV,WAAW;AACb;;;;;;;;;;AAWA,MAAa,mBAAmB;CAC9B,MAAM;CACN,aAAa;CACb,WAAW;AACb"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@videojs/spf",
   "type": "module",
-  "version": "10.0.0-beta.25",
+  "version": "10.0.0-beta.27",
   "description": "Stream Processing Framework for Video.js 10",
   "license": "Apache-2.0",
   "repository": {
@@ -33,10 +33,40 @@
       "development": "./dist/dev/hls.js",
       "default": "./dist/default/hls.js"
     },
-    "./background-video": {
-      "types": "./dist/dev/background-video.d.ts",
-      "development": "./dist/dev/background-video.js",
-      "default": "./dist/default/background-video.js"
+    "./media-tracks": {
+      "types": "./dist/dev/media-tracks.d.ts",
+      "development": "./dist/dev/media-tracks.js",
+      "default": "./dist/default/media-tracks.js"
+    },
+    "./hls-background-video": {
+      "types": "./dist/dev/hls-background-video.d.ts",
+      "development": "./dist/dev/hls-background-video.js",
+      "default": "./dist/default/hls-background-video.js"
+    },
+    "./hls-audio": {
+      "types": "./dist/dev/hls-audio.d.ts",
+      "development": "./dist/dev/hls-audio.js",
+      "default": "./dist/default/hls-audio.js"
+    },
+    "./hls-video": {
+      "types": "./dist/dev/hls-video.d.ts",
+      "development": "./dist/dev/hls-video.js",
+      "default": "./dist/default/hls-video.js"
+    },
+    "./mux-audio": {
+      "types": "./dist/dev/mux-audio.d.ts",
+      "development": "./dist/dev/mux-audio.js",
+      "default": "./dist/default/mux-audio.js"
+    },
+    "./mux-background-video": {
+      "types": "./dist/dev/mux-background-video.d.ts",
+      "development": "./dist/dev/mux-background-video.js",
+      "default": "./dist/default/mux-background-video.js"
+    },
+    "./mux-video": {
+      "types": "./dist/dev/mux-video.d.ts",
+      "development": "./dist/dev/mux-video.js",
+      "default": "./dist/default/mux-video.js"
     }
   },
   "main": "dist/default/index.js",
@@ -47,16 +77,17 @@
   ],
   "dependencies": {
     "signal-polyfill": "^0.2.2",
-    "@videojs/utils": "10.0.0-beta.25"
+    "@videojs/utils": "10.0.0-beta.27",
+    "@videojs/media": "10.0.0-beta.27"
   },
   "devDependencies": {
-    "@vitest/browser": "^4.1.0",
-    "@vitest/browser-playwright": "4.1.2",
-    "@vitest/coverage-v8": "^4.1.0",
+    "@vitest/browser": "^4.1.10",
+    "@vitest/browser-playwright": "^4.1.10",
+    "@vitest/coverage-v8": "^4.1.10",
     "jsdom": "^26.1.0",
     "playwright": "^1.59.1",
-    "tsdown": "^0.21.9",
-    "vitest": "^4.1.0"
+    "tsdown": "^0.22.14",
+    "vitest": "^4.1.10"
   },
   "publishConfig": {
     "access": "public"

package/dist/default/background-video.js

@@ -1,3 +0,0 @@
-import { createBackgroundVideoEngine } from "./playback/engines/background-video/engine.js";
-import { BackgroundVideoMediaElement, BackgroundVideoMediaMixin, backgroundVideoMediaDefaultProps } from "./playback/engines/background-video/adapter.js";
-export { BackgroundVideoMediaElement, BackgroundVideoMediaMixin, backgroundVideoMediaDefaultProps, createBackgroundVideoEngine };