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

package/dist/default/media/dom/capabilities.js

@@ -0,0 +1,70 @@
+import { NON_FMP4_CONTAINER_MIMES } from "../hls/parse-media-playlist.js";
+import { buildMimeCodec, isCodecSupported } from "./mse/mediasource-setup.js";
+//#region src/media/dom/capabilities.ts
+/**
+* Capability probing — the engine's foundation for asking the browser what it
+* can actually decode before committing a rendition to the pipeline.
+*
+* Today this is the synchronous codec half: `canPlayTrack` answers "can this
+* environment play this track?" by building the track's MIME codec string and
+* passing it to `MediaSource.isTypeSupported` (via `isCodecSupported`). It's the
+* DOM implementation of the DOM-free `CanPlayTrack` predicate the
+* track-switching hard-constraint pre-pass consumes — injected through engine
+* config so the (DOM-free) behavior never imports a DOM API directly.
+*
+* Results are memoized by built MIME string: codec support is a pure function
+* of (codec, environment) and never changes after load, so probing is lazy
+* (per candidate, at constraint-apply time) but each unique MIME is asked once.
+*
+* Future cluster-D phases (async `requestMediaKeySystemAccess` key-system
+* probing, `SourceBuffer.changeType()` availability) extend this surface; the
+* async ones land as a state-slot writer behavior rather than a config
+* predicate, since their verdict resolves asynchronously.
+*/
+const codecSupportCache = /* @__PURE__ */ new Map();
+/**
+* Whether the environment can decode `track`, by codec. Builds the track's
+* MIME codec string and checks `MediaSource.isTypeSupported`, memoized by MIME.
+* A track without enough to probe — no `mimeType`, or no declared `codecs`
+* (CODECS is optional per the HLS spec) — is unprobeable and passes through as
+* playable (`true`) rather than being dropped; the late `createSourceBuffer`
+* check stays as the backstop for those.
+*
+* Detected non-fMP4 containers (`video/mp2t`, `audio/aac`) are asserted
+* unsupported regardless of the probe, so they're pruned before selection
+* (the type makes no pick) instead of failing/stalling deep in the pipeline.
+* Two different reasons, neither UA-based:
+*
+* - **MPEG-TS** can't be played at all here: `isTypeSupported('video/mp2t…')` is
+*   a genuine false positive on Chromium (reports `true` but appends produce no
+*   buffered range), and this engine has no TS transmux pipeline.
+* - **Raw ADTS AAC** is a *temporary* limitation. The browser genuinely
+*   supports it (Chrome/Safari decode `audio/aac`; Firefox doesn't), so it could
+*   be made playable — but our segment actors / loading behaviors / append
+*   pipeline assume every rendition has an `EXT-X-MAP` init segment (e.g. an
+*   `append-init` task with an empty URL, fMP4-shaped append handling). Until
+*   that init-segment assumption is removed, ADTS would fetch but never buffer
+*   (a silent stall), so we assert it unplayable for now. FOLLOW-UP: drop the
+*   init-required assumption in the pipeline and switch this to a bare-MIME
+*   probe (`buildMimeCodec` would project `audio/aac` with no codecs) so it
+*   plays where the browser supports it.
+*
+* Override via the engine's `canPlayTrack` config when those pipelines land.
+*/
+const canPlayTrack = (track) => {
+	if (track.mimeType && NON_FMP4_CONTAINER_MIMES.has(track.mimeType)) return false;
+	if (!track.mimeType || !track.codecs?.length) return true;
+	const mimeCodec = buildMimeCodec({
+		mimeType: track.mimeType,
+		codecs: track.codecs
+	});
+	const cached = codecSupportCache.get(mimeCodec);
+	if (cached !== void 0) return cached;
+	const supported = isCodecSupported(mimeCodec);
+	codecSupportCache.set(mimeCodec, supported);
+	return supported;
+};
+//#endregion
+export { canPlayTrack };
+
+//# sourceMappingURL=capabilities.js.map

