@videojs/spf 10.0.0-beta.2 → 10.0.0-beta.21

package/dist/dev/dom/media/source-buffer-actor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-buffer-actor.js","names":[],"sources":["../../../../src/dom/media/source-buffer-actor.ts"],"sourcesContent":["import { createMachineActor, type HandlerContext, type MessageActor } from '../../core/create-machine-actor';\nimport { SerialRunner, Task } from '../../core/task';\nimport type { Segment, Track } from '../../core/types';\nimport { type AppendData, appendSegment } from './append-segment';\nimport { flushBuffer } from './buffer-flusher';\n\n// =============================================================================\n// Types\n// =============================================================================\n\nexport interface BufferedRange {\n  start: number;\n  end: number;\n}\n\nexport type AppendSegmentMeta = Pick<Segment, 'id' | 'startTime' | 'duration'> & {\n  trackId: Track['id'];\n  /** Declared track bandwidth in bps (from playlist BANDWIDTH attribute). */\n  trackBandwidth?: number;\n};\n\nexport type { AppendData };\n\nexport type AppendInitMessage = { type: 'append-init'; data: AppendData; meta: { trackId: Track['id'] } };\nexport type AppendSegmentMessage = { type: 'append-segment'; data: AppendData; meta: AppendSegmentMeta };\nexport type RemoveMessage = { type: 'remove'; start: number; end: number };\nexport type IndividualSourceBufferMessage = AppendInitMessage | AppendSegmentMessage | RemoveMessage;\nexport type BatchMessage = { type: 'batch'; messages: IndividualSourceBufferMessage[] };\nexport type CancelMessage = { type: 'cancel' };\n\n/** All messages accepted by a SourceBufferActor. */\nexport type SourceBufferMessage = IndividualSourceBufferMessage | BatchMessage | CancelMessage;\n\n/** Finite states of the actor. */\nexport type SourceBufferActorState = 'idle' | 'updating' | 'destroyed';\n\n/** Non-finite (extended) data managed by the actor — the XState \"context\". */\nexport interface SourceBufferActorContext {\n  initTrackId?: string | undefined;\n  segments: Array<\n    Pick<Segment, 'id' | 'startTime' | 'duration'> & {\n      trackId: Track['id'];\n      trackBandwidth?: number;\n      /**\n       * True while a streaming append is in progress for this segment.\n       * The segment's data is partially present in the SourceBuffer.\n       * Downstream code must not treat a partial segment as fully buffered.\n       */\n      partial?: boolean;\n    }\n  >;\n  bufferedRanges: BufferedRange[];\n}\n\n/** SourceBuffer actor: queues operations, owns its snapshot. */\nexport type SourceBufferActor = MessageActor<SourceBufferActorState, SourceBufferActorContext, SourceBufferMessage>;\n\n// =============================================================================\n// Helpers\n// =============================================================================\n\nfunction snapshotBuffered(buffered: TimeRanges): BufferedRange[] {\n  const ranges: BufferedRange[] = [];\n  for (let i = 0; i < buffered.length; i++) {\n    ranges.push({ start: buffered.start(i), end: buffered.end(i) });\n  }\n  return ranges;\n}\n\n// =============================================================================\n// Message task factories\n// =============================================================================\n\n// Context is read lazily via getContext at task execution time — not at creation\n// time — so each task always operates on the most recent context regardless of\n// when it was scheduled.\n\ninterface MessageTaskOptions {\n  getContext: () => SourceBufferActorContext;\n  sourceBuffer: SourceBuffer;\n  setContext: (ctx: SourceBufferActorContext) => void;\n}\n\nfunction appendInitTask(\n  message: AppendInitMessage,\n  { getContext, sourceBuffer }: MessageTaskOptions\n): Task<SourceBufferActorContext> {\n  return new Task(async (taskSignal) => {\n    const ctx = getContext();\n    if (taskSignal.aborted) return ctx;\n    await appendSegment(sourceBuffer, message.data);\n    // No abort check here: the physical SourceBuffer has been modified, so\n    // the model must be updated to match regardless of signal state.\n    return { ...ctx, initTrackId: message.meta.trackId };\n  });\n}\n\nfunction appendSegmentTask(\n  message: AppendSegmentMessage,\n  { getContext, sourceBuffer, setContext }: MessageTaskOptions\n): Task<SourceBufferActorContext> {\n  return new Task(async (taskSignal) => {\n    const ctx = getContext();\n    if (taskSignal.aborted) return ctx;\n\n    const { meta } = message;\n    // Remove any existing entry at the same start time (same \"slot\" in the\n    // timeline), then record the new segment. Assumes time-aligned segments\n    // across playlists. The epsilon guards against floating-point drift in\n    // parsed timestamps.\n    const EPSILON = 0.0001;\n    const filtered = ctx.segments.filter((s) => Math.abs(s.startTime - meta.startTime) >= 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":";;;;;AA6DA,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;GACpD;;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;EAKjB,MAAM,UAAU;EAChB,MAAM,WAAW,IAAI,SAAS,QAAQ,MAAM,KAAK,IAAI,EAAE,YAAY,KAAK,UAAU,IAAI,QAAQ;AAM9F,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/dom/network/chunked-stream-iterable.js

@@ -0,0 +1,49 @@
+//#region src/dom/network/chunked-stream-iterable.ts
+const DEFAULT_MIN_CHUNK_SIZE = 2 ** 17;
+/**
+* Adapts a `ReadableStream<Uint8Array>` (e.g. `response.body`) into an
+* `AsyncIterable<Uint8Array>` that yields chunks no smaller than
+* `minChunkSize` bytes. Smaller network chunks are accumulated and yielded
+* together once the threshold is met. Any remainder is flushed on stream end.
+*
+* Errors from the underlying stream propagate naturally — the reader lock is
+* always released via `finally`.
+*/
+var ChunkedStreamIterable = class {
+	minChunkSize;
+	#readableStream;
+	constructor(readableStream, { minChunkSize = DEFAULT_MIN_CHUNK_SIZE } = {}) {
+		this.#readableStream = readableStream;
+		this.minChunkSize = minChunkSize;
+	}
+	async *[Symbol.asyncIterator]() {
+		let pending;
+		const reader = this.#readableStream.getReader();
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) {
+					if (pending) yield pending;
+					break;
+				}
+				pending = pending ? concat(pending, value) : value;
+				if (pending.length >= this.minChunkSize) {
+					yield pending;
+					pending = void 0;
+				}
+			}
+		} finally {
+			reader.releaseLock();
+		}
+	}
+};
+function concat(a, b) {
+	const result = new Uint8Array(a.length + b.length);
+	result.set(a);
+	result.set(b, a.length);
+	return result;
+}
+//#endregion
+export { ChunkedStreamIterable };
+
+//# sourceMappingURL=chunked-stream-iterable.js.map