package/dist/default/media/dom/capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.js","names":[],"sources":["../../../../src/media/dom/capabilities.ts"],"sourcesContent":["/**\n * Capability probing — the engine's foundation for asking the browser what it\n * can actually decode before committing a rendition to the pipeline.\n *\n * Today this is the synchronous codec half: `canPlayTrack` answers \"can this\n * environment play this track?\" by building the track's MIME codec string and\n * passing it to `MediaSource.isTypeSupported` (via `isCodecSupported`). It's the\n * DOM implementation of the DOM-free `CanPlayTrack` predicate the\n * track-switching hard-constraint pre-pass consumes — injected through engine\n * config so the (DOM-free) behavior never imports a DOM API directly.\n *\n * Results are memoized by built MIME string: codec support is a pure function\n * of (codec, environment) and never changes after load, so probing is lazy\n * (per candidate, at constraint-apply time) but each unique MIME is asked once.\n *\n * Future cluster-D phases (async `requestMediaKeySystemAccess` key-system\n * probing, `SourceBuffer.changeType()` availability) extend this surface; the\n * async ones land as a state-slot writer behavior rather than a config\n * predicate, since their verdict resolves asynchronously.\n */\n\nimport { NON_FMP4_CONTAINER_MIMES } from '../hls/parse-media-playlist';\nimport type { CanPlayTrack } from '../types';\nimport { buildMimeCodec, isCodecSupported } from './mse/mediasource-setup';\n\nconst codecSupportCache = new Map<string, boolean>();\n\n/**\n * Whether the environment can decode `track`, by codec. Builds the track's\n * MIME codec string and checks `MediaSource.isTypeSupported`, memoized by MIME.\n * A track without enough to probe — no `mimeType`, or no declared `codecs`\n * (CODECS is optional per the HLS spec) — is unprobeable and passes through as\n * playable (`true`) rather than being dropped; the late `createSourceBuffer`\n * check stays as the backstop for those.\n *\n * Detected non-fMP4 containers (`video/mp2t`, `audio/aac`) are asserted\n * unsupported regardless of the probe, so they're pruned before selection\n * (the type makes no pick) instead of failing/stalling deep in the pipeline.\n * Two different reasons, neither UA-based:\n *\n * - **MPEG-TS** can't be played at all here: `isTypeSupported('video/mp2t…')` is\n *   a genuine false positive on Chromium (reports `true` but appends produce no\n *   buffered range), and this engine has no TS transmux pipeline.\n * - **Raw ADTS AAC** is a *temporary* limitation. The browser genuinely\n *   supports it (Chrome/Safari decode `audio/aac`; Firefox doesn't), so it could\n *   be made playable — but our segment actors / loading behaviors / append\n *   pipeline assume every rendition has an `EXT-X-MAP` init segment (e.g. an\n *   `append-init` task with an empty URL, fMP4-shaped append handling). Until\n *   that init-segment assumption is removed, ADTS would fetch but never buffer\n *   (a silent stall), so we assert it unplayable for now. FOLLOW-UP: drop the\n *   init-required assumption in the pipeline and switch this to a bare-MIME\n *   probe (`buildMimeCodec` would project `audio/aac` with no codecs) so it\n *   plays where the browser supports it.\n *\n * Override via the engine's `canPlayTrack` config when those pipelines land.\n */\nexport const canPlayTrack: CanPlayTrack = (track) => {\n  if (track.mimeType && NON_FMP4_CONTAINER_MIMES.has(track.mimeType)) return false;\n  if (!track.mimeType || !track.codecs?.length) return true;\n  const mimeCodec = buildMimeCodec({ mimeType: track.mimeType, codecs: track.codecs });\n  const cached = codecSupportCache.get(mimeCodec);\n  if (cached !== undefined) return cached;\n  const supported = isCodecSupported(mimeCodec);\n  codecSupportCache.set(mimeCodec, supported);\n  return supported;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAM,oCAAoB,IAAI,KAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BpD,MAAa,gBAA8B,UAAU;AACnD,KAAI,MAAM,YAAY,yBAAyB,IAAI,MAAM,SAAS,CAAE,QAAO;AAC3E,KAAI,CAAC,MAAM,YAAY,CAAC,MAAM,QAAQ,OAAQ,QAAO;CACrD,MAAM,YAAY,eAAe;EAAE,UAAU,MAAM;EAAU,QAAQ,MAAM;EAAQ,CAAC;CACpF,MAAM,SAAS,kBAAkB,IAAI,UAAU;AAC/C,KAAI,WAAW,KAAA,EAAW,QAAO;CACjC,MAAM,YAAY,iBAAiB,UAAU;AAC7C,mBAAkB,IAAI,WAAW,UAAU;AAC3C,QAAO"}

package/dist/{dev/dom/media → default/media/dom/mse}/append-segment.js

@@ -1,4 +1,4 @@
-//#region src/dom/media/append-segment.ts
+//#region src/media/dom/mse/append-segment.ts
 /**
 * Append media data to a SourceBuffer.
 *

package/dist/default/media/dom/mse/append-segment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"append-segment.js","names":[],"sources":["../../../../../src/media/dom/mse/append-segment.ts"],"sourcesContent":["/**\n * Segment appender helper.\n *\n * Appends media data (ArrayBuffer or AsyncIterable<Uint8Array> stream) to a\n * SourceBuffer, waiting for `updateend` between calls so the browser can\n * process each append before the next one arrives.\n */\n\n/** Data accepted by appendSegment — a full buffer or an async chunk stream. */\nexport type AppendData = ArrayBuffer | AsyncIterable<Uint8Array>;\n\n/**\n * Append media data to a SourceBuffer.\n *\n * Accepts either a full ArrayBuffer (single append) or an AsyncIterable of\n * Uint8Array chunks (one append per chunk, in order). Waits for `updateend`\n * between each call so appends are serialized correctly.\n *\n * Errors from the SourceBuffer (`error` event) or from the iterable are\n * propagated as rejections.\n */\nexport async function appendSegment(sourceBuffer: SourceBuffer, data: AppendData, signal?: AbortSignal): Promise<void> {\n  if (data instanceof ArrayBuffer) {\n    await appendChunk(sourceBuffer, data);\n  } else {\n    try {\n      for await (const chunk of data) {\n        // Check between chunks so an abort can stop streaming before the next\n        // appendBuffer call. The current chunk (if any) has already landed in the\n        // SourceBuffer; the partial: true flag in the actor model reflects this.\n        if (signal?.aborted) throw signal.reason ?? new DOMException('Aborted', 'AbortError');\n        await appendChunk(sourceBuffer, chunk);\n      }\n    } catch (e) {\n      // Reset the MSE segment parser on any abort to discard partial fMP4 box\n      // data from the SourceBuffer's internal byte buffer. Two paths reach here:\n      //\n      // 1. Explicit abort check above (signal.aborted between chunks) — the\n      //    last appended chunk may have left the parser mid-fragment.\n      //\n      // 2. The fetch was cancelled (signal fired), causing the underlying\n      //    ReadableStream to error and the for-await loop to throw directly\n      //    without ever passing through the signal check above. Same cleanup\n      //    is needed: partial box data must be cleared before the next append.\n      //\n      // Without this, the next appendBuffer call sees stale partial data and\n      // Chrome throws CHUNK_DEMUXER_ERROR_APPEND_FAILED.\n      if (e instanceof DOMException && e.name === 'AbortError' && !sourceBuffer.updating) {\n        try {\n          sourceBuffer.abort();\n        } catch {\n          // Thrown if the MediaSource is not \"open\" (e.g. during teardown).\n        }\n      }\n      throw e;\n    }\n  }\n}\n\nasync function appendChunk(sourceBuffer: SourceBuffer, data: ArrayBuffer | Uint8Array<ArrayBufferLike>): Promise<void> {\n  if (sourceBuffer.updating) {\n    await new Promise<void>((resolve) => {\n      const onUpdateEnd = () => {\n        sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n        resolve();\n      };\n      sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    });\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    const onUpdateEnd = () => {\n      cleanup();\n      resolve();\n    };\n\n    const onError = (event: Event) => {\n      cleanup();\n      reject(new Error(`SourceBuffer append error: ${event.type}`));\n    };\n\n    const cleanup = () => {\n      sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n      sourceBuffer.removeEventListener('error', onError);\n    };\n\n    sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    sourceBuffer.addEventListener('error', onError);\n\n    try {\n      sourceBuffer.appendBuffer(data as ArrayBuffer);\n    } catch (error) {\n      cleanup();\n      reject(error);\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;AAqBA,eAAsB,cAAc,cAA4B,MAAkB,QAAqC;AACrH,KAAI,gBAAgB,YAClB,OAAM,YAAY,cAAc,KAAK;KAErC,KAAI;AACF,aAAW,MAAM,SAAS,MAAM;AAI9B,OAAI,QAAQ,QAAS,OAAM,OAAO,UAAU,IAAI,aAAa,WAAW,aAAa;AACrF,SAAM,YAAY,cAAc,MAAM;;UAEjC,GAAG;AAcV,MAAI,aAAa,gBAAgB,EAAE,SAAS,gBAAgB,CAAC,aAAa,SACxE,KAAI;AACF,gBAAa,OAAO;UACd;AAIV,QAAM;;;AAKZ,eAAe,YAAY,cAA4B,MAAgE;AACrH,KAAI,aAAa,SACf,OAAM,IAAI,SAAe,YAAY;EACnC,MAAM,oBAAoB;AACxB,gBAAa,oBAAoB,aAAa,YAAY;AAC1D,YAAS;;AAEX,eAAa,iBAAiB,aAAa,YAAY;GACvD;AAGJ,QAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,MAAM,oBAAoB;AACxB,YAAS;AACT,YAAS;;EAGX,MAAM,WAAW,UAAiB;AAChC,YAAS;AACT,0BAAO,IAAI,MAAM,8BAA8B,MAAM,OAAO,CAAC;;EAG/D,MAAM,gBAAgB;AACpB,gBAAa,oBAAoB,aAAa,YAAY;AAC1D,gBAAa,oBAAoB,SAAS,QAAQ;;AAGpD,eAAa,iBAAiB,aAAa,YAAY;AACvD,eAAa,iBAAiB,SAAS,QAAQ;AAE/C,MAAI;AACF,gBAAa,aAAa,KAAoB;WACvC,OAAO;AACd,YAAS;AACT,UAAO,MAAM;;GAEf"}

package/dist/default/{dom/media → media/dom/mse}/buffer-flusher.js

@@ -1,4 +1,4 @@
-//#region src/dom/media/buffer-flusher.ts
+//#region src/media/dom/mse/buffer-flusher.ts
 /**
 * Buffer flusher helper (P12)
 *

package/dist/default/media/dom/mse/buffer-flusher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-flusher.js","names":[],"sources":["../../../../../src/media/dom/mse/buffer-flusher.ts"],"sourcesContent":["/**\n * Buffer flusher helper (P12)\n *\n * Removes a time range from a SourceBuffer to manage memory.\n */\n\n/**\n * Remove a time range from a SourceBuffer.\n *\n * Waits for the SourceBuffer to be ready (not updating), then removes\n * the specified range. Returns a promise that resolves when removal completes.\n *\n * @param sourceBuffer - The SourceBuffer to remove data from\n * @param start - Start of the time range to remove (seconds)\n * @param end - End of the time range to remove (seconds)\n * @returns Promise that resolves when removal completes\n *\n * @example\n * await flushBuffer(videoSourceBuffer, 0, 30);\n */\nexport async function flushBuffer(sourceBuffer: SourceBuffer, start: number, end: number): Promise<void> {\n  // Wait for SourceBuffer to be ready (not currently updating)\n  if (sourceBuffer.updating) {\n    await new Promise<void>((resolve) => {\n      const onUpdateEnd = () => {\n        sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n        resolve();\n      };\n      sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    });\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    const onUpdateEnd = () => {\n      cleanup();\n      resolve();\n    };\n\n    const onError = (event: Event) => {\n      cleanup();\n      reject(new Error(`SourceBuffer remove error: ${event.type}`));\n    };\n\n    const cleanup = () => {\n      sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n      sourceBuffer.removeEventListener('error', onError);\n    };\n\n    sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    sourceBuffer.addEventListener('error', onError);\n\n    try {\n      sourceBuffer.remove(start, end);\n    } catch (error) {\n      cleanup();\n      reject(error);\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,eAAsB,YAAY,cAA4B,OAAe,KAA4B;AAEvG,KAAI,aAAa,SACf,OAAM,IAAI,SAAe,YAAY;EACnC,MAAM,oBAAoB;AACxB,gBAAa,oBAAoB,aAAa,YAAY;AAC1D,YAAS;;AAEX,eAAa,iBAAiB,aAAa,YAAY;GACvD;AAGJ,QAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,MAAM,oBAAoB;AACxB,YAAS;AACT,YAAS;;EAGX,MAAM,WAAW,UAAiB;AAChC,YAAS;AACT,0BAAO,IAAI,MAAM,8BAA8B,MAAM,OAAO,CAAC;;EAG/D,MAAM,gBAAgB;AACpB,gBAAa,oBAAoB,aAAa,YAAY;AAC1D,gBAAa,oBAAoB,SAAS,QAAQ;;AAGpD,eAAa,iBAAiB,aAAa,YAAY;AACvD,eAAa,iBAAiB,SAAS,QAAQ;AAE/C,MAAI;AACF,gBAAa,OAAO,OAAO,IAAI;WACxB,OAAO;AACd,YAAS;AACT,UAAO,MAAM;;GAEf"}

package/dist/default/media/dom/mse/duration.js

@@ -0,0 +1,78 @@
+import { hasPresentationDuration } from "../../types/index.js";
+//#region src/media/dom/mse/duration.ts
+/**
+* Check if we have the basics to update MediaSource duration:
+* a `mediaSource` and a `presentation` with a numeric duration.
+*/
+function canUpdateDuration(presentation, mediaSource) {
+	return !!(mediaSource && presentation && hasPresentationDuration(presentation));
+}
+/**
+* Get the maximum buffered end time across an iterable of SourceBuffers
+* (typically `mediaSource.sourceBuffers`). Returns `0` when the collection is
+* empty or no buffer has any buffered ranges.
+*/
+function getMaxBufferedEnd(buffers) {
+	let maxEnd = 0;
+	for (const buffer of buffers) {
+		const { buffered } = buffer;
+		if (buffered.length > 0) {
+			const end = buffered.end(buffered.length - 1);
+			if (end > maxEnd) maxEnd = end;
+		}
+	}
+	return maxEnd;
+}
+/**
+* Check if the preconditions are met to *attempt* a `mediaSource.duration`
+* write: a `mediaSource` is in scope and the presentation has a valid
+* positive duration (or `Infinity` for live).
+*
+* Does **not** check `mediaSource.readyState` or `mediaSource.duration` —
+* those are DOM properties the caller resolves at write time (e.g., by
+* `await`ing `waitForMediaSourceOpen` and re-checking `readyState` after,
+* and guarding on the existing `mediaSource.duration` for idempotency).
+* Keeping these off the signal-driven predicate lets callers use this
+* inside reactor state derivation without smuggling non-reactive DOM
+* reads into `computed(...)`.
+*
+* `Infinity` is allowed — per the MSE spec, `mediaSource.duration = +Infinity`
+* is how live playback signals an indefinite duration.
+*/
+function shouldUpdateDuration(presentation, mediaSource) {
+	if (!canUpdateDuration(presentation, mediaSource)) return false;
+	const duration = presentation.duration;
+	if (Number.isNaN(duration) || duration <= 0) return false;
+	return true;
+}
+/**
+* Wait for all currently-updating SourceBuffers in `buffers` to finish, or
+* until `signal` aborts — whichever fires first.
+*
+* The MSE spec forbids setting `MediaSource.duration` while any attached
+* SourceBuffer has `updating === true`. This defers until all are idle.
+* Listeners are registered with `{ signal }` so an abort tears them down
+* up-front rather than leaving them dangling until the next `updateend`.
+*/
+function waitForSourceBuffersReady(buffers, signal) {
+	if (signal.aborted) return Promise.resolve();
+	const updating = [];
+	for (const buf of buffers) if (buf.updating) updating.push(buf);
+	if (updating.length === 0) return Promise.resolve();
+	return new Promise((resolve) => {
+		let remaining = updating.length;
+		const onUpdateEnd = () => {
+			remaining--;
+			if (remaining === 0) resolve();
+		};
+		for (const buf of updating) buf.addEventListener("updateend", onUpdateEnd, {
+			once: true,
+			signal
+		});
+		signal.addEventListener("abort", () => resolve(), { once: true });
+	});
+}
+//#endregion
+export { getMaxBufferedEnd, shouldUpdateDuration, waitForSourceBuffersReady };
+
+//# sourceMappingURL=duration.js.map

package/dist/default/media/dom/mse/duration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.js","names":[],"sources":["../../../../../src/media/dom/mse/duration.ts"],"sourcesContent":["/**\n * MediaSource duration helpers.\n *\n * Predicates and async primitives for propagating a presentation's duration\n * to `mediaSource.duration` under the MSE spec's constraints:\n *\n * - `duration` cannot be set while any attached SourceBuffer is `updating`.\n * - `duration` cannot be less than any buffered range's end time.\n *\n * The buffer-set helpers take a `SourceBufferList` (or any iterable of\n * `SourceBuffer`) — they operate uniformly across whatever buffers are\n * attached, so callers in audio-only, video-only, and mixed configurations\n * compose them without per-type plumbing. `mediaSource.sourceBuffers` is the\n * canonical aggregate.\n *\n * Consumed by `updateMediaSourceDuration` (DOM behavior) — kept here so the layering\n * stays clean: the predicates and wait helper are pure DOM/MSE primitives\n * with no `core/` reactivity.\n */\n\nimport type { MaybeResolvedPresentation } from '../../types';\nimport { hasPresentationDuration } from '../../types';\n\ntype SourceBufferIterable = SourceBufferList | Iterable<SourceBuffer>;\n\n/**\n * Check if we have the basics to update MediaSource duration:\n * a `mediaSource` and a `presentation` with a numeric duration.\n */\nexport function canUpdateDuration(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined\n): boolean {\n  return !!(mediaSource && presentation && hasPresentationDuration(presentation));\n}\n\n/**\n * Get the maximum buffered end time across an iterable of SourceBuffers\n * (typically `mediaSource.sourceBuffers`). Returns `0` when the collection is\n * empty or no buffer has any buffered ranges.\n */\nexport function getMaxBufferedEnd(buffers: SourceBufferIterable): number {\n  let maxEnd = 0;\n\n  for (const buffer of buffers) {\n    const { buffered } = buffer;\n    if (buffered.length > 0) {\n      const end = buffered.end(buffered.length - 1);\n      if (end > maxEnd) {\n        maxEnd = end;\n      }\n    }\n  }\n\n  return maxEnd;\n}\n\n/**\n * Check if the preconditions are met to *attempt* a `mediaSource.duration`\n * write: a `mediaSource` is in scope and the presentation has a valid\n * positive duration (or `Infinity` for live).\n *\n * Does **not** check `mediaSource.readyState` or `mediaSource.duration` —\n * those are DOM properties the caller resolves at write time (e.g., by\n * `await`ing `waitForMediaSourceOpen` and re-checking `readyState` after,\n * and guarding on the existing `mediaSource.duration` for idempotency).\n * Keeping these off the signal-driven predicate lets callers use this\n * inside reactor state derivation without smuggling non-reactive DOM\n * reads into `computed(...)`.\n *\n * `Infinity` is allowed — per the MSE spec, `mediaSource.duration = +Infinity`\n * is how live playback signals an indefinite duration.\n */\nexport function shouldUpdateDuration(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined\n): boolean {\n  if (!canUpdateDuration(presentation, mediaSource)) return false;\n\n  const duration = presentation!.duration!;\n\n  if (Number.isNaN(duration) || duration <= 0) return false;\n\n  return true;\n}\n\n/**\n * Wait for all currently-updating SourceBuffers in `buffers` to finish, or\n * until `signal` aborts — whichever fires first.\n *\n * The MSE spec forbids setting `MediaSource.duration` while any attached\n * SourceBuffer has `updating === true`. This defers until all are idle.\n * Listeners are registered with `{ signal }` so an abort tears them down\n * up-front rather than leaving them dangling until the next `updateend`.\n */\nexport function waitForSourceBuffersReady(buffers: SourceBufferIterable, signal: AbortSignal): Promise<void> {\n  if (signal.aborted) return Promise.resolve();\n\n  const updating: SourceBuffer[] = [];\n  for (const buf of buffers) {\n    if (buf.updating) updating.push(buf);\n  }\n\n  if (updating.length === 0) return Promise.resolve();\n\n  return new Promise<void>((resolve) => {\n    let remaining = updating.length;\n    const onUpdateEnd = () => {\n      remaining--;\n      if (remaining === 0) resolve();\n    };\n\n    for (const buf of updating) {\n      buf.addEventListener('updateend', onUpdateEnd, { once: true, signal });\n    }\n\n    signal.addEventListener('abort', () => resolve(), { once: true });\n  });\n}\n"],"mappings":";;;;;;AA6BA,SAAgB,kBACd,cACA,aACS;AACT,QAAO,CAAC,EAAE,eAAe,gBAAgB,wBAAwB,aAAa;;;;;;;AAQhF,SAAgB,kBAAkB,SAAuC;CACvE,IAAI,SAAS;AAEb,MAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,EAAE,aAAa;AACrB,MAAI,SAAS,SAAS,GAAG;GACvB,MAAM,MAAM,SAAS,IAAI,SAAS,SAAS,EAAE;AAC7C,OAAI,MAAM,OACR,UAAS;;;AAKf,QAAO;;;;;;;;;;;;;;;;;;AAmBT,SAAgB,qBACd,cACA,aACS;AACT,KAAI,CAAC,kBAAkB,cAAc,YAAY,CAAE,QAAO;CAE1D,MAAM,WAAW,aAAc;AAE/B,KAAI,OAAO,MAAM,SAAS,IAAI,YAAY,EAAG,QAAO;AAEpD,QAAO;;;;;;;;;;;AAYT,SAAgB,0BAA0B,SAA+B,QAAoC;AAC3G,KAAI,OAAO,QAAS,QAAO,QAAQ,SAAS;CAE5C,MAAM,WAA2B,EAAE;AACnC,MAAK,MAAM,OAAO,QAChB,KAAI,IAAI,SAAU,UAAS,KAAK,IAAI;AAGtC,KAAI,SAAS,WAAW,EAAG,QAAO,QAAQ,SAAS;AAEnD,QAAO,IAAI,SAAe,YAAY;EACpC,IAAI,YAAY,SAAS;EACzB,MAAM,oBAAoB;AACxB;AACA,OAAI,cAAc,EAAG,UAAS;;AAGhC,OAAK,MAAM,OAAO,SAChB,KAAI,iBAAiB,aAAa,aAAa;GAAE,MAAM;GAAM;GAAQ,CAAC;AAGxE,SAAO,iBAAiB,eAAe,SAAS,EAAE,EAAE,MAAM,MAAM,CAAC;GACjE"}

package/dist/default/media/dom/mse/end-of-stream.js

@@ -0,0 +1,20 @@
+//#region src/media/dom/mse/end-of-stream.ts
+/**
+* Check if the temporally last segment of `expectedSegments` is present in
+* `appendedSegments` and not marked partial.
+*
+* Compares by segment ID rather than by a pipeline flag, so the result
+* stays correct across quality switches (different tracks have different
+* segment IDs) and back-buffer flushes (flushed segment IDs are removed
+* from the appended list).
+*/
+function isLastSegmentAppended(expectedSegments, appendedSegments) {
+	if (expectedSegments.length === 0) return true;
+	const lastSeg = expectedSegments[expectedSegments.length - 1];
+	if (!lastSeg) return false;
+	return appendedSegments?.some((s) => s.id === lastSeg.id && !s.partial) ?? false;
+}
+//#endregion
+export { isLastSegmentAppended };
+
+//# sourceMappingURL=end-of-stream.js.map

package/dist/default/media/dom/mse/end-of-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"end-of-stream.js","names":[],"sources":["../../../../../src/media/dom/mse/end-of-stream.ts"],"sourcesContent":["/**\n * End-of-stream detection helpers.\n *\n * Pure predicate that compares a track's expected segment list against the\n * appended-segment list from an MSE SourceBufferActor's snapshot. Consumed\n * by the `endOfStream` playback behavior to decide when to call\n * `MediaSource.endOfStream()`.\n *\n * Kept here so the layering stays clean: predicate has no `core/`\n * reactivity and operates on plain segment lists extracted by the caller.\n */\n\n/**\n * Minimum information about an appended segment needed to decide whether\n * it counts toward end-of-stream readiness.\n *\n * Matches the shape of `SourceBufferActor`'s context segments — callers\n * typically pass `actor.snapshot.get().context.segments` directly.\n */\nexport interface AppendedSegment {\n  id: string;\n  /**\n   * True while a streaming append is in progress for this segment. A\n   * partial segment is still streaming — it does not count as the last\n   * segment being ready.\n   */\n  partial?: boolean;\n}\n\n/**\n * Check if the temporally last segment of `expectedSegments` is present in\n * `appendedSegments` and not marked partial.\n *\n * Compares by segment ID rather than by a pipeline flag, so the result\n * stays correct across quality switches (different tracks have different\n * segment IDs) and back-buffer flushes (flushed segment IDs are removed\n * from the appended list).\n */\nexport function isLastSegmentAppended(\n  expectedSegments: readonly { id: string }[],\n  appendedSegments: readonly AppendedSegment[] | undefined\n): boolean {\n  if (expectedSegments.length === 0) return true;\n  const lastSeg = expectedSegments[expectedSegments.length - 1];\n  if (!lastSeg) return false;\n  return appendedSegments?.some((s) => s.id === lastSeg.id && !s.partial) ?? false;\n}\n"],"mappings":";;;;;;;;;;AAsCA,SAAgB,sBACd,kBACA,kBACS;AACT,KAAI,iBAAiB,WAAW,EAAG,QAAO;CAC1C,MAAM,UAAU,iBAAiB,iBAAiB,SAAS;AAC3D,KAAI,CAAC,QAAS,QAAO;AACrB,QAAO,kBAAkB,MAAM,MAAM,EAAE,OAAO,QAAQ,MAAM,CAAC,EAAE,QAAQ,IAAI"}

package/dist/default/{dom/media → media/dom/mse}/mediasource-setup.js

@@ -1,5 +1,4 @@
-import { signal } from "../../core/signals/primitives.js";
-//#region src/dom/media/mediasource-setup.ts
+//#region src/media/dom/mse/mediasource-setup.ts
 /**
 * MediaSource Setup
 *
@@ -97,6 +96,22 @@ function createSourceBuffer(mediaSource, mimeCodec) {
 	return mediaSource.addSourceBuffer(mimeCodec);
 }
 /**
+* Build a MIME codec string from a track's `mimeType` + `codecs`. Works
+* on partially-resolved tracks — both fields come from the multivariant
+* playlist and are available before media-playlist resolution.
+*
+* @param track - Track carrying `mimeType` and `codecs`
+* @returns MIME codec string suitable for `MediaSource.addSourceBuffer`
+*
+* @example
+* buildMimeCodec({ mimeType: 'video/mp4', codecs: ['avc1.42E01E'] })
+* // => 'video/mp4; codecs="avc1.42E01E"'
+*/
+function buildMimeCodec(track) {
+	const codecString = track.codecs?.join(",") ?? "";
+	return `${track.mimeType}; codecs="${codecString}"`;
+}
+/**
 * Check if a codec is supported.
 *
 * @param mimeCodec - MIME type with codecs string
@@ -112,35 +127,65 @@ function isCodecSupported(mimeCodec) {
 	return MediaSource.isTypeSupported(mimeCodec);
 }
 /**
-* Create a reactive signal that mirrors `mediaSource.readyState`.
+* Observe `mediaSource.readyState` changes via DOM events.
 *
-* Listens to `sourceopen`, `sourceended`, and `sourceclose` events and updates
-* the signal accordingly, making readyState visible to the TC39 signal graph.
-* Listeners are automatically removed when `signal` is aborted.
+* Listens to `sourceopen`, `sourceended`, and `sourceclose` and invokes
+* `onChange` with the current `readyState` after each event. Listeners
+* are automatically removed when `abortSignal` is aborted.
 *
 * @param mediaSource - The MediaSource to observe
-* @param signal - AbortSignal that controls listener lifetime
-* @returns A `Signal.ReadonlyState` that reflects the current `readyState`
+* @param abortSignal - AbortSignal that controls listener lifetime
+* @param onChange - Called with the current readyState after each change
 *
 * @example
 * const controller = new AbortController();
-* const readyState = observeMediaSourceReadyState(mediaSource, controller.signal);
-* effect(() => {
-*   if (readyState.get() === 'open') { ... }
+* onMediaSourceReadyStateChange(mediaSource, controller.signal, (state) => {
+*   if (state === 'open') { ... }
 * });
-* // Later:
-* controller.abort();
+* // Later: controller.abort();
 */
-function observeMediaSourceReadyState(mediaSource, abortSignal) {
-	const readyState = signal(mediaSource.readyState);
-	const update = () => readyState.set(mediaSource.readyState);
+function onMediaSourceReadyStateChange(mediaSource, abortSignal, onChange) {
+	const update = () => onChange(mediaSource.readyState);
 	const options = { signal: abortSignal };
 	mediaSource.addEventListener("sourceopen", update, options);
 	mediaSource.addEventListener("sourceended", update, options);
 	mediaSource.addEventListener("sourceclose", update, options);
-	return readyState;
+}
+/**
+* Wait until `mediaSource.readyState` transitions away from `'closed'`
+* (the next `sourceopen`/`sourceended`/`sourceclose` event), or until
+* `signal` aborts — whichever fires first.
+*
+* Resolves immediately when `readyState` is already `'open'` or `'ended'`
+* (no further transition is coming, so there's nothing to wait for). The
+* caller is expected to re-check `readyState` after the await to
+* distinguish `'open'` from terminal states.
+*
+* Companion to `onMediaSourceReadyStateChange` for one-shot use in async
+* sequences (e.g., a behavior's reactor entry that needs to wait for the
+* MediaSource to attach before performing a spec-conforming mutation).
+*
+* @example
+* await waitForMediaSourceOpen(mediaSource, signal);
+* if (signal.aborted || mediaSource.readyState !== 'open') return;
+* // safe to perform 'open'-state-only work
+*/
+function waitForMediaSourceOpen(mediaSource, signal) {
+	if (signal.aborted) return Promise.resolve();
+	if (mediaSource.readyState !== "closed") return Promise.resolve();
+	return new Promise((resolve) => {
+		const done = () => resolve();
+		const options = {
+			once: true,
+			signal
+		};
+		mediaSource.addEventListener("sourceopen", done, options);
+		mediaSource.addEventListener("sourceended", done, options);
+		mediaSource.addEventListener("sourceclose", done, options);
+		signal.addEventListener("abort", done, { once: true });
+	});
 }
 //#endregion
-export { attachMediaSource, createMediaSource, createSourceBuffer, observeMediaSourceReadyState };
+export { attachMediaSource, buildMimeCodec, createMediaSource, createSourceBuffer, isCodecSupported, onMediaSourceReadyStateChange, waitForMediaSourceOpen };
 
 //# sourceMappingURL=mediasource-setup.js.map

package/dist/default/media/dom/mse/mediasource-setup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediasource-setup.js","names":[],"sources":["../../../../../src/media/dom/mse/mediasource-setup.ts"],"sourcesContent":["/**\n * MediaSource Setup\n *\n * Utilities for creating and configuring MediaSource/ManagedMediaSource\n * for MSE (Media Source Extensions) playback.\n *\n * Global ManagedMediaSource types are defined in ./mediasource.d.ts\n */\n\n/**\n * Check if MediaSource API is supported.\n */\nexport function supportsMediaSource(): boolean {\n  return typeof MediaSource !== 'undefined';\n}\n\n/**\n * Check if ManagedMediaSource API is supported.\n * ManagedMediaSource is a newer Safari API with better lifecycle management.\n */\nexport function supportsManagedMediaSource(): boolean {\n  return typeof ManagedMediaSource !== 'undefined';\n}\n\n/**\n * Options for creating a MediaSource.\n */\nexport interface CreateMediaSourceOptions {\n  /** Prefer ManagedMediaSource when available (default: false for broader compatibility). */\n  preferManaged?: boolean;\n}\n\n/**\n * Create a MediaSource or ManagedMediaSource instance.\n *\n * @param options - Creation options\n * @returns A MediaSource or ManagedMediaSource instance\n * @throws Error if no MediaSource API is available\n *\n * @example\n * const mediaSource = createMediaSource();\n * const mediaElement = document.querySelector('video');\n * attachMediaSource(mediaSource, mediaElement);\n */\nexport function createMediaSource(options: CreateMediaSourceOptions = {}): MediaSource {\n  const { preferManaged = false } = options;\n\n  if (preferManaged && supportsManagedMediaSource()) {\n    return new ManagedMediaSource!();\n  }\n\n  if (supportsMediaSource()) {\n    return new MediaSource();\n  }\n\n  throw new Error('MediaSource API is not supported');\n}\n\n/**\n * Result of attaching a MediaSource to a media element.\n */\nexport interface AttachMediaSourceResult {\n  /** The object URL created for the MediaSource (empty string for ManagedMediaSource). */\n  url: string;\n  /** Detach the MediaSource and clean up resources. */\n  detach: () => void;\n}\n\n/**\n * Attach a MediaSource to an HTMLMediaElement.\n *\n * Uses srcObject for ManagedMediaSource (Safari), or createObjectURL for regular MediaSource.\n *\n * @param mediaSource - The MediaSource to attach\n * @param mediaElement - The media element to attach to\n * @returns Object with URL and detach function\n *\n * @example\n * const mediaSource = createMediaSource();\n * const { detach } = attachMediaSource(mediaSource, videoElement);\n * // Use mediaSource...\n * // Later, to clean up:\n * detach();\n */\nexport function attachMediaSource(mediaSource: MediaSource, mediaElement: HTMLMediaElement): AttachMediaSourceResult {\n  // ManagedMediaSource requires srcObject instead of createObjectURL\n  const isManagedMediaSource = supportsManagedMediaSource() && mediaSource instanceof ManagedMediaSource!;\n\n  if (isManagedMediaSource) {\n    // ManagedMediaSource requires disableRemotePlayback — without it Safari\n    // will not fire sourceopen.\n    (mediaElement as HTMLMediaElement & { disableRemotePlayback: boolean }).disableRemotePlayback = true;\n\n    // Use srcObject for ManagedMediaSource\n    (mediaElement as HTMLMediaElement & { srcObject: MediaSource | null }).srcObject = mediaSource;\n\n    const detach = (): void => {\n      (mediaElement as HTMLMediaElement & { srcObject: MediaSource | null }).srcObject = null;\n      mediaElement.load(); // Reset the element\n    };\n\n    return { url: '', detach };\n  }\n\n  // Use createObjectURL for regular MediaSource\n  const url = URL.createObjectURL(mediaSource);\n  mediaElement.src = url;\n\n  const detach = (): void => {\n    mediaElement.removeAttribute('src');\n    mediaElement.load(); // Reset the element\n    URL.revokeObjectURL(url);\n  };\n\n  return { url, detach };\n}\n\n/**\n * Create a SourceBuffer on a MediaSource.\n *\n * @param mediaSource - The MediaSource (must be in 'open' state)\n * @param mimeCodec - MIME type with codecs (e.g., 'video/mp4; codecs=\"avc1.42E01E\"')\n * @returns The created SourceBuffer\n * @throws Error if MediaSource is not open or codec is unsupported\n *\n * @example\n * const buffer = createSourceBuffer(mediaSource, 'video/mp4; codecs=\"avc1.42E01E\"');\n */\nexport function createSourceBuffer(mediaSource: MediaSource, mimeCodec: string): SourceBuffer {\n  if (mediaSource.readyState !== 'open') {\n    throw new Error('MediaSource is not open');\n  }\n\n  if (!isCodecSupported(mimeCodec)) {\n    throw new Error(`Codec not supported: ${mimeCodec}`);\n  }\n\n  return mediaSource.addSourceBuffer(mimeCodec);\n}\n\n/**\n * Build a MIME codec string from a track's `mimeType` + `codecs`. Works\n * on partially-resolved tracks — both fields come from the multivariant\n * playlist and are available before media-playlist resolution.\n *\n * @param track - Track carrying `mimeType` and `codecs`\n * @returns MIME codec string suitable for `MediaSource.addSourceBuffer`\n *\n * @example\n * buildMimeCodec({ mimeType: 'video/mp4', codecs: ['avc1.42E01E'] })\n * // => 'video/mp4; codecs=\"avc1.42E01E\"'\n */\nexport function buildMimeCodec(track: { mimeType: string; codecs?: string[] }): string {\n  const codecString = track.codecs?.join(',') ?? '';\n  return `${track.mimeType}; codecs=\"${codecString}\"`;\n}\n\n/**\n * Check if a codec is supported.\n *\n * @param mimeCodec - MIME type with codecs string\n * @returns True if the codec is supported\n *\n * @example\n * if (isCodecSupported('video/mp4; codecs=\"avc1.42E01E\"')) {\n *   // Create source buffer\n * }\n */\nexport function isCodecSupported(mimeCodec: string): boolean {\n  if (!supportsMediaSource()) {\n    return false;\n  }\n\n  return MediaSource.isTypeSupported(mimeCodec);\n}\n\n/**\n * Observe `mediaSource.readyState` changes via DOM events.\n *\n * Listens to `sourceopen`, `sourceended`, and `sourceclose` and invokes\n * `onChange` with the current `readyState` after each event. Listeners\n * are automatically removed when `abortSignal` is aborted.\n *\n * @param mediaSource - The MediaSource to observe\n * @param abortSignal - AbortSignal that controls listener lifetime\n * @param onChange - Called with the current readyState after each change\n *\n * @example\n * const controller = new AbortController();\n * onMediaSourceReadyStateChange(mediaSource, controller.signal, (state) => {\n *   if (state === 'open') { ... }\n * });\n * // Later: controller.abort();\n */\nexport function onMediaSourceReadyStateChange(\n  mediaSource: MediaSource,\n  abortSignal: AbortSignal,\n  onChange: (readyState: MediaSource['readyState']) => void\n): void {\n  const update = () => onChange(mediaSource.readyState);\n  const options = { signal: abortSignal };\n  mediaSource.addEventListener('sourceopen', update, options);\n  mediaSource.addEventListener('sourceended', update, options);\n  mediaSource.addEventListener('sourceclose', update, options);\n}\n\n/**\n * Wait until `mediaSource.readyState` transitions away from `'closed'`\n * (the next `sourceopen`/`sourceended`/`sourceclose` event), or until\n * `signal` aborts — whichever fires first.\n *\n * Resolves immediately when `readyState` is already `'open'` or `'ended'`\n * (no further transition is coming, so there's nothing to wait for). The\n * caller is expected to re-check `readyState` after the await to\n * distinguish `'open'` from terminal states.\n *\n * Companion to `onMediaSourceReadyStateChange` for one-shot use in async\n * sequences (e.g., a behavior's reactor entry that needs to wait for the\n * MediaSource to attach before performing a spec-conforming mutation).\n *\n * @example\n * await waitForMediaSourceOpen(mediaSource, signal);\n * if (signal.aborted || mediaSource.readyState !== 'open') return;\n * // safe to perform 'open'-state-only work\n */\nexport function waitForMediaSourceOpen(mediaSource: MediaSource, signal: AbortSignal): Promise<void> {\n  if (signal.aborted) return Promise.resolve();\n  if (mediaSource.readyState !== 'closed') return Promise.resolve();\n\n  return new Promise<void>((resolve) => {\n    const done = () => resolve();\n    const options = { once: true, signal };\n    mediaSource.addEventListener('sourceopen', done, options);\n    mediaSource.addEventListener('sourceended', done, options);\n    mediaSource.addEventListener('sourceclose', done, options);\n    signal.addEventListener('abort', done, { once: true });\n  });\n}\n"],"mappings":";;;;;;;;;;;;AAYA,SAAgB,sBAA+B;AAC7C,QAAO,OAAO,gBAAgB;;;;;;AAOhC,SAAgB,6BAAsC;AACpD,QAAO,OAAO,uBAAuB;;;;;;;;;;;;;;AAuBvC,SAAgB,kBAAkB,UAAoC,EAAE,EAAe;CACrF,MAAM,EAAE,gBAAgB,UAAU;AAElC,KAAI,iBAAiB,4BAA4B,CAC/C,QAAO,IAAI,oBAAqB;AAGlC,KAAI,qBAAqB,CACvB,QAAO,IAAI,aAAa;AAG1B,OAAM,IAAI,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;AA6BrD,SAAgB,kBAAkB,aAA0B,cAAyD;AAInH,KAF6B,4BAA4B,IAAI,uBAAuB,oBAE1D;AAGvB,eAAuE,wBAAwB;AAG/F,eAAsE,YAAY;EAEnF,MAAM,eAAqB;AACxB,gBAAsE,YAAY;AACnF,gBAAa,MAAM;;AAGrB,SAAO;GAAE,KAAK;GAAI;GAAQ;;CAI5B,MAAM,MAAM,IAAI,gBAAgB,YAAY;AAC5C,cAAa,MAAM;CAEnB,MAAM,eAAqB;AACzB,eAAa,gBAAgB,MAAM;AACnC,eAAa,MAAM;AACnB,MAAI,gBAAgB,IAAI;;AAG1B,QAAO;EAAE;EAAK;EAAQ;;;;;;;;;;;;;AAcxB,SAAgB,mBAAmB,aAA0B,WAAiC;AAC5F,KAAI,YAAY,eAAe,OAC7B,OAAM,IAAI,MAAM,0BAA0B;AAG5C,KAAI,CAAC,iBAAiB,UAAU,CAC9B,OAAM,IAAI,MAAM,wBAAwB,YAAY;AAGtD,QAAO,YAAY,gBAAgB,UAAU;;;;;;;;;;;;;;AAe/C,SAAgB,eAAe,OAAwD;CACrF,MAAM,cAAc,MAAM,QAAQ,KAAK,IAAI,IAAI;AAC/C,QAAO,GAAG,MAAM,SAAS,YAAY,YAAY;;;;;;;;;;;;;AAcnD,SAAgB,iBAAiB,WAA4B;AAC3D,KAAI,CAAC,qBAAqB,CACxB,QAAO;AAGT,QAAO,YAAY,gBAAgB,UAAU;;;;;;;;;;;;;;;;;;;;AAqB/C,SAAgB,8BACd,aACA,aACA,UACM;CACN,MAAM,eAAe,SAAS,YAAY,WAAW;CACrD,MAAM,UAAU,EAAE,QAAQ,aAAa;AACvC,aAAY,iBAAiB,cAAc,QAAQ,QAAQ;AAC3D,aAAY,iBAAiB,eAAe,QAAQ,QAAQ;AAC5D,aAAY,iBAAiB,eAAe,QAAQ,QAAQ;;;;;;;;;;;;;;;;;;;;;AAsB9D,SAAgB,uBAAuB,aAA0B,QAAoC;AACnG,KAAI,OAAO,QAAS,QAAO,QAAQ,SAAS;AAC5C,KAAI,YAAY,eAAe,SAAU,QAAO,QAAQ,SAAS;AAEjE,QAAO,IAAI,SAAe,YAAY;EACpC,MAAM,aAAa,SAAS;EAC5B,MAAM,UAAU;GAAE,MAAM;GAAM;GAAQ;AACtC,cAAY,iBAAiB,cAAc,MAAM,QAAQ;AACzD,cAAY,iBAAiB,eAAe,MAAM,QAAQ;AAC1D,cAAY,iBAAiB,eAAe,MAAM,QAAQ;AAC1D,SAAO,iBAAiB,SAAS,MAAM,EAAE,MAAM,MAAM,CAAC;GACtD"}

package/dist/default/{dom/text/parse-vtt-segment.js → media/dom/text/resolve-vtt-segment.js}

@@ -1,4 +1,4 @@
-//#region src/dom/text/parse-vtt-segment.ts
+//#region src/media/dom/text/resolve-vtt-segment.ts
 /**
 * Parse a VTT segment using browser's native parser.
 *
@@ -16,7 +16,7 @@ function ensureDummyVideo() {
 	}
 	return dummyVideo;
 }
-function parseVttSegment(url) {
+function resolveVttSegment(url) {
 	const video = ensureDummyVideo();
 	const track = document.createElement("track");
 	track.kind = "subtitles";
@@ -47,10 +47,10 @@ function parseVttSegment(url) {
 		track.src = url;
 	});
 }
-function destroyVttParser() {
+function destroyVttResolver() {
 	dummyVideo = null;
 }
 //#endregion
-export { destroyVttParser, parseVttSegment };
+export { destroyVttResolver, resolveVttSegment };
 
-//# sourceMappingURL=parse-vtt-segment.js.map
+//# sourceMappingURL=resolve-vtt-segment.js.map

package/dist/default/media/dom/text/resolve-vtt-segment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-vtt-segment.js","names":[],"sources":["../../../../../src/media/dom/text/resolve-vtt-segment.ts"],"sourcesContent":["/**\n * Parse a VTT segment using browser's native parser.\n *\n * Creates a dummy video element with a track element to leverage\n * the browser's optimized VTT parsing. Returns parsed VTTCue objects.\n */\n\n// Singleton dummy video (reused across all parsing)\nlet dummyVideo: HTMLVideoElement | null = null;\n\nfunction ensureDummyVideo(): HTMLVideoElement {\n  if (!dummyVideo) {\n    dummyVideo = document.createElement('video');\n    dummyVideo.muted = true;\n    dummyVideo.preload = 'none';\n    dummyVideo.style.display = 'none';\n    dummyVideo.crossOrigin = 'anonymous';\n  }\n  return dummyVideo;\n}\n\nexport function resolveVttSegment(url: string): Promise<VTTCue[]> {\n  const video = ensureDummyVideo();\n  const track = document.createElement('track');\n  track.kind = 'subtitles';\n  track.default = true;\n\n  return new Promise((resolve, reject) => {\n    const onLoad = (): void => {\n      const cues: VTTCue[] = [];\n      const textTrack = track.track;\n\n      if (textTrack.cues) {\n        for (let i = 0; i < textTrack.cues.length; i++) {\n          const cue = textTrack.cues[i];\n          if (cue) {\n            cues.push(cue as VTTCue);\n          }\n        }\n      }\n\n      cleanup();\n      resolve(cues);\n    };\n\n    const onError = (): void => {\n      cleanup();\n      reject(new Error(`Failed to load VTT segment: ${url}`));\n    };\n\n    const cleanup = (): void => {\n      track.removeEventListener('load', onLoad);\n      track.removeEventListener('error', onError);\n      video.removeChild(track);\n    };\n\n    track.addEventListener('load', onLoad);\n    track.addEventListener('error', onError);\n    video.appendChild(track);\n    track.src = url;\n  });\n}\n\nexport function destroyVttResolver(): void {\n  dummyVideo = null;\n}\n"],"mappings":";;;;;;;AAQA,IAAI,aAAsC;AAE1C,SAAS,mBAAqC;AAC5C,KAAI,CAAC,YAAY;AACf,eAAa,SAAS,cAAc,QAAQ;AAC5C,aAAW,QAAQ;AACnB,aAAW,UAAU;AACrB,aAAW,MAAM,UAAU;AAC3B,aAAW,cAAc;;AAE3B,QAAO;;AAGT,SAAgB,kBAAkB,KAAgC;CAChE,MAAM,QAAQ,kBAAkB;CAChC,MAAM,QAAQ,SAAS,cAAc,QAAQ;AAC7C,OAAM,OAAO;AACb,OAAM,UAAU;AAEhB,QAAO,IAAI,SAAS,SAAS,WAAW;EACtC,MAAM,eAAqB;GACzB,MAAM,OAAiB,EAAE;GACzB,MAAM,YAAY,MAAM;AAExB,OAAI,UAAU,KACZ,MAAK,IAAI,IAAI,GAAG,IAAI,UAAU,KAAK,QAAQ,KAAK;IAC9C,MAAM,MAAM,UAAU,KAAK;AAC3B,QAAI,IACF,MAAK,KAAK,IAAc;;AAK9B,YAAS;AACT,WAAQ,KAAK;;EAGf,MAAM,gBAAsB;AAC1B,YAAS;AACT,0BAAO,IAAI,MAAM,+BAA+B,MAAM,CAAC;;EAGzD,MAAM,gBAAsB;AAC1B,SAAM,oBAAoB,QAAQ,OAAO;AACzC,SAAM,oBAAoB,SAAS,QAAQ;AAC3C,SAAM,YAAY,MAAM;;AAG1B,QAAM,iBAAiB,QAAQ,OAAO;AACtC,QAAM,iBAAiB,SAAS,QAAQ;AACxC,QAAM,YAAY,MAAM;AACxB,QAAM,MAAM;GACZ;;AAGJ,SAAgB,qBAA2B;AACzC,cAAa"}

package/dist/default/media/dom/text/text-track-slots.js

@@ -0,0 +1,69 @@
+import { isCaptionOrSubtitleTrack } from "@videojs/utils/dom";
+//#region src/media/dom/text/text-track-slots.ts
+/**
+* SPF-owned `<track>` selector. Each slot created by
+* `addSubtitlesTracksToMedia` carries this attribute so reads and removals can
+* filter SPF-owned tracks from host-page-owned ones.
+*/
+const SPF_TRACK_SELECTOR = "track[data-src-track]";
+/**
+* Allocate text-track slots on `mediaElement` for each model track by creating
+* and appending `<track>` children. Marks each element with `data-src-track`
+* so it can be distinguished from `<track>` children the host page added
+* directly — used by `getShowingSubtitlesTrackFromMedia` and
+* `removeAllSubtitlesTracksFromMedia` to scope their reads/removals to
+* SPF-owned slots. The spec has no `removeTextTrack` API, so creating
+* `<track>` elements is the only mechanism for adding *and* removing entries
+* to `mediaElement.textTracks`.
+*/
+function addSubtitlesTracksToMedia(mediaElement, modelTextTracks) {
+	for (const modelTrack of modelTextTracks) {
+		const el = document.createElement("track");
+		el.id = modelTrack.id;
+		el.kind = modelTrack.kind;
+		el.label = modelTrack.label;
+		el.toggleAttribute("data-src-track", true);
+		if (modelTrack.language) el.srclang = modelTrack.language;
+		mediaElement.appendChild(el);
+	}
+}
+/**
+* Return the SPF-owned subtitle/caption `TextTrack` currently in `'showing'`
+* mode, or `undefined` if none. Restricts the search to slots created by
+* `addSubtitlesTracksToMedia` (via the `data-src-track` selector) so a showing
+* track that the host page added directly is ignored — SPF selection only
+* mirrors tracks it owns.
+*/
+function getShowingSubtitlesTrackFromMedia(mediaElement) {
+	const elements = mediaElement.querySelectorAll(SPF_TRACK_SELECTOR);
+	for (const el of elements) {
+		const track = el.track;
+		if (track.mode === "showing" && isCaptionOrSubtitleTrack(track)) return track;
+	}
+}
+/**
+* Remove every SPF-owned `<track>` child from `mediaElement` (those tagged
+* with `data-src-track` by `addSubtitlesTracksToMedia`). `<track>` elements
+* the host page added directly are left in place.
+*/
+function removeAllSubtitlesTracksFromMedia(mediaElement) {
+	const elements = mediaElement.querySelectorAll(SPF_TRACK_SELECTOR);
+	for (const el of elements) el.remove();
+}
+/**
+* Apply a selection to a `TextTrackList` by setting each subtitle/caption
+* track's `mode` to `'showing'` if its `id` matches `selectedId` and
+* `'disabled'` otherwise. Tracks of other kinds (chapters, metadata,
+* descriptions) are left untouched — they may be owned by the host page.
+*/
+function syncTextTrackModes(textTracks, selectedId) {
+	for (let i = 0; i < textTracks.length; i++) {
+		const track = textTracks[i];
+		if (!isCaptionOrSubtitleTrack(track)) continue;
+		track.mode = track.id === selectedId ? "showing" : "disabled";
+	}
+}
+//#endregion
+export { addSubtitlesTracksToMedia, getShowingSubtitlesTrackFromMedia, removeAllSubtitlesTracksFromMedia, syncTextTrackModes };
+
+//# sourceMappingURL=text-track-slots.js.map

package/dist/default/media/dom/text/text-track-slots.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-track-slots.js","names":[],"sources":["../../../../../src/media/dom/text/text-track-slots.ts"],"sourcesContent":["import { isCaptionOrSubtitleTrack } from '@videojs/utils/dom';\n\nimport type { PartiallyResolvedTextTrack, TextTrack } from '../../types';\n\n/**\n * SPF-owned `<track>` selector. Each slot created by\n * `addSubtitlesTracksToMedia` carries this attribute so reads and removals can\n * filter SPF-owned tracks from host-page-owned ones.\n */\nconst SPF_TRACK_SELECTOR = 'track[data-src-track]';\n\n/**\n * Allocate text-track slots on `mediaElement` for each model track by creating\n * and appending `<track>` children. Marks each element with `data-src-track`\n * so it can be distinguished from `<track>` children the host page added\n * directly — used by `getShowingSubtitlesTrackFromMedia` and\n * `removeAllSubtitlesTracksFromMedia` to scope their reads/removals to\n * SPF-owned slots. The spec has no `removeTextTrack` API, so creating\n * `<track>` elements is the only mechanism for adding *and* removing entries\n * to `mediaElement.textTracks`.\n */\nexport function addSubtitlesTracksToMedia(\n  mediaElement: HTMLMediaElement,\n  modelTextTracks: readonly (PartiallyResolvedTextTrack | TextTrack)[]\n): void {\n  for (const modelTrack of modelTextTracks) {\n    const el = document.createElement('track');\n    el.id = modelTrack.id;\n    el.kind = modelTrack.kind;\n    el.label = modelTrack.label;\n    el.toggleAttribute('data-src-track', true);\n    if (modelTrack.language) el.srclang = modelTrack.language;\n    // Deliberately NOT propagating `modelTrack.default` to the `default`\n    // attribute: that makes the browser auto-activate the slot on insertion,\n    // which fires a `change` that `syncTextTracks` records as user intent —\n    // auto-enabling captions past SPF's opt-in policy (`enableDefaultTrack`\n    // governs DEFAULT=YES handling in `switchTextTrack`, not the browser). SPF\n    // owns selection; these slots are containers, so they carry no selection hint.\n    mediaElement.appendChild(el);\n  }\n}\n\n/**\n * Return the SPF-owned subtitle/caption `TextTrack` currently in `'showing'`\n * mode, or `undefined` if none. Restricts the search to slots created by\n * `addSubtitlesTracksToMedia` (via the `data-src-track` selector) so a showing\n * track that the host page added directly is ignored — SPF selection only\n * mirrors tracks it owns.\n */\nexport function getShowingSubtitlesTrackFromMedia(mediaElement: HTMLMediaElement): globalThis.TextTrack | undefined {\n  const elements = mediaElement.querySelectorAll<HTMLTrackElement>(SPF_TRACK_SELECTOR);\n  for (const el of elements) {\n    const track = el.track;\n    if (track.mode === 'showing' && isCaptionOrSubtitleTrack(track)) {\n      return track;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Remove every SPF-owned `<track>` child from `mediaElement` (those tagged\n * with `data-src-track` by `addSubtitlesTracksToMedia`). `<track>` elements\n * the host page added directly are left in place.\n */\nexport function removeAllSubtitlesTracksFromMedia(mediaElement: HTMLMediaElement): void {\n  const elements = mediaElement.querySelectorAll<HTMLTrackElement>(SPF_TRACK_SELECTOR);\n  for (const el of elements) {\n    el.remove();\n  }\n}\n\n/**\n * Apply a selection to a `TextTrackList` by setting each subtitle/caption\n * track's `mode` to `'showing'` if its `id` matches `selectedId` and\n * `'disabled'` otherwise. Tracks of other kinds (chapters, metadata,\n * descriptions) are left untouched — they may be owned by the host page.\n */\nexport function syncTextTrackModes(textTracks: TextTrackList, selectedId: string | undefined): void {\n  for (let i = 0; i < textTracks.length; i++) {\n    const track = textTracks[i]!;\n    if (!isCaptionOrSubtitleTrack(track)) continue;\n    track.mode = track.id === selectedId ? 'showing' : 'disabled';\n  }\n}\n"],"mappings":";;;;;;;AASA,MAAM,qBAAqB;;;;;;;;;;;AAY3B,SAAgB,0BACd,cACA,iBACM;AACN,MAAK,MAAM,cAAc,iBAAiB;EACxC,MAAM,KAAK,SAAS,cAAc,QAAQ;AAC1C,KAAG,KAAK,WAAW;AACnB,KAAG,OAAO,WAAW;AACrB,KAAG,QAAQ,WAAW;AACtB,KAAG,gBAAgB,kBAAkB,KAAK;AAC1C,MAAI,WAAW,SAAU,IAAG,UAAU,WAAW;AAOjD,eAAa,YAAY,GAAG;;;;;;;;;;AAWhC,SAAgB,kCAAkC,cAAkE;CAClH,MAAM,WAAW,aAAa,iBAAmC,mBAAmB;AACpF,MAAK,MAAM,MAAM,UAAU;EACzB,MAAM,QAAQ,GAAG;AACjB,MAAI,MAAM,SAAS,aAAa,yBAAyB,MAAM,CAC7D,QAAO;;;;;;;;AAWb,SAAgB,kCAAkC,cAAsC;CACtF,MAAM,WAAW,aAAa,iBAAmC,mBAAmB;AACpF,MAAK,MAAM,MAAM,SACf,IAAG,QAAQ;;;;;;;;AAUf,SAAgB,mBAAmB,YAA2B,YAAsC;AAClG,MAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;EAC1C,MAAM,QAAQ,WAAW;AACzB,MAAI,CAAC,yBAAyB,MAAM,CAAE;AACtC,QAAM,OAAO,MAAM,OAAO,aAAa,YAAY"}

package/dist/{dev/core → default/media}/hls/parse-attributes.js

@@ -1,4 +1,4 @@
-//#region src/core/hls/parse-attributes.ts
+//#region src/media/hls/parse-attributes.ts
 /**
 * Parse HLS attribute list from a tag line.
 * Handles both quoted and unquoted values.
@@ -44,14 +44,28 @@ function parseFrameRate(value) {
 	if (fps % 1 === 0) return { frameRateNumerator: Math.round(fps) };
 	return { frameRateNumerator: Math.round(fps) };
 }
+const AUDIO_CODEC_PREFIXES = [
+	"mp4a.",
+	"ac-3",
+	"ec-3",
+	"ac-4",
+	"opus",
+	"flac",
+	"dts",
+	"alac",
+	"vorbis"
+];
 /**
 * Parse CODECS attribute into separate video and audio codecs.
 */
 function parseCodecs(codecs) {
 	const parts = codecs.split(",").map((s) => s.trim());
 	const result = {};
-	for (const codec of parts) if (codec.startsWith("avc1.") || codec.startsWith("hvc1.") || codec.startsWith("hev1.")) result.video = codec;
-	else if (codec.startsWith("mp4a.")) result.audio = codec;
+	for (const codec of parts) {
+		const lower = codec.toLowerCase();
+		if (codec.startsWith("avc1.") || codec.startsWith("hvc1.") || codec.startsWith("hev1.")) result.video = codec;
+		else if (AUDIO_CODEC_PREFIXES.some((prefix) => lower.startsWith(prefix))) result.audio = codec;
+	}
 	return result;
 }
 /**

package/dist/default/media/hls/parse-attributes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-attributes.js","names":[],"sources":["../../../../src/media/hls/parse-attributes.ts"],"sourcesContent":["import type { FrameRate } from '../types';\n\n/**\n * Parse HLS attribute list from a tag line.\n * Handles both quoted and unquoted values.\n */\nexport function parseAttributeList(line: string): Map<string, string> {\n  const attributes = new Map<string, string>();\n  const regex = /([A-Z0-9-]+)=(?:\"([^\"]*)\"|([^,]*))/g;\n\n  for (const match of line.matchAll(regex)) {\n    const key = match[1];\n    const value = match[2] ?? match[3] ?? '';\n    if (key) {\n      attributes.set(key, value);\n    }\n  }\n\n  return attributes;\n}\n\n/**\n * Parse RESOLUTION attribute value (WIDTHxHEIGHT).\n */\nexport function parseResolution(value: string): { width: number; height: number } | null {\n  const match = /^(\\d+)x(\\d+)$/.exec(value);\n  if (!match) return null;\n\n  const width = Number.parseInt(match[1]!, 10);\n  const height = Number.parseInt(match[2]!, 10);\n\n  return { width, height };\n}\n\n/**\n * Parse FRAME-RATE attribute to rational frame rate.\n */\nexport function parseFrameRate(value: string): FrameRate | undefined {\n  const fps = Number.parseFloat(value);\n  if (Number.isNaN(fps) || fps <= 0) return undefined;\n\n  // Common frame rates with tolerance for floating point precision\n  if (Math.abs(fps - 23.976) < 0.01) {\n    return { frameRateNumerator: 24000, frameRateDenominator: 1001 };\n  }\n  if (Math.abs(fps - 29.97) < 0.01) {\n    return { frameRateNumerator: 30000, frameRateDenominator: 1001 };\n  }\n  if (Math.abs(fps - 59.94) < 0.01) {\n    return { frameRateNumerator: 60000, frameRateDenominator: 1001 };\n  }\n\n  // Integer frame rates\n  if (fps % 1 === 0) {\n    return { frameRateNumerator: Math.round(fps) };\n  }\n\n  // Default: use rounded value\n  return { frameRateNumerator: Math.round(fps) };\n}\n\n// Audio codec identifiers, matched case-insensitively against each CODECS\n// entry's prefix. Beyond AAC (`mp4a.*`): Dolby (`ac-3`, `ec-3`, `ac-4`), Opus,\n// FLAC (`fLaC`), DTS (`dts*`), ALAC, and Vorbis. Recognizing these is what lets\n// capability probing filter undecodable audio renditions (e.g. an AC-3 5.1\n// track on a browser without AC-3) — an unrecognized codec parses empty and is\n// treated as unprobeable, so it would never be pruned.\nconst AUDIO_CODEC_PREFIXES = ['mp4a.', 'ac-3', 'ec-3', 'ac-4', 'opus', 'flac', 'dts', 'alac', 'vorbis'];\n\n/**\n * Parse CODECS attribute into separate video and audio codecs.\n */\nexport function parseCodecs(codecs: string): { video?: string; audio?: string } {\n  const parts = codecs.split(',').map((s) => s.trim());\n  const result: { video?: string; audio?: string } = {};\n\n  for (const codec of parts) {\n    const lower = codec.toLowerCase();\n    if (codec.startsWith('avc1.') || codec.startsWith('hvc1.') || codec.startsWith('hev1.')) {\n      result.video = codec;\n    } else if (AUDIO_CODEC_PREFIXES.some((prefix) => lower.startsWith(prefix))) {\n      result.audio = codec;\n    }\n  }\n\n  return result;\n}\n\n/**\n * Parse #EXTINF duration value.\n */\nexport function parseExtInfDuration(value: string): number {\n  const durationPart = value.split(',')[0] ?? value;\n  const duration = Number.parseFloat(durationPart);\n  return Number.isNaN(duration) ? 0 : duration;\n}\n\n/**\n * Parse BYTERANGE attribute value.\n * Format: \"length[@offset]\"\n * If offset is omitted, it continues from the previous byte range end.\n */\nexport function parseByteRange(value: string, previousEnd?: number): { start: number; end: number } | null {\n  const match = /^(\\d+)(?:@(\\d+))?$/.exec(value);\n  if (!match) return null;\n\n  const length = Number.parseInt(match[1]!, 10);\n  if (Number.isNaN(length)) return null;\n\n  let start: number;\n  if (match[2] !== undefined) {\n    start = Number.parseInt(match[2], 10);\n    if (Number.isNaN(start)) return null;\n  } else if (previousEnd !== undefined) {\n    start = previousEnd;\n  } else {\n    return null;\n  }\n\n  return { start, end: start + length - 1 };\n}\n\n/**\n * AttributeList - Typed attribute access wrapper.\n */\nexport interface AttributeList {\n  get: (key: string) => string | undefined;\n  getInt: (key: string, defaultValue?: number) => number | undefined;\n  getFloat: (key: string, defaultValue?: number) => number | undefined;\n  getBool: (key: string) => boolean;\n  getResolution: (key: string) => { width: number; height: number } | undefined;\n  getFrameRate: (key: string) => FrameRate | undefined;\n}\n\n/**\n * Create AttributeList from raw attribute string.\n */\nexport function createAttributeList(line: string): AttributeList {\n  const map = parseAttributeList(line);\n\n  return {\n    get(key: string): string | undefined {\n      return map.get(key);\n    },\n\n    getInt(key: string, defaultValue?: number): number | undefined {\n      const value = map.get(key);\n      if (value === undefined) return defaultValue;\n      const parsed = Number.parseInt(value, 10);\n      return Number.isNaN(parsed) ? defaultValue : parsed;\n    },\n\n    getFloat(key: string, defaultValue?: number): number | undefined {\n      const value = map.get(key);\n      if (value === undefined) return defaultValue;\n      const parsed = Number.parseFloat(value);\n      return Number.isNaN(parsed) ? defaultValue : parsed;\n    },\n\n    getBool(key: string): boolean {\n      return map.get(key) === 'YES';\n    },\n\n    getResolution(key: string): { width: number; height: number } | undefined {\n      const value = map.get(key);\n      if (!value) return undefined;\n      return parseResolution(value) ?? undefined;\n    },\n\n    getFrameRate(key: string): FrameRate | undefined {\n      const value = map.get(key);\n      if (!value) return undefined;\n      return parseFrameRate(value);\n    },\n  };\n}\n\n/**\n * Match a tag and extract its attributes.\n * Returns null if the line doesn't match the tag.\n */\nexport function matchTag(line: string, tag: string): AttributeList | null {\n  const prefix = `#${tag}:`;\n  if (!line.startsWith(prefix)) return null;\n  return createAttributeList(line.slice(prefix.length));\n}\n"],"mappings":";;;;;AAMA,SAAgB,mBAAmB,MAAmC;CACpE,MAAM,6BAAa,IAAI,KAAqB;AAG5C,MAAK,MAAM,SAAS,KAAK,SAFX,sCAE0B,EAAE;EACxC,MAAM,MAAM,MAAM;EAClB,MAAM,QAAQ,MAAM,MAAM,MAAM,MAAM;AACtC,MAAI,IACF,YAAW,IAAI,KAAK,MAAM;;AAI9B,QAAO;;;;;AAMT,SAAgB,gBAAgB,OAAyD;CACvF,MAAM,QAAQ,gBAAgB,KAAK,MAAM;AACzC,KAAI,CAAC,MAAO,QAAO;AAKnB,QAAO;EAAE,OAHK,OAAO,SAAS,MAAM,IAAK,GAAG;EAG5B,QAFD,OAAO,SAAS,MAAM,IAAK,GAAG;EAErB;;;;;AAM1B,SAAgB,eAAe,OAAsC;CACnE,MAAM,MAAM,OAAO,WAAW,MAAM;AACpC,KAAI,OAAO,MAAM,IAAI,IAAI,OAAO,EAAG,QAAO,KAAA;AAG1C,KAAI,KAAK,IAAI,MAAM,OAAO,GAAG,IAC3B,QAAO;EAAE,oBAAoB;EAAO,sBAAsB;EAAM;AAElE,KAAI,KAAK,IAAI,MAAM,MAAM,GAAG,IAC1B,QAAO;EAAE,oBAAoB;EAAO,sBAAsB;EAAM;AAElE,KAAI,KAAK,IAAI,MAAM,MAAM,GAAG,IAC1B,QAAO;EAAE,oBAAoB;EAAO,sBAAsB;EAAM;AAIlE,KAAI,MAAM,MAAM,EACd,QAAO,EAAE,oBAAoB,KAAK,MAAM,IAAI,EAAE;AAIhD,QAAO,EAAE,oBAAoB,KAAK,MAAM,IAAI,EAAE;;AAShD,MAAM,uBAAuB;CAAC;CAAS;CAAQ;CAAQ;CAAQ;CAAQ;CAAQ;CAAO;CAAQ;CAAS;;;;AAKvG,SAAgB,YAAY,QAAoD;CAC9E,MAAM,QAAQ,OAAO,MAAM,IAAI,CAAC,KAAK,MAAM,EAAE,MAAM,CAAC;CACpD,MAAM,SAA6C,EAAE;AAErD,MAAK,MAAM,SAAS,OAAO;EACzB,MAAM,QAAQ,MAAM,aAAa;AACjC,MAAI,MAAM,WAAW,QAAQ,IAAI,MAAM,WAAW,QAAQ,IAAI,MAAM,WAAW,QAAQ,CACrF,QAAO,QAAQ;WACN,qBAAqB,MAAM,WAAW,MAAM,WAAW,OAAO,CAAC,CACxE,QAAO,QAAQ;;AAInB,QAAO;;;;;AAMT,SAAgB,oBAAoB,OAAuB;CACzD,MAAM,eAAe,MAAM,MAAM,IAAI,CAAC,MAAM;CAC5C,MAAM,WAAW,OAAO,WAAW,aAAa;AAChD,QAAO,OAAO,MAAM,SAAS,GAAG,IAAI;;;;;;;AAQtC,SAAgB,eAAe,OAAe,aAA6D;CACzG,MAAM,QAAQ,qBAAqB,KAAK,MAAM;AAC9C,KAAI,CAAC,MAAO,QAAO;CAEnB,MAAM,SAAS,OAAO,SAAS,MAAM,IAAK,GAAG;AAC7C,KAAI,OAAO,MAAM,OAAO,CAAE,QAAO;CAEjC,IAAI;AACJ,KAAI,MAAM,OAAO,KAAA,GAAW;AAC1B,UAAQ,OAAO,SAAS,MAAM,IAAI,GAAG;AACrC,MAAI,OAAO,MAAM,MAAM,CAAE,QAAO;YACvB,gBAAgB,KAAA,EACzB,SAAQ;KAER,QAAO;AAGT,QAAO;EAAE;EAAO,KAAK,QAAQ,SAAS;EAAG;;;;;AAkB3C,SAAgB,oBAAoB,MAA6B;CAC/D,MAAM,MAAM,mBAAmB,KAAK;AAEpC,QAAO;EACL,IAAI,KAAiC;AACnC,UAAO,IAAI,IAAI,IAAI;;EAGrB,OAAO,KAAa,cAA2C;GAC7D,MAAM,QAAQ,IAAI,IAAI,IAAI;AAC1B,OAAI,UAAU,KAAA,EAAW,QAAO;GAChC,MAAM,SAAS,OAAO,SAAS,OAAO,GAAG;AACzC,UAAO,OAAO,MAAM,OAAO,GAAG,eAAe;;EAG/C,SAAS,KAAa,cAA2C;GAC/D,MAAM,QAAQ,IAAI,IAAI,IAAI;AAC1B,OAAI,UAAU,KAAA,EAAW,QAAO;GAChC,MAAM,SAAS,OAAO,WAAW,MAAM;AACvC,UAAO,OAAO,MAAM,OAAO,GAAG,eAAe;;EAG/C,QAAQ,KAAsB;AAC5B,UAAO,IAAI,IAAI,IAAI,KAAK;;EAG1B,cAAc,KAA4D;GACxE,MAAM,QAAQ,IAAI,IAAI,IAAI;AAC1B,OAAI,CAAC,MAAO,QAAO,KAAA;AACnB,UAAO,gBAAgB,MAAM,IAAI,KAAA;;EAGnC,aAAa,KAAoC;GAC/C,MAAM,QAAQ,IAAI,IAAI,IAAI;AAC1B,OAAI,CAAC,MAAO,QAAO,KAAA;AACnB,UAAO,eAAe,MAAM;;EAE/B;;;;;;AAOH,SAAgB,SAAS,MAAc,KAAmC;CACxE,MAAM,SAAS,IAAI,IAAI;AACvB,KAAI,CAAC,KAAK,WAAW,OAAO,CAAE,QAAO;AACrC,QAAO,oBAAoB,KAAK,MAAM,OAAO,OAAO,CAAC"}

package/dist/{dev/core → default/media}/hls/parse-media-playlist.js

@@ -1,6 +1,26 @@
 import { matchTag, parseByteRange, parseExtInfDuration } from "./parse-attributes.js";
 import { resolveUrl } from "./resolve-url.js";
-//#region src/core/hls/parse-media-playlist.ts
+const CONTAINER_MIME_BY_EXTENSION = {
+	".ts": "video/mp2t",
+	".aac": "audio/aac"
+};
+/** The non-fMP4 container MIMEs the parser detects — all currently treated as unplayable. */
+const NON_FMP4_CONTAINER_MIMES = new Set(Object.values(CONTAINER_MIME_BY_EXTENSION));
+/**
+* Non-fMP4 container MIME for a (resolved, absolute) segment URL, by file
+* extension, ignoring the query string. `undefined` for fMP4 / unrecognized.
+*/
+function containerMimeFromSegment(url) {
+	if (!url) return void 0;
+	let path;
+	try {
+		path = new URL(url).pathname.toLowerCase();
+	} catch {
+		path = url.toLowerCase().split("?")[0] ?? "";
+	}
+	const dot = path.lastIndexOf(".");
+	return dot === -1 ? void 0 : CONTAINER_MIME_BY_EXTENSION[path.slice(dot)];
+}
 /**
 * Parse HLS media playlist and resolve track with segments.
 *
@@ -68,8 +88,11 @@ function parseMediaPlaylist(text, unresolved) {
 		url: initSegmentUrl,
 		...initSegmentByteRange ? { byteRange: initSegmentByteRange } : {}
 	} : { url: "" };
+	const detectedContainer = initSegmentUrl ? void 0 : containerMimeFromSegment(segments[0]?.url);
+	const mimeType = unresolved.type !== "text" && detectedContainer ? detectedContainer : unresolved.mimeType;
 	return {
 		...unresolved,
+		mimeType,
 		startTime: 0,
 		duration: totalDuration,
 		segments,
@@ -77,6 +100,6 @@ function parseMediaPlaylist(text, unresolved) {
 	};
 }
 //#endregion
-export { parseMediaPlaylist };
+export { NON_FMP4_CONTAINER_MIMES, parseMediaPlaylist };
 
 //# sourceMappingURL=parse-media-playlist.js.map

package/dist/default/media/hls/parse-media-playlist.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-media-playlist.js","names":[],"sources":["../../../../src/media/hls/parse-media-playlist.ts"],"sourcesContent":["import type {\n  AudioTrack,\n  PartiallyResolvedAudioTrack,\n  PartiallyResolvedTextTrack,\n  PartiallyResolvedTrack,\n  PartiallyResolvedVideoTrack,\n  Segment,\n  TextTrack,\n  VideoTrack,\n} from '../types';\nimport { matchTag, parseByteRange, parseExtInfDuration } from './parse-attributes';\nimport { resolveUrl } from './resolve-url';\n\n/** MPEG-2 Transport Stream (IANA `video/MP2T`, lowercased for `isTypeSupported`). Video + audio TS — there is no `audio/mp2t`. */\nexport const MPEG_TS_MIME = 'video/mp2t';\n/** Raw ADTS AAC packed-audio (HLS `.aac` segments; IANA `audio/aac`). */\nexport const RAW_AAC_MIME = 'audio/aac';\n\n// Non-fMP4 container MIMEs keyed by segment file extension. fMP4 (the MSE\n// default) always carries an EXT-X-MAP init segment, so a media playlist with\n// no init segment and one of these extensions is a non-fMP4 rendition,\n// relabeled from the fMP4 default. Extend with `.mp3` → 'audio/mpeg' etc.\nconst CONTAINER_MIME_BY_EXTENSION: Record<string, string> = {\n  '.ts': MPEG_TS_MIME,\n  '.aac': RAW_AAC_MIME,\n};\n\n/** The non-fMP4 container MIMEs the parser detects — all currently treated as unplayable. */\nexport const NON_FMP4_CONTAINER_MIMES = new Set(Object.values(CONTAINER_MIME_BY_EXTENSION));\n\n/**\n * Non-fMP4 container MIME for a (resolved, absolute) segment URL, by file\n * extension, ignoring the query string. `undefined` for fMP4 / unrecognized.\n */\nfunction containerMimeFromSegment(url: string | undefined): string | undefined {\n  if (!url) return undefined;\n  let path: string;\n  try {\n    path = new URL(url).pathname.toLowerCase();\n  } catch {\n    path = url.toLowerCase().split('?')[0] ?? '';\n  }\n  const dot = path.lastIndexOf('.');\n  return dot === -1 ? undefined : CONTAINER_MIME_BY_EXTENSION[path.slice(dot)];\n}\n\n/**\n * Resolve unresolved track type to its resolved equivalent.\n */\ntype ResolveTrack<T> = T extends PartiallyResolvedVideoTrack\n  ? VideoTrack\n  : T extends PartiallyResolvedAudioTrack\n    ? AudioTrack\n    : T extends PartiallyResolvedTextTrack\n      ? TextTrack\n      : never;\n\n/**\n * Parse HLS media playlist and resolve track with segments.\n *\n * Takes an unresolved track (from multivariant playlist) and media playlist text,\n * returns a HAM-compliant resolved track with segments.\n *\n * @param text - Media playlist text content\n * @param unresolved - Unresolved track from parseMultivariantPlaylist\n * @returns Resolved track with segments (type inferred from input)\n */\nexport function parseMediaPlaylist<T extends PartiallyResolvedTrack>(\n  text: string,\n  unresolved: T | ResolveTrack<T>\n): ResolveTrack<T> {\n  const lines = text.split(/\\r?\\n/);\n\n  // Segments and resources resolve relative to media playlist URL (per HLS spec)\n  const baseUrl = unresolved.url;\n\n  // Parse playlist\n  const segments: Segment[] = [];\n  let initSegmentUrl: string | undefined;\n  let initSegmentByteRange: { start: number; end: number } | undefined;\n\n  let currentDuration = 0;\n  let currentByteRange: { start: number; end: number } | undefined;\n  let currentTime = 0;\n  let segmentIndex = 0;\n  let previousByteRangeEnd: number | undefined;\n\n  for (const line of lines) {\n    const trimmed = line.trim();\n\n    if (!trimmed || (trimmed.startsWith('#') && !trimmed.startsWith('#EXT'))) {\n      continue;\n    }\n\n    if (\n      trimmed === '#EXTM3U' ||\n      trimmed.startsWith('#EXT-X-VERSION:') ||\n      trimmed.startsWith('#EXT-X-TARGETDURATION:') ||\n      trimmed.startsWith('#EXT-X-PLAYLIST-TYPE:') ||\n      trimmed.startsWith('#EXT-X-INDEPENDENT-SEGMENTS')\n    ) {\n      continue;\n    }\n\n    // #EXT-X-MAP - Init segment\n    const mapAttrs = matchTag(trimmed, 'EXT-X-MAP');\n    if (mapAttrs) {\n      const uri = mapAttrs.get('URI');\n      if (uri) {\n        initSegmentUrl = resolveUrl(uri, baseUrl);\n        const byteRangeStr = mapAttrs.get('BYTERANGE');\n        if (byteRangeStr) {\n          initSegmentByteRange = parseByteRange(byteRangeStr, 0) ?? undefined;\n        }\n      }\n      continue;\n    }\n\n    // #EXTINF - Segment duration\n    if (trimmed.startsWith('#EXTINF:')) {\n      currentDuration = parseExtInfDuration(trimmed.slice(8));\n      continue;\n    }\n\n    // #EXT-X-BYTERANGE - Segment byte range\n    if (trimmed.startsWith('#EXT-X-BYTERANGE:')) {\n      currentByteRange = parseByteRange(trimmed.slice(17), previousByteRangeEnd) ?? undefined;\n      continue;\n    }\n\n    if (trimmed === '#EXT-X-ENDLIST') {\n      continue;\n    }\n\n    // Segment URI\n    if (!trimmed.startsWith('#') && currentDuration > 0) {\n      const segment: Segment = {\n        id: `segment-${segmentIndex}`,\n        url: resolveUrl(trimmed, baseUrl),\n        duration: currentDuration,\n        startTime: currentTime,\n      };\n\n      if (currentByteRange) {\n        segment.byteRange = currentByteRange;\n        previousByteRangeEnd = currentByteRange.end + 1;\n      } else {\n        previousByteRangeEnd = undefined;\n      }\n\n      segments.push(segment);\n      currentTime += currentDuration;\n      segmentIndex++;\n\n      currentDuration = 0;\n      currentByteRange = undefined;\n    }\n  }\n\n  const totalDuration = currentTime;\n\n  // Build initialization (VTT may not have init segment)\n  const initialization =\n    unresolved.type === 'text' && !initSegmentUrl\n      ? undefined\n      : initSegmentUrl\n        ? { url: initSegmentUrl, ...(initSegmentByteRange ? { byteRange: initSegmentByteRange } : {}) }\n        : { url: '' };\n\n  // Container detection: fMP4 always carries an EXT-X-MAP init segment, so its\n  // absence plus a recognized non-fMP4 segment extension (`.ts` → MPEG-TS,\n  // `.aac` → raw ADTS AAC) marks a non-fMP4 rendition (high-precision — never\n  // trips on fMP4, which mandates the map). Relabel from the fMP4 default\n  // `video/mp4` / `audio/mp4` to the container MIME so capability probing prunes\n  // it (these containers are currently treated as unplayable; see `canPlayTrack`).\n  const detectedContainer = initSegmentUrl ? undefined : containerMimeFromSegment(segments[0]?.url);\n  const mimeType = unresolved.type !== 'text' && detectedContainer ? detectedContainer : unresolved.mimeType;\n\n  // Generic resolution: All type-specific fields already on unresolved track from P1\n  // Just add parsed properties (startTime, duration, segments, initialization)\n  return {\n    ...unresolved,\n    mimeType,\n    startTime: 0,\n    duration: totalDuration,\n    segments,\n    initialization,\n  } as unknown as ResolveTrack<T>;\n}\n"],"mappings":";;AAsBA,MAAM,8BAAsD;CAC1D,OAT0B;CAU1B,QAR0B;CAS3B;;AAGD,MAAa,2BAA2B,IAAI,IAAI,OAAO,OAAO,4BAA4B,CAAC;;;;;AAM3F,SAAS,yBAAyB,KAA6C;AAC7E,KAAI,CAAC,IAAK,QAAO,KAAA;CACjB,IAAI;AACJ,KAAI;AACF,SAAO,IAAI,IAAI,IAAI,CAAC,SAAS,aAAa;SACpC;AACN,SAAO,IAAI,aAAa,CAAC,MAAM,IAAI,CAAC,MAAM;;CAE5C,MAAM,MAAM,KAAK,YAAY,IAAI;AACjC,QAAO,QAAQ,KAAK,KAAA,IAAY,4BAA4B,KAAK,MAAM,IAAI;;;;;;;;;;;;AAwB7E,SAAgB,mBACd,MACA,YACiB;CACjB,MAAM,QAAQ,KAAK,MAAM,QAAQ;CAGjC,MAAM,UAAU,WAAW;CAG3B,MAAM,WAAsB,EAAE;CAC9B,IAAI;CACJ,IAAI;CAEJ,IAAI,kBAAkB;CACtB,IAAI;CACJ,IAAI,cAAc;CAClB,IAAI,eAAe;CACnB,IAAI;AAEJ,MAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,UAAU,KAAK,MAAM;AAE3B,MAAI,CAAC,WAAY,QAAQ,WAAW,IAAI,IAAI,CAAC,QAAQ,WAAW,OAAO,CACrE;AAGF,MACE,YAAY,aACZ,QAAQ,WAAW,kBAAkB,IACrC,QAAQ,WAAW,yBAAyB,IAC5C,QAAQ,WAAW,wBAAwB,IAC3C,QAAQ,WAAW,8BAA8B,CAEjD;EAIF,MAAM,WAAW,SAAS,SAAS,YAAY;AAC/C,MAAI,UAAU;GACZ,MAAM,MAAM,SAAS,IAAI,MAAM;AAC/B,OAAI,KAAK;AACP,qBAAiB,WAAW,KAAK,QAAQ;IACzC,MAAM,eAAe,SAAS,IAAI,YAAY;AAC9C,QAAI,aACF,wBAAuB,eAAe,cAAc,EAAE,IAAI,KAAA;;AAG9D;;AAIF,MAAI,QAAQ,WAAW,WAAW,EAAE;AAClC,qBAAkB,oBAAoB,QAAQ,MAAM,EAAE,CAAC;AACvD;;AAIF,MAAI,QAAQ,WAAW,oBAAoB,EAAE;AAC3C,sBAAmB,eAAe,QAAQ,MAAM,GAAG,EAAE,qBAAqB,IAAI,KAAA;AAC9E;;AAGF,MAAI,YAAY,iBACd;AAIF,MAAI,CAAC,QAAQ,WAAW,IAAI,IAAI,kBAAkB,GAAG;GACnD,MAAM,UAAmB;IACvB,IAAI,WAAW;IACf,KAAK,WAAW,SAAS,QAAQ;IACjC,UAAU;IACV,WAAW;IACZ;AAED,OAAI,kBAAkB;AACpB,YAAQ,YAAY;AACpB,2BAAuB,iBAAiB,MAAM;SAE9C,wBAAuB,KAAA;AAGzB,YAAS,KAAK,QAAQ;AACtB,kBAAe;AACf;AAEA,qBAAkB;AAClB,sBAAmB,KAAA;;;CAIvB,MAAM,gBAAgB;CAGtB,MAAM,iBACJ,WAAW,SAAS,UAAU,CAAC,iBAC3B,KAAA,IACA,iBACE;EAAE,KAAK;EAAgB,GAAI,uBAAuB,EAAE,WAAW,sBAAsB,GAAG,EAAE;EAAG,GAC7F,EAAE,KAAK,IAAI;CAQnB,MAAM,oBAAoB,iBAAiB,KAAA,IAAY,yBAAyB,SAAS,IAAI,IAAI;CACjG,MAAM,WAAW,WAAW,SAAS,UAAU,oBAAoB,oBAAoB,WAAW;AAIlG,QAAO;EACL,GAAG;EACH;EACA,WAAW;EACX,UAAU;EACV;EACA;EACD"}