package/dist/dev/dom/network/chunked-stream-iterable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunked-stream-iterable.js","names":["#readableStream"],"sources":["../../../../src/dom/network/chunked-stream-iterable.ts"],"sourcesContent":["const DEFAULT_MIN_CHUNK_SIZE = 2 ** 17; // 128 KB\n\nexport interface ChunkedStreamIterableOptions {\n  minChunkSize?: number;\n}\n\n/**\n * Adapts a `ReadableStream<Uint8Array>` (e.g. `response.body`) into an\n * `AsyncIterable<Uint8Array>` that yields chunks no smaller than\n * `minChunkSize` bytes. Smaller network chunks are accumulated and yielded\n * together once the threshold is met. Any remainder is flushed on stream end.\n *\n * Errors from the underlying stream propagate naturally — the reader lock is\n * always released via `finally`.\n */\nexport class ChunkedStreamIterable implements AsyncIterable<Uint8Array> {\n  readonly minChunkSize: number;\n  #readableStream: ReadableStream<Uint8Array>;\n\n  constructor(\n    readableStream: ReadableStream<Uint8Array>,\n    { minChunkSize = DEFAULT_MIN_CHUNK_SIZE }: ChunkedStreamIterableOptions = {}\n  ) {\n    this.#readableStream = readableStream;\n    this.minChunkSize = minChunkSize;\n  }\n\n  async *[Symbol.asyncIterator](): AsyncGenerator<Uint8Array> {\n    let pending: Uint8Array | undefined;\n    const reader = this.#readableStream.getReader();\n    try {\n      while (true) {\n        const { done, value } = await reader.read();\n        if (done) {\n          if (pending) yield pending;\n          break;\n        }\n\n        pending = pending ? concat(pending, value) : value;\n\n        if (pending.length >= this.minChunkSize) {\n          yield pending;\n          pending = undefined;\n        }\n      }\n    } finally {\n      reader.releaseLock();\n    }\n  }\n}\n\nfunction concat(a: Uint8Array, b: Uint8Array): Uint8Array {\n  const result = new Uint8Array(a.length + b.length);\n  result.set(a);\n  result.set(b, a.length);\n  return result;\n}\n"],"mappings":";AAAA,MAAM,yBAAyB,KAAK;;;;;;;;;;AAepC,IAAa,wBAAb,MAAwE;CACtE;CACA;CAEA,YACE,gBACA,EAAE,eAAe,2BAAyD,EAAE,EAC5E;AACA,QAAA,iBAAuB;AACvB,OAAK,eAAe;;CAGtB,QAAQ,OAAO,iBAA6C;EAC1D,IAAI;EACJ,MAAM,SAAS,MAAA,eAAqB,WAAW;AAC/C,MAAI;AACF,UAAO,MAAM;IACX,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,MAAM;AAC3C,QAAI,MAAM;AACR,SAAI,QAAS,OAAM;AACnB;;AAGF,cAAU,UAAU,OAAO,SAAS,MAAM,GAAG;AAE7C,QAAI,QAAQ,UAAU,KAAK,cAAc;AACvC,WAAM;AACN,eAAU,KAAA;;;YAGN;AACR,UAAO,aAAa;;;;AAK1B,SAAS,OAAO,GAAe,GAA2B;CACxD,MAAM,SAAS,IAAI,WAAW,EAAE,SAAS,EAAE,OAAO;AAClD,QAAO,IAAI,EAAE;AACb,QAAO,IAAI,GAAG,EAAE,OAAO;AACvB,QAAO"}

package/dist/dev/dom/network/fetch.js

@@ -0,0 +1,54 @@
+//#region src/dom/network/fetch.ts
+/**
+* Fetch resolvable from AddressableObject.
+*
+* Handles byte range requests if byteRange is present.
+* Returns native fetch Response for composability (can extract text, stream, etc.).
+*
+* @param addressable - Resource to fetch (url + optional byteRange)
+* @returns Promise resolving to Response
+*
+* @example
+* const response = await fetchResolvable({ url: 'https://example.com/segment.m4s' });
+* const text = await getResponseText(response);
+*
+* @example
+* // With byte range
+* const response = await fetchResolvable({
+*   url: 'https://example.com/file.mp4',
+*   byteRange: { start: 1000, end: 1999 }
+* });
+*/
+async function fetchResolvable(addressable, options) {
+	const headers = new Headers(options?.headers);
+	if (addressable.byteRange) {
+		const { start, end } = addressable.byteRange;
+		headers.set("Range", `bytes=${start}-${end}`);
+	}
+	const request = new Request(addressable.url, {
+		method: "GET",
+		headers,
+		...options
+	});
+	return fetch(request);
+}
+/**
+* Extract text from Response.
+*
+* Accepts minimal Response-like object (just needs text() method).
+* Returns promise from response.text().
+*
+* @param response - Response-like object with text() method
+* @returns Promise resolving to text content
+*
+* @example
+* const response = await fetchResolvable(addressable);
+* const text = await getResponseText(response);
+*/
+function getResponseText(response) {
+	return response.text();
+}
+//#endregion
+export { fetchResolvable, getResponseText };
+
+//# sourceMappingURL=fetch.js.map

package/dist/dev/dom/network/fetch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.js","names":[],"sources":["../../../../src/dom/network/fetch.ts"],"sourcesContent":["/**\n * HTTP Fetch Wrapper\n *\n * Two-function approach for composability:\n * 1. fetchResolvable() - Fetch AddressableObject (handles byte ranges)\n * 2. getResponseText() - Extract text from Response\n * 3. fetchResolvableStream() - Stream body as Uint8Array chunks\n */\n\nimport type { AddressableObject } from '../../core/types';\nimport { ChunkedStreamIterable, type ChunkedStreamIterableOptions } from './chunked-stream-iterable';\n\n/**\n * Minimal Response-like interface for text extraction.\n * Allows testing without full Response object.\n */\nexport interface ResponseLike {\n  text(): Promise<string>;\n}\n\n/**\n * Fetch resolvable from AddressableObject.\n *\n * Handles byte range requests if byteRange is present.\n * Returns native fetch Response for composability (can extract text, stream, etc.).\n *\n * @param addressable - Resource to fetch (url + optional byteRange)\n * @returns Promise resolving to Response\n *\n * @example\n * const response = await fetchResolvable({ url: 'https://example.com/segment.m4s' });\n * const text = await getResponseText(response);\n *\n * @example\n * // With byte range\n * const response = await fetchResolvable({\n *   url: 'https://example.com/file.mp4',\n *   byteRange: { start: 1000, end: 1999 }\n * });\n */\nexport async function fetchResolvable(addressable: AddressableObject, options?: RequestInit): Promise<Response> {\n  const headers = new Headers(options?.headers);\n\n  // Add Range header for byte range requests\n  if (addressable.byteRange) {\n    const { start, end } = addressable.byteRange;\n    headers.set('Range', `bytes=${start}-${end}`);\n  }\n\n  const request = new Request(addressable.url, {\n    method: 'GET',\n    headers,\n    ...options,\n  });\n\n  return fetch(request);\n}\n\n/**\n * Fetch resolvable as bytes.\n *\n * Convenience wrapper around fetchResolvable that resolves the body as an\n * ArrayBuffer. Use this when you need the raw bytes (e.g. segment appends).\n * For text or streaming consumption, use fetchResolvable directly.\n */\nexport async function fetchResolvableBytes(\n  addressable: AddressableObject,\n  options?: RequestInit\n): Promise<ArrayBuffer> {\n  const response = await fetchResolvable(addressable, options);\n  return response.arrayBuffer();\n}\n\n/**\n * Fetch resolvable as a stream of Uint8Array chunks.\n *\n * Convenience wrapper around fetchResolvable that yields the body as chunks\n * via ChunkedStreamIterable. Headers are awaited before the first chunk is\n * yielded (TTFB is accounted for before iteration begins).\n *\n * Throws if the response body is null (e.g. non-body HTTP status).\n * Errors from the underlying stream propagate naturally as thrown errors.\n */\nexport async function* fetchResolvableStream(\n  addressable: AddressableObject,\n  options?: RequestInit & ChunkedStreamIterableOptions\n): AsyncGenerator<Uint8Array> {\n  const { minChunkSize, ...fetchOptions } = options ?? {};\n  const response = await fetchResolvable(addressable, fetchOptions);\n  if (!response.body) throw new Error('Response has no body');\n  yield* new ChunkedStreamIterable(response.body, ...(minChunkSize !== undefined ? [{ minChunkSize }] : []));\n}\n\n/**\n * Extract text from Response.\n *\n * Accepts minimal Response-like object (just needs text() method).\n * Returns promise from response.text().\n *\n * @param response - Response-like object with text() method\n * @returns Promise resolving to text content\n *\n * @example\n * const response = await fetchResolvable(addressable);\n * const text = await getResponseText(response);\n */\nexport function getResponseText(response: ResponseLike): Promise<string> {\n  return response.text();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAwCA,eAAsB,gBAAgB,aAAgC,SAA0C;CAC9G,MAAM,UAAU,IAAI,QAAQ,SAAS,QAAQ;AAG7C,KAAI,YAAY,WAAW;EACzB,MAAM,EAAE,OAAO,QAAQ,YAAY;AACnC,UAAQ,IAAI,SAAS,SAAS,MAAM,GAAG,MAAM;;CAG/C,MAAM,UAAU,IAAI,QAAQ,YAAY,KAAK;EAC3C,QAAQ;EACR;EACA,GAAG;EACJ,CAAC;AAEF,QAAO,MAAM,QAAQ;;;;;;;;;;;;;;;AAmDvB,SAAgB,gBAAgB,UAAyC;AACvE,QAAO,SAAS,MAAM"}

package/dist/dev/dom/playback-engine/adapter.d.ts

@@ -0,0 +1,40 @@
+import { PlaybackEngine } from "./engine.js";
+import { Constructor, MixinReturn } from "@videojs/utils/types";
+
+//#region src/dom/playback-engine/adapter.d.ts
+interface SpfMediaAPI {
+  readonly engine: PlaybackEngine;
+  src: string;
+  preload: '' | 'none' | 'metadata' | 'auto';
+  attach(mediaElement: HTMLMediaElement): void;
+  detach(): void;
+  destroy(): void;
+  play(): Promise<void>;
+}
+/**
+ * Mixin that adds SPF playback engine behavior to any base class.
+ *
+ * Implements the src/play() contract per the WHATWG HTML spec so that SPF can
+ * be used anywhere a media element API is expected.
+ *
+ * A new engine is created on every src assignment — this fully tears down all
+ * state, SourceBuffers, and in-flight requests from the previous source before
+ * the next one begins. The media element reference is preserved across src
+ * changes and re-applied to the new engine automatically.
+ *
+ * @example
+ * class SimpleHlsMedia extends SpfMediaMixin(HTMLVideoElementHost) {}
+ *
+ * const media = new SimpleHlsMedia();
+ * media.attach(document.querySelector('video'));
+ * media.src = 'https://stream.mux.com/abc123.m3u8';
+ */
+declare function SpfMediaMixin<Base extends Constructor<any>>(BaseClass: Base): MixinReturn<Base, SpfMediaAPI>;
+declare const SpfMedia_base: MixinReturn<{
+  new (): {};
+}, SpfMediaAPI>;
+/** Standalone SPF media adapter with no base class. */
+declare class SpfMedia extends SpfMedia_base {}
+//#endregion
+export { SpfMedia, SpfMediaAPI, SpfMediaMixin };
+//# sourceMappingURL=adapter.d.ts.map

package/dist/dev/dom/playback-engine/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","names":[],"sources":["../../../../src/dom/playback-engine/adapter.ts"],"mappings":";;;;UAKiB,WAAA;EAAA,SACN,MAAA,EAAQ,cAAA;EACjB,GAAA;EACA,OAAA;EACA,MAAA,CAAO,YAAA,EAAc,gBAAA;EACrB,MAAA;EACA,OAAA;EACA,IAAA,IAAQ,OAAA;AAAA;;;;;;;;;;;;;;;AAqBV;;;;iBAAgB,aAAA,cAA2B,WAAA,MAAA,CAAkB,SAAA,EAAW,IAAA,GAuIpC,WAAA,CAAY,IAAA,EAAM,WAAA;AAAA,cACrD,aAAA;;;;cAGY,QAAA,SAAiB,aAAA"}

package/dist/dev/dom/playback-engine/adapter.js

@@ -0,0 +1,100 @@
+import { update } from "../../core/signals/primitives.js";
+import { createPlaybackEngine } from "./engine.js";
+//#region src/dom/playback-engine/adapter.ts
+/**
+* Mixin that adds SPF playback engine behavior to any base class.
+*
+* Implements the src/play() contract per the WHATWG HTML spec so that SPF can
+* be used anywhere a media element API is expected.
+*
+* A new engine is created on every src assignment — this fully tears down all
+* state, SourceBuffers, and in-flight requests from the previous source before
+* the next one begins. The media element reference is preserved across src
+* changes and re-applied to the new engine automatically.
+*
+* @example
+* class SimpleHlsMedia extends SpfMediaMixin(HTMLVideoElementHost) {}
+*
+* const media = new SimpleHlsMedia();
+* media.attach(document.querySelector('video'));
+* media.src = 'https://stream.mux.com/abc123.m3u8';
+*/
+function SpfMediaMixin(BaseClass) {
+	class SpfMediaImpl extends BaseClass {
+		#engine;
+		#config;
+		#preload = "";
+		/** Pending loadstart listener from a deferred play() retry, if any. */
+		#loadstartListener = null;
+		constructor(...args) {
+			super(...args);
+			const { config } = args?.[0] ?? {};
+			this.#config = config;
+			this.#engine = createPlaybackEngine(config);
+		}
+		get engine() {
+			return this.#engine;
+		}
+		attach(mediaElement) {
+			super.attach?.(mediaElement);
+			update(this.#engine.owners, { mediaElement });
+		}
+		detach() {
+			this.#cancelPendingPlay();
+			update(this.#engine.owners, { mediaElement: void 0 });
+			super.detach?.();
+		}
+		destroy() {
+			this.#cancelPendingPlay();
+			this.#engine.destroy();
+		}
+		get preload() {
+			return this.#preload;
+		}
+		set preload(value) {
+			this.#preload = value;
+			if (value) update(this.#engine.state, { preload: value });
+		}
+		get src() {
+			return this.#engine.state.get().presentation?.url ?? "";
+		}
+		set src(value) {
+			const prevMediaElement = this.#engine.owners.get().mediaElement;
+			this.#cancelPendingPlay();
+			this.#engine.destroy();
+			this.#engine = createPlaybackEngine(this.#config);
+			if (this.#preload) update(this.#engine.state, { preload: this.#preload });
+			if (prevMediaElement) update(this.#engine.owners, { mediaElement: prevMediaElement });
+			if (value) update(this.#engine.state, { presentation: { url: value } });
+		}
+		play() {
+			const { mediaElement } = this.#engine.owners.get();
+			if (!mediaElement) return Promise.reject(/* @__PURE__ */ new Error("SpfMedia: no media element attached"));
+			update(this.#engine.state, { playbackInitiated: true });
+			return mediaElement.play().catch((err) => {
+				if (this.src) return new Promise((resolve, reject) => {
+					const listener = () => {
+						this.#loadstartListener = null;
+						mediaElement.play().then(resolve, reject);
+					};
+					this.#loadstartListener = listener;
+					mediaElement.addEventListener("loadstart", listener, { once: true });
+				});
+				throw err;
+			});
+		}
+		#cancelPendingPlay() {
+			if (!this.#loadstartListener) return;
+			const { mediaElement } = this.#engine.owners.get();
+			mediaElement?.removeEventListener("loadstart", this.#loadstartListener);
+			this.#loadstartListener = null;
+		}
+	}
+	return SpfMediaImpl;
+}
+/** Standalone SPF media adapter with no base class. */
+var SpfMedia = class extends SpfMediaMixin(class {}) {};
+//#endregion
+export { SpfMedia, SpfMediaMixin };
+
+//# sourceMappingURL=adapter.js.map

package/dist/dev/dom/playback-engine/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","names":["#config","#engine","#cancelPendingPlay","#preload","#loadstartListener"],"sources":["../../../../src/dom/playback-engine/adapter.ts"],"sourcesContent":["import type { Constructor, MixinReturn } from '@videojs/utils/types';\nimport { update } from '../../core/signals/primitives';\nimport type { PlaybackEngineConfig } from './engine';\nimport { createPlaybackEngine, type PlaybackEngine } from './engine';\n\nexport interface SpfMediaAPI {\n  readonly engine: PlaybackEngine;\n  src: string;\n  preload: '' | 'none' | 'metadata' | 'auto';\n  attach(mediaElement: HTMLMediaElement): void;\n  detach(): void;\n  destroy(): void;\n  play(): Promise<void>;\n}\n\n/**\n * Mixin that adds SPF playback engine behavior to any base class.\n *\n * Implements the src/play() contract per the WHATWG HTML spec so that SPF can\n * be used anywhere a media element API is expected.\n *\n * A new engine is created on every src assignment — this fully tears down all\n * state, SourceBuffers, and in-flight requests from the previous source before\n * the next one begins. The media element reference is preserved across src\n * changes and re-applied to the new engine automatically.\n *\n * @example\n * class SimpleHlsMedia extends SpfMediaMixin(HTMLVideoElementHost) {}\n *\n * const media = new SimpleHlsMedia();\n * media.attach(document.querySelector('video'));\n * media.src = 'https://stream.mux.com/abc123.m3u8';\n */\nexport function SpfMediaMixin<Base extends Constructor<any>>(BaseClass: Base) {\n  class SpfMediaImpl extends BaseClass {\n    #engine: PlaybackEngine;\n    #config: PlaybackEngineConfig;\n    #preload: '' | 'none' | 'metadata' | 'auto' = '';\n\n    /** Pending loadstart listener from a deferred play() retry, if any. */\n    #loadstartListener: (() => void) | null = null;\n\n    constructor(...args: any[]) {\n      super(...args);\n\n      const { config } = args?.[0] ?? {};\n      this.#config = config;\n      this.#engine = createPlaybackEngine(config);\n    }\n\n    get engine(): PlaybackEngine {\n      return this.#engine;\n    }\n\n    // -------------------------------------------------------------------------\n    // Media element lifecycle\n    // -------------------------------------------------------------------------\n\n    attach(mediaElement: HTMLMediaElement): void {\n      super.attach?.(mediaElement);\n      update(this.#engine.owners, { mediaElement });\n    }\n\n    detach(): void {\n      this.#cancelPendingPlay();\n      update(this.#engine.owners, { mediaElement: undefined });\n      super.detach?.();\n    }\n\n    destroy(): void {\n      this.#cancelPendingPlay();\n      this.#engine.destroy();\n    }\n\n    // -------------------------------------------------------------------------\n    // preload — synchronous IDL attribute (WHATWG §4.8.11.2)\n    // -------------------------------------------------------------------------\n\n    get preload(): '' | 'none' | 'metadata' | 'auto' {\n      return this.#preload;\n    }\n\n    set preload(value: '' | 'none' | 'metadata' | 'auto') {\n      this.#preload = value;\n      if (value) {\n        update(this.#engine.state, { preload: value });\n      }\n      // value = '' clears #preload (so the next engine recreation won't re-apply\n      // an explicit value) but does not patch current state — the existing preload\n      // stays in effect until the next src change creates a fresh engine.\n    }\n\n    // -------------------------------------------------------------------------\n    // src — synchronous IDL attribute (WHATWG §4.8.11.2)\n    // Each assignment destroys the current engine and starts a fresh one, exactly\n    // as the browser's load algorithm resets all media element state on src change.\n    // -------------------------------------------------------------------------\n\n    get src(): string {\n      return this.#engine.state.get().presentation?.url ?? '';\n    }\n\n    set src(value: string) {\n      const prevMediaElement = this.#engine.owners.get().mediaElement;\n\n      this.#cancelPendingPlay();\n      this.#engine.destroy();\n      this.#engine = createPlaybackEngine(this.#config);\n\n      // Apply explicit preload before setting owners so syncPreloadAttribute skips\n      // element inference and the explicit value is preserved across src changes.\n      if (this.#preload) {\n        update(this.#engine.state, { preload: this.#preload });\n      }\n\n      if (prevMediaElement) {\n        update(this.#engine.owners, { mediaElement: prevMediaElement });\n      }\n\n      if (value) {\n        update(this.#engine.state, { presentation: { url: value } });\n      }\n    }\n\n    // -------------------------------------------------------------------------\n    // play() — WHATWG §4.8.11.8\n    // Delegates to the attached media element's native play().\n    // -------------------------------------------------------------------------\n\n    play(): Promise<void> {\n      const { mediaElement } = this.#engine.owners.get();\n      if (!mediaElement) {\n        return Promise.reject(new Error('SpfMedia: no media element attached'));\n      }\n\n      // Signal play intent — enables loading even with preload=\"none\"\n      update(this.#engine.state, { playbackInitiated: true });\n\n      return mediaElement.play().catch((err: unknown) => {\n        // If we have a pending HLS source, the rejection may be because MSE\n        // hasn't attached a blob URL yet. Wait for loadstart (src assigned\n        // by MSE setup) and retry once.\n        if (this.src) {\n          return new Promise<void>((resolve, reject) => {\n            const listener = () => {\n              this.#loadstartListener = null;\n              mediaElement.play().then(resolve, reject);\n            };\n            this.#loadstartListener = listener;\n            mediaElement.addEventListener('loadstart', listener, { once: true });\n          });\n        }\n        throw err;\n      });\n    }\n\n    // -------------------------------------------------------------------------\n    // Private\n    // -------------------------------------------------------------------------\n\n    #cancelPendingPlay(): void {\n      if (!this.#loadstartListener) return;\n      const { mediaElement } = this.#engine.owners.get();\n      mediaElement?.removeEventListener('loadstart', this.#loadstartListener);\n      this.#loadstartListener = null;\n    }\n  }\n\n  return SpfMediaImpl as unknown as MixinReturn<Base, SpfMediaAPI>;\n}\n\n/** Standalone SPF media adapter with no base class. */\nexport class SpfMedia extends SpfMediaMixin(class {}) {}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAiCA,SAAgB,cAA6C,WAAiB;CAC5E,MAAM,qBAAqB,UAAU;EACnC;EACA;EACA,WAA8C;;EAG9C,qBAA0C;EAE1C,YAAY,GAAG,MAAa;AAC1B,SAAM,GAAG,KAAK;GAEd,MAAM,EAAE,WAAW,OAAO,MAAM,EAAE;AAClC,SAAA,SAAe;AACf,SAAA,SAAe,qBAAqB,OAAO;;EAG7C,IAAI,SAAyB;AAC3B,UAAO,MAAA;;EAOT,OAAO,cAAsC;AAC3C,SAAM,SAAS,aAAa;AAC5B,UAAO,MAAA,OAAa,QAAQ,EAAE,cAAc,CAAC;;EAG/C,SAAe;AACb,SAAA,mBAAyB;AACzB,UAAO,MAAA,OAAa,QAAQ,EAAE,cAAc,KAAA,GAAW,CAAC;AACxD,SAAM,UAAU;;EAGlB,UAAgB;AACd,SAAA,mBAAyB;AACzB,SAAA,OAAa,SAAS;;EAOxB,IAAI,UAA6C;AAC/C,UAAO,MAAA;;EAGT,IAAI,QAAQ,OAA0C;AACpD,SAAA,UAAgB;AAChB,OAAI,MACF,QAAO,MAAA,OAAa,OAAO,EAAE,SAAS,OAAO,CAAC;;EAalD,IAAI,MAAc;AAChB,UAAO,MAAA,OAAa,MAAM,KAAK,CAAC,cAAc,OAAO;;EAGvD,IAAI,IAAI,OAAe;GACrB,MAAM,mBAAmB,MAAA,OAAa,OAAO,KAAK,CAAC;AAEnD,SAAA,mBAAyB;AACzB,SAAA,OAAa,SAAS;AACtB,SAAA,SAAe,qBAAqB,MAAA,OAAa;AAIjD,OAAI,MAAA,QACF,QAAO,MAAA,OAAa,OAAO,EAAE,SAAS,MAAA,SAAe,CAAC;AAGxD,OAAI,iBACF,QAAO,MAAA,OAAa,QAAQ,EAAE,cAAc,kBAAkB,CAAC;AAGjE,OAAI,MACF,QAAO,MAAA,OAAa,OAAO,EAAE,cAAc,EAAE,KAAK,OAAO,EAAE,CAAC;;EAShE,OAAsB;GACpB,MAAM,EAAE,iBAAiB,MAAA,OAAa,OAAO,KAAK;AAClD,OAAI,CAAC,aACH,QAAO,QAAQ,uBAAO,IAAI,MAAM,sCAAsC,CAAC;AAIzE,UAAO,MAAA,OAAa,OAAO,EAAE,mBAAmB,MAAM,CAAC;AAEvD,UAAO,aAAa,MAAM,CAAC,OAAO,QAAiB;AAIjD,QAAI,KAAK,IACP,QAAO,IAAI,SAAe,SAAS,WAAW;KAC5C,MAAM,iBAAiB;AACrB,YAAA,oBAA0B;AAC1B,mBAAa,MAAM,CAAC,KAAK,SAAS,OAAO;;AAE3C,WAAA,oBAA0B;AAC1B,kBAAa,iBAAiB,aAAa,UAAU,EAAE,MAAM,MAAM,CAAC;MACpE;AAEJ,UAAM;KACN;;EAOJ,qBAA2B;AACzB,OAAI,CAAC,MAAA,kBAAyB;GAC9B,MAAM,EAAE,iBAAiB,MAAA,OAAa,OAAO,KAAK;AAClD,iBAAc,oBAAoB,aAAa,MAAA,kBAAwB;AACvE,SAAA,oBAA0B;;;AAI9B,QAAO;;;AAIT,IAAa,WAAb,cAA8B,cAAc,MAAM,GAAG,CAAC"}

package/dist/dev/dom/playback-engine/engine.d.ts

@@ -0,0 +1,124 @@
+import { BandwidthState } from "../../core/abr/bandwidth-estimator.js";
+import { ReadonlySignal, Signal } from "../../core/signals/primitives.js";
+import { SourceBufferActor } from "../media/source-buffer-actor.js";
+import { TextTracksActor } from "../features/text-tracks-actor.js";
+import { TextTrackSegmentLoaderActor } from "../features/text-track-segment-loader-actor.js";
+
+//#region src/dom/playback-engine/engine.d.ts
+/**
+ * Configuration for the playback engine.
+ */
+interface PlaybackEngineConfig {
+  /**
+   * Initial bandwidth estimate for cold start (bits per second).
+   * Default: 1 Mbps (conservative).
+   */
+  initialBandwidth?: number;
+  /**
+   * Preferred audio language (ISO 639 code, e.g., "en", "es").
+   * If not specified, selects first audio track.
+   */
+  preferredAudioLanguage?: string;
+  /**
+   * Preferred subtitle language (ISO 639 code, e.g., "en", "es").
+   * If specified, selects matching text track if available.
+   */
+  preferredSubtitleLanguage?: string;
+  /**
+   * Include FORCED subtitle tracks in selection.
+   * Default: false (follows hls.js/http-streaming pattern)
+   */
+  includeForcedTracks?: boolean;
+  /**
+   * Auto-select DEFAULT track (requires DEFAULT=YES + AUTOSELECT=YES in HLS).
+   * Default: false (user opt-in, matches hls.js/http-streaming)
+   */
+  enableDefaultTrack?: boolean;
+}
+/**
+ * Combined state shape for the playback engine.
+ * Includes all state needed by orchestrations.
+ */
+interface PlaybackEngineState {
+  presentation?: any;
+  preload?: 'auto' | 'metadata' | 'none';
+  selectedVideoTrackId?: string;
+  selectedAudioTrackId?: string;
+  selectedTextTrackId?: string;
+  bandwidthState?: BandwidthState;
+  abrDisabled?: boolean;
+  currentTime?: number;
+  playbackInitiated?: boolean;
+}
+/**
+ * Combined owners shape for the playback engine.
+ * Includes all mutable platform objects.
+ */
+interface PlaybackEngineOwners {
+  mediaElement?: HTMLMediaElement | undefined;
+  mediaSource?: MediaSource;
+  /** Reactive mirror of `mediaSource.readyState` — updated via DOM events. */
+  mediaSourceReadyState?: ReadonlySignal<MediaSource['readyState']>;
+  videoBuffer?: SourceBuffer;
+  audioBuffer?: SourceBuffer;
+  videoBufferActor?: SourceBufferActor;
+  audioBufferActor?: SourceBufferActor;
+  textTracksActor?: TextTracksActor;
+  segmentLoaderActor?: TextTrackSegmentLoaderActor;
+}
+/**
+ * Playback engine instance.
+ */
+interface PlaybackEngine {
+  /**
+   * Reactive state signal (for inspection/testing).
+   */
+  state: Signal<PlaybackEngineState>;
+  /**
+   * Mutable owners signal (for inspection/testing).
+   */
+  owners: Signal<PlaybackEngineOwners>;
+  /**
+   * Cleanup function to destroy all orchestrations.
+   */
+  destroy: () => void;
+}
+/**
+ * Create a POC playback engine.
+ *
+ * Wires together all orchestrations to create a reactive playback pipeline:
+ * 1. Resolve presentation (multivariant playlist)
+ * 2. Select initial video and audio tracks
+ * 3. Resolve selected tracks (media playlists)
+ * 4. Setup MediaSource
+ * 5. Setup SourceBuffers for video and audio
+ *
+ * Note: This is a POC - does not yet load/append segments.
+ *
+ * @param config - Playback engine configuration
+ * @returns Playback engine instance with state, owners, and destroy function
+ *
+ * @example
+ * const engine = createPlaybackEngine({
+ *   initialBandwidth: 2_000_000,
+ *   preferredAudioLanguage: 'en',
+ * });
+ *
+ * // Initialize by setting state and owners
+ * engine.owners.set({ ...engine.owners.get(), mediaElement: document.querySelector('video') });
+ * engine.state.set({
+ *   ...engine.state.get(),
+ *   presentation: { url: 'https://example.com/playlist.m3u8' },
+ *   preload: 'auto',
+ * });
+ *
+ * // Inspect state
+ * console.log(engine.state.get());
+ *
+ * // Cleanup
+ * engine.destroy();
+ */
+declare function createPlaybackEngine(config?: PlaybackEngineConfig): PlaybackEngine;
+//#endregion
+export { PlaybackEngine, PlaybackEngineConfig, PlaybackEngineOwners, PlaybackEngineState, createPlaybackEngine };
+//# sourceMappingURL=engine.d.ts.map

package/dist/dev/dom/playback-engine/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","names":[],"sources":["../../../../src/dom/playback-engine/engine.ts"],"mappings":";;;;;;;;;AA0BA;UAAiB,oBAAA;;;;;EAKf,gBAAA;EAkBA;;;;EAZA,sBAAA;EAyBkC;;;;EAnBlC,yBAAA;EAyBA;;;;EAnBA,mBAAA;EA8BA;;;;EAxBA,kBAAA;AAAA;;;;;UAOe,mBAAA;EAEf,YAAA;EACA,OAAA;EAGA,oBAAA;EACA,oBAAA;EAEA,mBAAA;EAGA,cAAA,GAAiB,cAAA;EAKjB,WAAA;EAGA,WAAA;EAGA,iBAAA;AAAA;;;;;UAOe,oBAAA;EAEf,YAAA,GAAe,gBAAA;EAGf,WAAA,GAAc,WAAA;EAKA;EAHd,qBAAA,GAAwB,cAAA,CAAe,WAAA;EAGvC,WAAA,GAAc,YAAA;EACd,WAAA,GAAc,YAAA;EACd,gBAAA,GAAmB,iBAAA;EACnB,gBAAA,GAAmB,iBAAA;EAGnB,eAAA,GAAkB,eAAA;EAClB,kBAAA,GAAqB,2BAAA;AAAA;;;;UAMN,cAAA;EAAA;;;EAIf,KAAA,EAAO,MAAA,CAAO,mBAAA;EAAP;;;EAKP,MAAA,EAAQ,MAAA,CAAO,oBAAA;EAAD;;;EAKd,OAAA;AAAA;;;;;;AAsCF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,oBAAA,CAAqB,MAAA,GAAQ,oBAAA,GAA4B,cAAA"}

package/dist/dev/dom/playback-engine/engine.js

@@ -0,0 +1,142 @@
+import { signal } from "../../core/signals/primitives.js";
+import { loadSegments } from "../features/load-segments.js";
+import { destroyVttParser } from "../text/parse-vtt-segment.js";
+import { loadTextTrackCues } from "../features/load-text-track-cues.js";
+import { trackCurrentTime } from "../features/track-current-time.js";
+import { trackPlaybackInitiated } from "../features/track-playback-initiated.js";
+import { calculatePresentationDuration } from "../../core/features/calculate-presentation-duration.js";
+import { switchQuality } from "../../core/features/quality-switching.js";
+import { resolvePresentation } from "../../core/features/resolve-presentation.js";
+import { resolveTrack } from "../../core/features/resolve-track.js";
+import { selectAudioTrack, selectTextTrack, selectVideoTrack } from "../../core/features/select-tracks.js";
+import { syncPreloadAttribute } from "../../core/features/sync-preload-attribute.js";
+import { endOfStream } from "../features/end-of-stream.js";
+import { setupMediaSource } from "../features/setup-mediasource.js";
+import { setupSourceBuffers } from "../features/setup-sourcebuffer.js";
+import { syncTextTracks } from "../features/sync-text-tracks.js";
+import { updateDuration } from "../features/update-duration.js";
+//#region src/dom/playback-engine/engine.ts
+/**
+* Create a POC playback engine.
+*
+* Wires together all orchestrations to create a reactive playback pipeline:
+* 1. Resolve presentation (multivariant playlist)
+* 2. Select initial video and audio tracks
+* 3. Resolve selected tracks (media playlists)
+* 4. Setup MediaSource
+* 5. Setup SourceBuffers for video and audio
+*
+* Note: This is a POC - does not yet load/append segments.
+*
+* @param config - Playback engine configuration
+* @returns Playback engine instance with state, owners, and destroy function
+*
+* @example
+* const engine = createPlaybackEngine({
+*   initialBandwidth: 2_000_000,
+*   preferredAudioLanguage: 'en',
+* });
+*
+* // Initialize by setting state and owners
+* engine.owners.set({ ...engine.owners.get(), mediaElement: document.querySelector('video') });
+* engine.state.set({
+*   ...engine.state.get(),
+*   presentation: { url: 'https://example.com/playlist.m3u8' },
+*   preload: 'auto',
+* });
+*
+* // Inspect state
+* console.log(engine.state.get());
+*
+* // Cleanup
+* engine.destroy();
+*/
+function createPlaybackEngine(config = {}) {
+	const state = signal({ bandwidthState: {
+		fastEstimate: 0,
+		fastTotalWeight: 0,
+		slowEstimate: 0,
+		slowTotalWeight: 0,
+		bytesSampled: 0
+	} });
+	const owners = signal({});
+	const cleanups = [
+		syncPreloadAttribute({
+			state,
+			owners
+		}),
+		trackPlaybackInitiated({
+			state,
+			owners
+		}),
+		resolvePresentation({ state }),
+		selectVideoTrack({ state }, {
+			type: "video",
+			...config.initialBandwidth !== void 0 && { initialBandwidth: config.initialBandwidth }
+		}),
+		selectAudioTrack({ state }, {
+			type: "audio",
+			...config.preferredAudioLanguage !== void 0 && { preferredAudioLanguage: config.preferredAudioLanguage }
+		}),
+		selectTextTrack({ state }, {
+			type: "text",
+			...config.preferredSubtitleLanguage !== void 0 && { preferredSubtitleLanguage: config.preferredSubtitleLanguage },
+			...config.includeForcedTracks !== void 0 && { includeForcedTracks: config.includeForcedTracks },
+			...config.enableDefaultTrack !== void 0 && { enableDefaultTrack: config.enableDefaultTrack }
+		}),
+		resolveTrack({ state }, { type: "video" }),
+		resolveTrack({ state }, { type: "audio" }),
+		resolveTrack({ state }, { type: "text" }),
+		calculatePresentationDuration({ state }),
+		setupMediaSource({
+			state,
+			owners
+		}),
+		updateDuration({
+			state,
+			owners
+		}),
+		setupSourceBuffers({
+			state,
+			owners
+		}),
+		trackCurrentTime({
+			state,
+			owners
+		}),
+		switchQuality({ state }, config.initialBandwidth !== void 0 ? { defaultBandwidth: config.initialBandwidth } : {}),
+		loadSegments({
+			state,
+			owners
+		}, { type: "video" }),
+		loadSegments({
+			state,
+			owners
+		}, { type: "audio" }),
+		endOfStream({
+			state,
+			owners
+		}),
+		syncTextTracks({
+			state,
+			owners
+		}),
+		loadTextTrackCues({
+			state,
+			owners
+		})
+	];
+	return {
+		state,
+		owners,
+		destroy: () => {
+			cleanups.forEach((cleanup) => typeof cleanup === "function" ? cleanup() : cleanup.destroy());
+			for (const value of Object.values(owners.get())) if (value !== null && typeof value === "object" && typeof value.destroy === "function") value.destroy();
+			destroyVttParser();
+		}
+	};
+}
+//#endregion
+export { createPlaybackEngine };
+
+//# sourceMappingURL=engine.js.map

package/dist/dev/dom/playback-engine/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","names":[],"sources":["../../../../src/dom/playback-engine/engine.ts"],"sourcesContent":["import type { BandwidthState } from '../../core/abr/bandwidth-estimator';\nimport { calculatePresentationDuration } from '../../core/features/calculate-presentation-duration';\nimport { switchQuality } from '../../core/features/quality-switching';\nimport { resolvePresentation } from '../../core/features/resolve-presentation';\nimport { resolveTrack } from '../../core/features/resolve-track';\nimport { selectAudioTrack, selectTextTrack, selectVideoTrack } from '../../core/features/select-tracks';\nimport { syncPreloadAttribute } from '../../core/features/sync-preload-attribute';\nimport type { ReadonlySignal, Signal } from '../../core/signals/primitives';\nimport { signal } from '../../core/signals/primitives';\nimport { endOfStream } from '../features/end-of-stream';\nimport { loadSegments } from '../features/load-segments';\nimport { loadTextTrackCues } from '../features/load-text-track-cues';\nimport { setupMediaSource } from '../features/setup-mediasource';\nimport { setupSourceBuffers } from '../features/setup-sourcebuffer';\nimport { syncTextTracks } from '../features/sync-text-tracks';\nimport type { TextTrackSegmentLoaderActor } from '../features/text-track-segment-loader-actor';\nimport type { TextTracksActor } from '../features/text-tracks-actor';\nimport { trackCurrentTime } from '../features/track-current-time';\nimport { trackPlaybackInitiated } from '../features/track-playback-initiated';\nimport { updateDuration } from '../features/update-duration';\nimport type { SourceBufferActor } from '../media/source-buffer-actor';\nimport { destroyVttParser } from '../text/parse-vtt-segment';\n\n/**\n * Configuration for the playback engine.\n */\nexport interface PlaybackEngineConfig {\n  /**\n   * Initial bandwidth estimate for cold start (bits per second).\n   * Default: 1 Mbps (conservative).\n   */\n  initialBandwidth?: number;\n\n  /**\n   * Preferred audio language (ISO 639 code, e.g., \"en\", \"es\").\n   * If not specified, selects first audio track.\n   */\n  preferredAudioLanguage?: string;\n\n  /**\n   * Preferred subtitle language (ISO 639 code, e.g., \"en\", \"es\").\n   * If specified, selects matching text track if available.\n   */\n  preferredSubtitleLanguage?: string;\n\n  /**\n   * Include FORCED subtitle tracks in selection.\n   * Default: false (follows hls.js/http-streaming pattern)\n   */\n  includeForcedTracks?: boolean;\n\n  /**\n   * Auto-select DEFAULT track (requires DEFAULT=YES + AUTOSELECT=YES in HLS).\n   * Default: false (user opt-in, matches hls.js/http-streaming)\n   */\n  enableDefaultTrack?: boolean;\n}\n\n/**\n * Combined state shape for the playback engine.\n * Includes all state needed by orchestrations.\n */\nexport interface PlaybackEngineState {\n  // Presentation state\n  presentation?: any;\n  preload?: 'auto' | 'metadata' | 'none';\n\n  // Track selection state\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n  // NOTE: Text Tracks (subtitles/ccs) can be unselected\n  selectedTextTrackId?: string;\n\n  // Bandwidth estimation state\n  bandwidthState?: BandwidthState;\n\n  // ABR control — set to true to suppress automatic quality switching (manual selection mode).\n  // TODO: replace with separate manualVideoTrackId / abrVideoTrackId fields so the two\n  // concerns don't share a field; see quality-switching.ts for the full design note.\n  abrDisabled?: boolean;\n\n  // Current playback position (mirrored from mediaElement via trackCurrentTime)\n  currentTime?: number;\n\n  // True once the user has initiated playback (enables segment loading regardless of preload)\n  playbackInitiated?: boolean;\n}\n\n/**\n * Combined owners shape for the playback engine.\n * Includes all mutable platform objects.\n */\nexport interface PlaybackEngineOwners {\n  // Media element\n  mediaElement?: HTMLMediaElement | undefined;\n\n  // MediaSource\n  mediaSource?: MediaSource;\n  /** Reactive mirror of `mediaSource.readyState` — updated via DOM events. */\n  mediaSourceReadyState?: ReadonlySignal<MediaSource['readyState']>;\n\n  // SourceBuffers and their actors (created together by setupSourceBuffer)\n  videoBuffer?: SourceBuffer;\n  audioBuffer?: SourceBuffer;\n  videoBufferActor?: SourceBufferActor;\n  audioBufferActor?: SourceBufferActor;\n\n  // Text track actors (written by loadTextTrackCues; destroyed by engine on destroy)\n  textTracksActor?: TextTracksActor;\n  segmentLoaderActor?: TextTrackSegmentLoaderActor;\n}\n\n/**\n * Playback engine instance.\n */\nexport interface PlaybackEngine {\n  /**\n   * Reactive state signal (for inspection/testing).\n   */\n  state: Signal<PlaybackEngineState>;\n\n  /**\n   * Mutable owners signal (for inspection/testing).\n   */\n  owners: Signal<PlaybackEngineOwners>;\n\n  /**\n   * Cleanup function to destroy all orchestrations.\n   */\n  destroy: () => void;\n}\n\n/**\n * Create a POC playback engine.\n *\n * Wires together all orchestrations to create a reactive playback pipeline:\n * 1. Resolve presentation (multivariant playlist)\n * 2. Select initial video and audio tracks\n * 3. Resolve selected tracks (media playlists)\n * 4. Setup MediaSource\n * 5. Setup SourceBuffers for video and audio\n *\n * Note: This is a POC - does not yet load/append segments.\n *\n * @param config - Playback engine configuration\n * @returns Playback engine instance with state, owners, and destroy function\n *\n * @example\n * const engine = createPlaybackEngine({\n *   initialBandwidth: 2_000_000,\n *   preferredAudioLanguage: 'en',\n * });\n *\n * // Initialize by setting state and owners\n * engine.owners.set({ ...engine.owners.get(), mediaElement: document.querySelector('video') });\n * engine.state.set({\n *   ...engine.state.get(),\n *   presentation: { url: 'https://example.com/playlist.m3u8' },\n *   preload: 'auto',\n * });\n *\n * // Inspect state\n * console.log(engine.state.get());\n *\n * // Cleanup\n * engine.destroy();\n */\nexport function createPlaybackEngine(config: PlaybackEngineConfig = {}): PlaybackEngine {\n  // Create reactive state and owners as signals\n  const state = signal<PlaybackEngineState>({\n    bandwidthState: {\n      fastEstimate: 0,\n      fastTotalWeight: 0,\n      slowEstimate: 0,\n      slowTotalWeight: 0,\n      bytesSampled: 0,\n    },\n  });\n  const owners = signal<PlaybackEngineOwners>({});\n\n  // Wire up orchestrations\n  const cleanups = [\n    // 0a. Sync preload attribute from mediaElement → state.preload\n    //     Normalises '' (absent attribute) to 'auto' (browser default).\n    syncPreloadAttribute({ state, owners }),\n\n    // 0b. Track media element play event → state.playbackInitiated\n    //     Enables preload=\"none\" resolution via native controls / element.play()\n    trackPlaybackInitiated({ state, owners }),\n\n    // 1. Resolve presentation (URL already in state)\n    resolvePresentation({ state }),\n\n    // 2. Select initial tracks (when presentation loads)\n    selectVideoTrack(\n      { state },\n      {\n        type: 'video',\n        ...(config.initialBandwidth !== undefined && { initialBandwidth: config.initialBandwidth }),\n      }\n    ),\n    selectAudioTrack(\n      { state },\n      {\n        type: 'audio',\n        ...(config.preferredAudioLanguage !== undefined && { preferredAudioLanguage: config.preferredAudioLanguage }),\n      }\n    ),\n    selectTextTrack(\n      { state },\n      {\n        type: 'text',\n        ...(config.preferredSubtitleLanguage !== undefined && {\n          preferredSubtitleLanguage: config.preferredSubtitleLanguage,\n        }),\n        ...(config.includeForcedTracks !== undefined && { includeForcedTracks: config.includeForcedTracks }),\n        ...(config.enableDefaultTrack !== undefined && { enableDefaultTrack: config.enableDefaultTrack }),\n      }\n    ),\n\n    // 3. Resolve selected tracks (fetch media playlists)\n    resolveTrack({ state }, { type: 'video' as const }),\n    resolveTrack({ state }, { type: 'audio' as const }),\n    resolveTrack({ state }, { type: 'text' as const }),\n\n    // 3.5. Calculate presentation duration from resolved tracks\n    calculatePresentationDuration({ state }),\n\n    // 4. Setup MediaSource (when presentation loaded)\n    setupMediaSource({ state, owners }),\n\n    // 4.5. Update MediaSource duration (when presentation duration available)\n    updateDuration({ state, owners }),\n\n    // 5. Setup SourceBuffers (when MediaSource ready and all selected tracks resolved)\n    // Both SourceBuffers are created in a single synchronous operation to guarantee\n    // neither is visible to loadSegments before the other exists — preventing the\n    // Firefox bug where appending video data before audio SB is created causes\n    // mozHasAudio to be permanently false.\n    setupSourceBuffers({ state, owners }),\n\n    // 5.5. Track currentTime from mediaElement (feeds forward buffer management)\n    //\n    // NOTE: SourceBufferActor wiring is intentionally absent here in Phase 1.\n    //\n    // Attempting to wire actors into the engine at this layer revealed a\n    // brittleness in the current architecture: every patch to `owners` —\n    // regardless of which field changed — wakes up ALL combineLatest subscribers\n    // (loadSegments, endOfStream, etc.). Storing actor references in owners\n    // caused loadSegments to re-evaluate mid-task, store a spurious pending\n    // state, and run a second loading cycle on completion.\n    //\n    // This means any future feature that needs to introduce new reactive state\n    // alongside SourceBuffers faces the same hazard. The right fix is for\n    // loadSegments (and other orchestrations) to route their MSE operations\n    // through the actor directly, at which point the actor lifecycle is\n    // co-located with its consumer rather than managed centrally here.\n    //\n    // Actor wiring will be introduced in Phase 2 as part of the loadSegments\n    // refactor. See .claude/plans/spf/buffer-state-shadow-actual-model.md.\n    trackCurrentTime({ state, owners }),\n\n    // 5.75. ABR quality switching (reacts to bandwidth samples from loadSegments)\n    switchQuality(\n      { state },\n      config.initialBandwidth !== undefined ? { defaultBandwidth: config.initialBandwidth } : {}\n    ),\n\n    // 6. Load segments (when SourceBuffer ready and track resolved)\n    loadSegments({ state, owners }, { type: 'video' }),\n    loadSegments({ state, owners }, { type: 'audio' }),\n\n    // 6.5. Signal end of stream when all segments loaded\n    endOfStream({ state, owners }),\n\n    // 7-8.5. Text track sync: setup, mode sync, and DOM bridge.\n    //        Consolidates setupTextTracks, syncTextTrackModes, syncSelectedTextTrackFromDom.\n    syncTextTracks({ state, owners }),\n\n    // 9. Load text track cues (when track resolved and mode set)\n    loadTextTrackCues({ state, owners }),\n  ];\n\n  // Return engine instance\n  return {\n    state,\n    owners,\n    destroy: () => {\n      cleanups.forEach((cleanup) => (typeof cleanup === 'function' ? cleanup() : cleanup.destroy()));\n      // Destroy any actors that orchestrations wrote into owners during their lifetime.\n      for (const value of Object.values(owners.get())) {\n        if (\n          value !== null &&\n          typeof value === 'object' &&\n          typeof (value as { destroy?: unknown }).destroy === 'function'\n        ) {\n          (value as { destroy(): void }).destroy();\n        }\n      }\n      destroyVttParser();\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuKA,SAAgB,qBAAqB,SAA+B,EAAE,EAAkB;CAEtF,MAAM,QAAQ,OAA4B,EACxC,gBAAgB;EACd,cAAc;EACd,iBAAiB;EACjB,cAAc;EACd,iBAAiB;EACjB,cAAc;EACf,EACF,CAAC;CACF,MAAM,SAAS,OAA6B,EAAE,CAAC;CAG/C,MAAM,WAAW;EAGf,qBAAqB;GAAE;GAAO;GAAQ,CAAC;EAIvC,uBAAuB;GAAE;GAAO;GAAQ,CAAC;EAGzC,oBAAoB,EAAE,OAAO,CAAC;EAG9B,iBACE,EAAE,OAAO,EACT;GACE,MAAM;GACN,GAAI,OAAO,qBAAqB,KAAA,KAAa,EAAE,kBAAkB,OAAO,kBAAkB;GAC3F,CACF;EACD,iBACE,EAAE,OAAO,EACT;GACE,MAAM;GACN,GAAI,OAAO,2BAA2B,KAAA,KAAa,EAAE,wBAAwB,OAAO,wBAAwB;GAC7G,CACF;EACD,gBACE,EAAE,OAAO,EACT;GACE,MAAM;GACN,GAAI,OAAO,8BAA8B,KAAA,KAAa,EACpD,2BAA2B,OAAO,2BACnC;GACD,GAAI,OAAO,wBAAwB,KAAA,KAAa,EAAE,qBAAqB,OAAO,qBAAqB;GACnG,GAAI,OAAO,uBAAuB,KAAA,KAAa,EAAE,oBAAoB,OAAO,oBAAoB;GACjG,CACF;EAGD,aAAa,EAAE,OAAO,EAAE,EAAE,MAAM,SAAkB,CAAC;EACnD,aAAa,EAAE,OAAO,EAAE,EAAE,MAAM,SAAkB,CAAC;EACnD,aAAa,EAAE,OAAO,EAAE,EAAE,MAAM,QAAiB,CAAC;EAGlD,8BAA8B,EAAE,OAAO,CAAC;EAGxC,iBAAiB;GAAE;GAAO;GAAQ,CAAC;EAGnC,eAAe;GAAE;GAAO;GAAQ,CAAC;EAOjC,mBAAmB;GAAE;GAAO;GAAQ,CAAC;EAqBrC,iBAAiB;GAAE;GAAO;GAAQ,CAAC;EAGnC,cACE,EAAE,OAAO,EACT,OAAO,qBAAqB,KAAA,IAAY,EAAE,kBAAkB,OAAO,kBAAkB,GAAG,EAAE,CAC3F;EAGD,aAAa;GAAE;GAAO;GAAQ,EAAE,EAAE,MAAM,SAAS,CAAC;EAClD,aAAa;GAAE;GAAO;GAAQ,EAAE,EAAE,MAAM,SAAS,CAAC;EAGlD,YAAY;GAAE;GAAO;GAAQ,CAAC;EAI9B,eAAe;GAAE;GAAO;GAAQ,CAAC;EAGjC,kBAAkB;GAAE;GAAO;GAAQ,CAAC;EACrC;AAGD,QAAO;EACL;EACA;EACA,eAAe;AACb,YAAS,SAAS,YAAa,OAAO,YAAY,aAAa,SAAS,GAAG,QAAQ,SAAS,CAAE;AAE9F,QAAK,MAAM,SAAS,OAAO,OAAO,OAAO,KAAK,CAAC,CAC7C,KACE,UAAU,QACV,OAAO,UAAU,YACjB,OAAQ,MAAgC,YAAY,WAEnD,OAA8B,SAAS;AAG5C,qBAAkB;;EAErB"}

package/dist/dev/dom/playback-engine.d.ts

@@ -0,0 +1,4 @@
+import { PlaybackEngine, PlaybackEngineConfig, PlaybackEngineOwners, PlaybackEngineState, createPlaybackEngine } from "./playback-engine/engine.js";
+import { SpfMedia, SpfMediaAPI, SpfMediaMixin } from "./playback-engine/adapter.js";
+import { effect } from "../core/signals/effect.js";
+export { type PlaybackEngine, type PlaybackEngineConfig, type PlaybackEngineOwners, type PlaybackEngineState, SpfMedia, type SpfMediaAPI, SpfMediaMixin, createPlaybackEngine, effect };

package/dist/dev/dom/playback-engine.js

@@ -0,0 +1,4 @@
+import { effect } from "../core/signals/effect.js";
+import { createPlaybackEngine } from "./playback-engine/engine.js";
+import { SpfMedia, SpfMediaMixin } from "./playback-engine/adapter.js";
+export { SpfMedia, SpfMediaMixin, createPlaybackEngine, effect };

package/dist/dev/dom/text/parse-vtt-segment.d.ts

@@ -0,0 +1,12 @@
+//#region src/dom/text/parse-vtt-segment.d.ts
+/**
+ * Parse a VTT segment using browser's native parser.
+ *
+ * Creates a dummy video element with a track element to leverage
+ * the browser's optimized VTT parsing. Returns parsed VTTCue objects.
+ */
+declare function parseVttSegment(url: string): Promise<VTTCue[]>;
+declare function destroyVttParser(): void;
+//#endregion
+export { destroyVttParser, parseVttSegment };
+//# sourceMappingURL=parse-vtt-segment.d.ts.map

package/dist/dev/dom/text/parse-vtt-segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-vtt-segment.d.ts","names":[],"sources":["../../../../src/dom/text/parse-vtt-segment.ts"],"mappings":";;AAqBA;;;;;iBAAgB,eAAA,CAAgB,GAAA,WAAc,OAAA,CAAQ,MAAA;AAAA,iBA0CtC,gBAAA,CAAA"}