@videojs/spf 10.0.0-beta.8 → 10.0.0-rc.1

package/dist/dev/playback/primitives/head-peek.js

@@ -0,0 +1,41 @@
+//#region src/playback/primitives/head-peek.ts
+/**
+* Eager head-of-stream peek. Pulls chunks from an async byte stream only until `tryParse` signals it has read what it
+* needs (or the stream ends), then returns a stream that re-emits the pulled head followed by the untouched tail — so
+* reading a head-of-stream mp4 box (`mdhd` / `tfdt`) doesn't break streaming of the append. Once the caller has what it
+* wants, the rest streams as normal.
+*/
+function concat(chunks) {
+	if (chunks.length === 1) return chunks[0];
+	const total = chunks.reduce((n, c) => n + c.length, 0);
+	const out = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		out.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return out;
+}
+/** Re-emit the eagerly-pulled head chunks, then stream the untouched tail. */
+async function* reassemble(head, tail) {
+	yield* head;
+	for (let next = await tail.next(); !next.done; next = await tail.next()) yield next.value;
+}
+/**
+* Pull chunks until `tryParse(accumulatedHead)` returns `true` — it found and read its box — or the stream ends, then
+* return a stream re-emitting the pulled head followed by the untouched tail. `tryParse` is called with the growing
+* head after each chunk; it performs the side effect (publishing the parsed value) and returns whether it's done.
+*/
+async function peekHead(data, tryParse) {
+	const iterator = data[Symbol.asyncIterator]();
+	const head = [];
+	for (let next = await iterator.next(); !next.done; next = await iterator.next()) {
+		head.push(next.value);
+		if (tryParse(concat(head))) break;
+	}
+	return reassemble(head, iterator);
+}
+//#endregion
+export { peekHead };
+
+//# sourceMappingURL=head-peek.js.map

package/dist/dev/playback/primitives/head-peek.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"head-peek.js","names":[],"sources":["../../../../src/playback/primitives/head-peek.ts"],"sourcesContent":["/**\n * Eager head-of-stream peek. Pulls chunks from an async byte stream only until `tryParse` signals it has read what it\n * needs (or the stream ends), then returns a stream that re-emits the pulled head followed by the untouched tail — so\n * reading a head-of-stream mp4 box (`mdhd` / `tfdt`) doesn't break streaming of the append. Once the caller has what it\n * wants, the rest streams as normal.\n */\n\nfunction concat(chunks: Uint8Array[]): Uint8Array {\n  if (chunks.length === 1) return chunks[0]!;\n\n  const total = chunks.reduce((n, c) => n + c.length, 0);\n  const out = new Uint8Array(total);\n  let offset = 0;\n\n  for (const chunk of chunks) {\n    out.set(chunk, offset);\n    offset += chunk.length;\n  }\n\n  return out;\n}\n\n/** Re-emit the eagerly-pulled head chunks, then stream the untouched tail. */\nasync function* reassemble(head: Uint8Array[], tail: AsyncIterator<Uint8Array>): AsyncIterable<Uint8Array> {\n  yield* head;\n\n  for (let next = await tail.next(); !next.done; next = await tail.next()) yield next.value;\n}\n\n/**\n * Pull chunks until `tryParse(accumulatedHead)` returns `true` — it found and read its box — or the stream ends, then\n * return a stream re-emitting the pulled head followed by the untouched tail. `tryParse` is called with the growing\n * head after each chunk; it performs the side effect (publishing the parsed value) and returns whether it's done.\n */\nexport async function peekHead(\n  data: AsyncIterable<Uint8Array>,\n  tryParse: (bytes: Uint8Array) => boolean\n): Promise<AsyncIterable<Uint8Array>> {\n  const iterator = data[Symbol.asyncIterator]();\n  const head: Uint8Array[] = [];\n\n  for (let next = await iterator.next(); !next.done; next = await iterator.next()) {\n    head.push(next.value);\n\n    if (tryParse(concat(head))) break;\n  }\n\n  return reassemble(head, iterator);\n}\n"],"mappings":";;;;;;;AAOA,SAAS,OAAO,QAAkC;CAChD,IAAI,OAAO,WAAW,GAAG,OAAO,OAAO;CAEvC,MAAM,QAAQ,OAAO,QAAQ,GAAG,MAAM,IAAI,EAAE,QAAQ,CAAC;CACrD,MAAM,MAAM,IAAI,WAAW,KAAK;CAChC,IAAI,SAAS;CAEb,KAAK,MAAM,SAAS,QAAQ;EAC1B,IAAI,IAAI,OAAO,MAAM;EACrB,UAAU,MAAM;CAClB;CAEA,OAAO;AACT;;AAGA,gBAAgB,WAAW,MAAoB,MAA4D;CACzG,OAAO;CAEP,KAAK,IAAI,OAAO,MAAM,KAAK,KAAK,GAAG,CAAC,KAAK,MAAM,OAAO,MAAM,KAAK,KAAK,GAAG,MAAM,KAAK;AACtF;;;;;;AAOA,eAAsB,SACpB,MACA,UACoC;CACpC,MAAM,WAAW,KAAK,OAAO,cAAc,CAAC;CAC5C,MAAM,OAAqB,CAAC;CAE5B,KAAK,IAAI,OAAO,MAAM,SAAS,KAAK,GAAG,CAAC,KAAK,MAAM,OAAO,MAAM,SAAS,KAAK,GAAG;EAC/E,KAAK,KAAK,KAAK,KAAK;EAEpB,IAAI,SAAS,OAAO,IAAI,CAAC,GAAG;CAC9B;CAEA,OAAO,WAAW,MAAM,QAAQ;AAClC"}

package/dist/dev/playback/primitives/live-window.js

@@ -0,0 +1,63 @@
+import { getTracksByType } from "../../media/utils/tracks.js";
+import { liveWindowFor } from "../../media/live-window.js";
+//#region src/playback/primitives/live-window.ts
+/**
+* The id of the timeline-bearing track: the selected video track when present, else the selected audio track. The
+* single pick both the window derivation and the live-latency resolution (`seek-to-live-edge`) share, so they can't
+* drift.
+*/
+function liveTrackId(state) {
+	return state.selectedVideoTrackId?.get() ?? state.selectedAudioTrackId?.get();
+}
+/**
+* One type's window: the selected track's when it's resolved, else any resolved track of the type. The fallback keeps
+* the window from blinking to `null` mid ABR / user switch — all renditions of a type are time-aligned and share the
+* anchor, so a deselected track's window may trail live by up to one reload during the switch gap (acceptable; the
+* selected track's fresh window resumes the moment it resolves). A null blink would flip `seekToLiveEdge` out of `live`
+* and stall the seekable-range writer.
+*/
+function liveWindowForType(presentation, selectedId, type) {
+	if (!presentation || selectedId === void 0) return null;
+	const selected = liveWindowFor(presentation, selectedId);
+	if (selected) return selected;
+	for (const track of getTracksByType(presentation, type)) {
+		const window = liveWindowFor(presentation, track.id);
+		if (window) return window;
+	}
+	return null;
+}
+function liveWindowFromState(state) {
+	const presentation = state.presentation.get();
+	const video = liveWindowForType(presentation, state.selectedVideoTrackId?.get(), "video");
+	const audio = liveWindowForType(presentation, state.selectedAudioTrackId?.get(), "audio");
+	if (video && audio) {
+		const start = Math.max(video.start, audio.start);
+		const end = Math.min(video.end, audio.end);
+		return start < end ? {
+			start,
+			end
+		} : null;
+	}
+	return video ?? audio;
+}
+/**
+* Resolve the live edge — the window bounds plus the target playhead position — from a behavior's setup arguments.
+* Bundles the window geometry and the format-specific latency policy (`config.resolveLiveLatency`) so the consuming
+* behavior never has to compose them; it just forwards its `{ state, config }`. `null` when there is no live edge (VOD
+* / ended / unresolved).
+*
+* Reads signals lazily — call it inside a reactive context (an effect).
+*/
+function getLiveEdge({ state, config }) {
+	const window = liveWindowFromState(state);
+	if (!window) return null;
+	const latency = config?.resolveLiveLatency?.(state.presentation.get(), liveTrackId(state)) ?? 0;
+	return {
+		...window,
+		liveEdgeStart: Math.max(window.start, window.end - latency)
+	};
+}
+//#endregion
+export { getLiveEdge, liveTrackId, liveWindowFromState };
+
+//# sourceMappingURL=live-window.js.map

package/dist/dev/playback/primitives/live-window.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-window.js","names":[],"sources":["../../../../src/playback/primitives/live-window.ts"],"sourcesContent":["/**\n * Resolve the live window from engine state — the single call site the seek-to-live-edge and live-seekable-range\n * behaviors share, so their window derivation can't drift apart.\n *\n * The window is the **intersection over the selected A/V tracks'** windows (`max` of starts, `min` of ends):\n * publication skew between the two playlists shrinks the window to what both can actually serve, and the `max` also\n * clamps the legitimate _negative_ early `startTime` of a non-reference track whose window precedes the join point\n * (presentation-0) — see `internal/design/spf/live-presentation-timeline-model.md` (Phase 2 window math). With one\n * selected type (video-only / audio-only) its window stands alone.\n *\n * Reads signals lazily — call it inside a reactive context (an effect) so the read tracks `presentation` + the\n * selected-track ids.\n */\nimport type { ReadonlySignal } from '../../core/signals/primitives';\nimport { type LiveWindow, liveWindowFor } from '../../media/live-window';\nimport type { MaybeResolvedPresentation, TrackType } from '../../media/types';\nimport { getTracksByType } from '../../media/utils/tracks';\n\nexport interface LiveWindowState {\n  presentation: ReadonlySignal<MaybeResolvedPresentation | undefined>;\n  selectedVideoTrackId?: ReadonlySignal<string | undefined>;\n  selectedAudioTrackId?: ReadonlySignal<string | undefined>;\n}\n\n/**\n * The id of the timeline-bearing track: the selected video track when present, else the selected audio track. The\n * single pick both the window derivation and the live-latency resolution (`seek-to-live-edge`) share, so they can't\n * drift.\n */\nexport function liveTrackId(state: LiveWindowState): string | undefined {\n  return state.selectedVideoTrackId?.get() ?? state.selectedAudioTrackId?.get();\n}\n\n/**\n * One type's window: the selected track's when it's resolved, else any resolved track of the type. The fallback keeps\n * the window from blinking to `null` mid ABR / user switch — all renditions of a type are time-aligned and share the\n * anchor, so a deselected track's window may trail live by up to one reload during the switch gap (acceptable; the\n * selected track's fresh window resumes the moment it resolves). A null blink would flip `seekToLiveEdge` out of `live`\n * and stall the seekable-range writer.\n */\nfunction liveWindowForType(\n  presentation: MaybeResolvedPresentation | undefined,\n  selectedId: string | undefined,\n  type: TrackType\n): LiveWindow | null {\n  if (!presentation || selectedId === undefined) return null;\n\n  const selected = liveWindowFor(presentation, selectedId);\n  if (selected) return selected;\n\n  for (const track of getTracksByType(presentation, type)) {\n    const window = liveWindowFor(presentation, track.id);\n    if (window) return window;\n  }\n\n  return null;\n}\n\nexport function liveWindowFromState(state: LiveWindowState): LiveWindow | null {\n  const presentation = state.presentation.get();\n  const video = liveWindowForType(presentation, state.selectedVideoTrackId?.get(), 'video');\n  const audio = liveWindowForType(presentation, state.selectedAudioTrackId?.get(), 'audio');\n\n  if (video && audio) {\n    const start = Math.max(video.start, audio.start);\n    const end = Math.min(video.end, audio.end);\n\n    // A degenerate intersection (disjoint windows — one playlist stalled a full\n    // window behind the other) means there is no position both types can serve:\n    // no live edge, rather than an invented one.\n    return start < end ? { start, end } : null;\n  }\n\n  return video ?? audio;\n}\n\n/**\n * Resolve the target live latency (seconds the playhead should trail the live edge) for the timeline-bearing track.\n * Format-specific — supplied by the engine (HLS: `HOLD-BACK`; DASH would use `suggestedPresentationDelay`) — so the\n * live edge stays format-neutral.\n */\nexport type ResolveLiveLatency = (\n  presentation: MaybeResolvedPresentation | undefined,\n  trackId: string | undefined\n) => number;\n\n/** The live window plus the target playhead position within it. */\nexport interface LiveEdge extends LiveWindow {\n  /** Where to sit near the live edge: `end` − live latency, clamped to `start`. */\n  liveEdgeStart: number;\n}\n\n/**\n * Resolve the live edge — the window bounds plus the target playhead position — from a behavior's setup arguments.\n * Bundles the window geometry and the format-specific latency policy (`config.resolveLiveLatency`) so the consuming\n * behavior never has to compose them; it just forwards its `{ state, config }`. `null` when there is no live edge (VOD\n * / ended / unresolved).\n *\n * Reads signals lazily — call it inside a reactive context (an effect).\n */\nexport function getLiveEdge({\n  state,\n  // context,  // not needed yet; in the shape for setup-parity when it is\n  config,\n}: {\n  state: LiveWindowState;\n  config?: { resolveLiveLatency?: ResolveLiveLatency };\n}): LiveEdge | null {\n  const window = liveWindowFromState(state);\n  if (!window) return null;\n\n  const latency = config?.resolveLiveLatency?.(state.presentation.get(), liveTrackId(state)) ?? 0;\n\n  return { ...window, liveEdgeStart: Math.max(window.start, window.end - latency) };\n}\n"],"mappings":";;;;;;;;AA6BA,SAAgB,YAAY,OAA4C;CACtE,OAAO,MAAM,sBAAsB,IAAI,KAAK,MAAM,sBAAsB,IAAI;AAC9E;;;;;;;;AASA,SAAS,kBACP,cACA,YACA,MACmB;CACnB,IAAI,CAAC,gBAAgB,eAAe,KAAA,GAAW,OAAO;CAEtD,MAAM,WAAW,cAAc,cAAc,UAAU;CACvD,IAAI,UAAU,OAAO;CAErB,KAAK,MAAM,SAAS,gBAAgB,cAAc,IAAI,GAAG;EACvD,MAAM,SAAS,cAAc,cAAc,MAAM,EAAE;EACnD,IAAI,QAAQ,OAAO;CACrB;CAEA,OAAO;AACT;AAEA,SAAgB,oBAAoB,OAA2C;CAC7E,MAAM,eAAe,MAAM,aAAa,IAAI;CAC5C,MAAM,QAAQ,kBAAkB,cAAc,MAAM,sBAAsB,IAAI,GAAG,OAAO;CACxF,MAAM,QAAQ,kBAAkB,cAAc,MAAM,sBAAsB,IAAI,GAAG,OAAO;CAExF,IAAI,SAAS,OAAO;EAClB,MAAM,QAAQ,KAAK,IAAI,MAAM,OAAO,MAAM,KAAK;EAC/C,MAAM,MAAM,KAAK,IAAI,MAAM,KAAK,MAAM,GAAG;EAKzC,OAAO,QAAQ,MAAM;GAAE;GAAO;EAAI,IAAI;CACxC;CAEA,OAAO,SAAS;AAClB;;;;;;;;;AA0BA,SAAgB,YAAY,EAC1B,OAEA,UAIkB;CAClB,MAAM,SAAS,oBAAoB,KAAK;CACxC,IAAI,CAAC,QAAQ,OAAO;CAEpB,MAAM,UAAU,QAAQ,qBAAqB,MAAM,aAAa,IAAI,GAAG,YAAY,KAAK,CAAC,KAAK;CAE9F,OAAO;EAAE,GAAG;EAAQ,eAAe,KAAK,IAAI,OAAO,OAAO,OAAO,MAAM,OAAO;CAAE;AAClF"}

package/dist/dev/playback/primitives/relocation-pipelines.js

@@ -0,0 +1,191 @@
+import { peek, update } from "../../core/signals/primitives.js";
+import { effect } from "../../core/signals/effect.js";
+import { resolveVttSegmentMetadata } from "../../media/text/resolve-vtt-metadata.js";
+import { findTrackById, getTracksByType } from "../../media/utils/tracks.js";
+import { dispatchCuesStep, textStepWiring } from "./text-segment-load-pipeline.js";
+import { dispatchStep, fetchStep } from "./segment-load-pipeline.js";
+import { findMediaTrack, readBaseMediaDecodeTime } from "../../media/mp4/timestamp-origin.js";
+import { peekHead } from "./head-peek.js";
+//#region src/playback/primitives/relocation-pipelines.ts
+/** Assert the relocation state view from the opaque step deps — this module knows the slots the composition provides. */
+function relocationState(deps) {
+	return deps.state;
+}
+function containerSlot(deps) {
+	return relocationState(deps).mediaContainerData;
+}
+/** Synchronous RMW of the per-type entry — disjoint keys across producers, so no lost update. */
+function writeContainer(slot, trackType, patch) {
+	update(slot, (current) => ({
+		...current,
+		[trackType]: {
+			...current?.[trackType],
+			...patch
+		}
+	}));
+}
+/**
+* Resolve once `read()` returns a number. Shared by the A/V stamp (waits for the `derive`d origin — immediate for
+* per-type, the shared-`min` barrier for coordinated) and the text step (waits for the primary A/V origin). No bound:
+* for fMP4 the origin always establishes.
+*/
+function awaitDefined(read) {
+	return new Promise((resolve) => {
+		let stop;
+		stop = effect(() => {
+			const value = read();
+			if (value !== void 0) {
+				stop?.();
+				resolve(value);
+			}
+		});
+	});
+}
+/**
+* Relocation pipelines for one track type — a plain config `messagePipelines`. Keyed by **track type** (`'video'` /
+* `'audio'`), so ABR rungs of a type share the origin (discover skips once the type's value is present). The steps
+* read/write `state.mediaContainerData[trackType]` via their call-time `deps`; the stamp applies the same `derive` seam
+* the reactor uses (pass the composition's resolved `deriveStartMediaTime` so the buffer offset and the model's
+* `startMediaTime` agree).
+*/
+function relocationPipelinesFor(trackType, derive) {
+	const handlerType = trackType === "video" ? "vide" : "soun";
+	/**
+	* Init step: head-peek the buffered media track's `track_id` + `mdhd` timescale into `mediaContainerData[trackType]`.
+	* Matching by handler (`vide`/`soun`) skips a muxed `clcp` caption track, and the `track_id` lets `readSegmentOrigin`
+	* read _this_ track's `tfdt` rather than the first `traf` in the segment.
+	*/
+	const readInitTrackInfo = async (frame, _signal, deps) => {
+		const { op } = frame;
+		if (op.type !== "append-init" || !frame.data) return;
+		const slot = containerSlot(deps);
+		if (peek(slot)?.[trackType]?.timescale !== void 0) return;
+		frame.data = await peekHead(frame.data, (bytes) => {
+			const track = findMediaTrack(bytes, handlerType);
+			if (track === void 0) return false;
+			writeContainer(slot, trackType, {
+				trackId: track.trackId,
+				timescale: track.timescale
+			});
+			return true;
+		});
+	};
+	/**
+	* Media-segment step: head-peek the `tfdt` baseMediaDecodeTime of the media track's `traf` (matched by the `track_id`
+	* discovered from the init), recording the segment's 0-based `startTime` with it — the origin is `bmdt/ts −
+	* segmentStartTime`, so the first _loaded_ segment need not be the 0th. Without a discovered `track_id` (non-fMP4 /
+	* mock init) there's no media track to relocate, so the step no-ops and the append stays native.
+	*/
+	const readSegmentOrigin = async (frame, _signal, deps) => {
+		const { op } = frame;
+		if (op.type !== "append-segment" || !frame.data) return;
+		const slot = containerSlot(deps);
+		const container = peek(slot)?.[trackType];
+		if (container?.baseMediaDecodeTime !== void 0) return;
+		const { trackId } = container ?? {};
+		if (trackId === void 0) return;
+		const segmentStartTime = op.meta.startTime;
+		frame.data = await peekHead(frame.data, (bytes) => {
+			const baseMediaDecodeTime = readBaseMediaDecodeTime(bytes, trackId);
+			if (baseMediaDecodeTime === void 0) return false;
+			writeContainer(slot, trackType, {
+				baseMediaDecodeTime,
+				segmentStartTime
+			});
+			return true;
+		});
+	};
+	/**
+	* Stamp step — tier-agnostic apply. Relocate by the `derive`d `startMediaTime` for this type (`offset =
+	* −startMediaTime`). Applies the **same** `derive` the reactor uses, over the shared `mediaContainerData` slot — so
+	* the buffer offset matches the model's stamped `startMediaTime`, and it's robust to `established` + late tracks (the
+	* slot persists; the model value may not be re-stamped after the reactor goes sticky). Awaited: per-type resolves at
+	* once (own origin discovered earlier in this pipeline); shared-`min` waits until every selected A/V origin is in —
+	* the barrier, filled by the other type's discover step. A derived `0` (0-PTS / below threshold) leaves the append
+	* native — setting `timestampOffset` at all can ripple.
+	*/
+	const stampStartMediaTime = async (frame, signal, deps) => {
+		if (frame.op.type !== "append-segment") return;
+		const state = relocationState(deps);
+		const own = peek(state.mediaContainerData)?.[trackType];
+		if (own?.timescale === void 0 || own.baseMediaDecodeTime === void 0 || own.segmentStartTime === void 0) return;
+		const startMediaTime = await awaitDefined(() => {
+			const containerData = state.mediaContainerData.get();
+			if (!containerData) return void 0;
+			return derive(containerData, {
+				selectedVideoTrackId: state.selectedVideoTrackId?.get(),
+				selectedAudioTrackId: state.selectedAudioTrackId?.get()
+			})[trackType];
+		});
+		if (signal.aborted || startMediaTime === 0) return;
+		frame.meta = {
+			...frame.meta ?? frame.op.meta,
+			timestampOffset: -startMediaTime
+		};
+	};
+	return () => ({
+		remove: [dispatchStep],
+		"append-init": [
+			fetchStep,
+			readInitTrackInfo,
+			dispatchStep
+		],
+		"append-segment": [
+			fetchStep,
+			readSegmentOrigin,
+			stampStartMediaTime,
+			dispatchStep
+		]
+	});
+}
+/**
+* Resolve step for the relocation text pipeline. Reuses the injected host resolver (the loader's folded
+* `resolveSegment`, via `textStepWiring`) for cues and fetches the `X-TIMESTAMP-MAP` header in parallel, stashing it on
+* `frame.metadata` for `relocateCuesStep`. Replaces the base `resolveCuesStep` (which fetches cues only) — text's
+* native `<track>` parser discards the header, so the map needs its own raw-bytes fetch.
+*/
+const resolveWithMetadataStep = async (frame, signal, deps) => {
+	const [cues, metadata] = await Promise.all([textStepWiring(deps).resolveSegment(frame.op.segment.url), resolveVttSegmentMetadata(frame.op.segment.url)]);
+	if (signal.aborted) return;
+	frame.cues = cues;
+	frame.metadata = metadata;
+};
+/**
+* Relocate step — shifts each cue onto the 0-based presentation timeline: `cueFinal = cueNative − startMediaTime`,
+* where `startMediaTime` is the primary A/V track's origin (selected **video**, else **audio** — the single-anchor
+* rule, and defensive like the reactor's optional selection) and `cueNative` folds in the `X-TIMESTAMP-MAP` correction
+* (`mpegts/90000 − local`) for map-bearing VTT (Apple) or is the absolute cue time (no map, e.g. Mux). Text can resolve
+* before A/V establishes, so the origin is awaited; fMP4 always establishes it (0-PTS → 0), and a text-only source (no
+* A/V selected) simply gets offset 0.
+*/
+const relocateCuesStep = async (frame, signal, deps) => {
+	if (!frame.cues?.length) return;
+	const state = deps.state;
+	const startMediaTime = await awaitDefined(() => {
+		const presentation = state.presentation.get();
+		if (!presentation) return void 0;
+		const primaryId = state.selectedVideoTrackId.get() ?? state.selectedAudioTrackId.get();
+		if (primaryId !== void 0) return findTrackById(presentation, primaryId)?.startMediaTime;
+		return getTracksByType(presentation, "video").length > 0 || getTracksByType(presentation, "audio").length > 0 ? void 0 : 0;
+	});
+	if (signal.aborted) return;
+	const { timestampMap } = frame.metadata ?? {};
+	const delta = (timestampMap ? timestampMap.mpegts / 9e4 - timestampMap.local : 0) - startMediaTime;
+	if (delta !== 0) for (const cue of frame.cues) {
+		cue.startTime += delta;
+		cue.endTime += delta;
+	}
+};
+/**
+* Relocation text pipeline — the text analog of `relocationPipelinesFor(type)`. `resolveWithMetadata` (cues +
+* `X-TIMESTAMP-MAP`) → `relocateCues` (shift by the primary A/V origin) → `dispatchCues`.
+*/
+const relocatingTextPipelines = () => [
+	resolveWithMetadataStep,
+	relocateCuesStep,
+	dispatchCuesStep
+];
+//#endregion
+export { relocatingTextPipelines, relocationPipelinesFor };
+
+//# sourceMappingURL=relocation-pipelines.js.map

package/dist/dev/playback/primitives/relocation-pipelines.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relocation-pipelines.js","names":[],"sources":["../../../../src/playback/primitives/relocation-pipelines.ts"],"sourcesContent":["/**\n * Non-zero-PTS relocation pipelines — the config-supplied, loader-facing half of the `establishStartMediaTime` behavior\n * (`../behaviors/establish-start-media-time`). The reactor there owns the lifecycle and the `derive` coordination seam;\n * this file supplies the `messagePipelines` the segment/text loaders run to _fill and act on_ that behavior's state.\n * It's the relocation analog of `track-switching`'s config-supplied constraint/rule chain — a pluggable strategy handed\n * to the machinery via config, not applied inline — supplied to the loaders rather than applied by the behavior, so the\n * two coordinate through the shared `mediaContainerData` / `startMediaTime` slots alone, never by import.\n *\n * DOM-free: it composes the loader vocabularies (`segment-load-pipeline`, `text-segment-load-pipeline`) through their\n * structural sink seams and shifts cues via the structural `Cue` type, so it names no `SourceBuffer`,\n * `TextTracksActor`, or `VTTCue`. The A/V pipeline is a plain `messagePipelines` array:\n *\n * - `discover` — init `track_id` + `mdhd` timescale for the buffered media track, then that same track's `tfdt`\n *   baseMediaDecodeTime, matched by `track_id` so a muxed segment reads the media track's origin, not the first `traf`\n *   — writes `state.mediaContainerData`.\n * - `stamp` — reads that track's derived origin back and relocates via `timestampOffset = −startMediaTime`. Steps read\n *   composition `state` from their call-time `deps` (no closures, no context).\n *\n * The text half (`relocatingTextPipelines`) is the same idea for the text-segment loader: a `resolveWithMetadata →\n * relocateCues → dispatchCues` pipeline that shifts cues onto the same 0-based timeline, reading the primary A/V\n * track's `startMediaTime` (the reactor's consumed value) via `deps`.\n */\nimport type { StateSignals } from '../../core/composition/create-composition';\nimport { effect } from '../../core/signals/effect';\nimport { peek, type Signal, update } from '../../core/signals/primitives';\nimport { findMediaTrack, type MediaHandlerType, readBaseMediaDecodeTime } from '../../media/mp4/timestamp-origin';\nimport { resolveVttSegmentMetadata, type TextSegmentMetadata } from '../../media/text/resolve-vtt-metadata';\nimport type { Cue, MaybeResolvedPresentation, MediaContainerData } from '../../media/types';\nimport { findTrackById, getTracksByType } from '../../media/utils/tracks';\nimport type { DeriveStartMediaTime } from './derive-start-media-time';\nimport { peekHead } from './head-peek';\nimport { dispatchStep, fetchStep, type LoadStep, type MessagePipelines, type StepDeps } from './segment-load-pipeline';\nimport {\n  dispatchCuesStep,\n  type TextFrame,\n  type TextLoadStep,\n  type TextStepDeps,\n  textStepWiring,\n} from './text-segment-load-pipeline';\n\n/** The composition slots these steps read — the view asserted from the opaque `deps.state`. */\ninterface RelocationSlots {\n  presentation?: MaybeResolvedPresentation;\n  mediaContainerData?: Record<string, MediaContainerData>;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n}\n\ntype ContainerSlot = Signal<Record<string, MediaContainerData> | undefined>;\n\n/** Assert the relocation state view from the opaque step deps — this module knows the slots the composition provides. */\nfunction relocationState(deps: StepDeps): StateSignals<RelocationSlots> {\n  return deps.state as unknown as StateSignals<RelocationSlots>;\n}\n\nfunction containerSlot(deps: StepDeps): ContainerSlot {\n  return relocationState(deps).mediaContainerData;\n}\n\n/** Synchronous RMW of the per-type entry — disjoint keys across producers, so no lost update. */\nfunction writeContainer(slot: ContainerSlot, trackType: string, patch: Partial<MediaContainerData>): void {\n  update(slot, (current) => ({ ...current, [trackType]: { ...current?.[trackType], ...patch } }));\n}\n\n/**\n * Resolve once `read()` returns a number. Shared by the A/V stamp (waits for the `derive`d origin — immediate for\n * per-type, the shared-`min` barrier for coordinated) and the text step (waits for the primary A/V origin). No bound:\n * for fMP4 the origin always establishes.\n */\nfunction awaitDefined(read: () => number | undefined): Promise<number> {\n  return new Promise((resolve) => {\n    let stop: (() => void) | undefined;\n\n    stop = effect(() => {\n      const value = read();\n\n      if (value !== undefined) {\n        stop?.();\n        resolve(value);\n      }\n    });\n  });\n}\n\n/**\n * Relocation pipelines for one track type — a plain config `messagePipelines`. Keyed by **track type** (`'video'` /\n * `'audio'`), so ABR rungs of a type share the origin (discover skips once the type's value is present). The steps\n * read/write `state.mediaContainerData[trackType]` via their call-time `deps`; the stamp applies the same `derive` seam\n * the reactor uses (pass the composition's resolved `deriveStartMediaTime` so the buffer offset and the model's\n * `startMediaTime` agree).\n */\nexport function relocationPipelinesFor(trackType: 'video' | 'audio', derive: DeriveStartMediaTime): MessagePipelines {\n  const handlerType: MediaHandlerType = trackType === 'video' ? 'vide' : 'soun';\n\n  /**\n   * Init step: head-peek the buffered media track's `track_id` + `mdhd` timescale into `mediaContainerData[trackType]`.\n   * Matching by handler (`vide`/`soun`) skips a muxed `clcp` caption track, and the `track_id` lets `readSegmentOrigin`\n   * read _this_ track's `tfdt` rather than the first `traf` in the segment.\n   */\n  const readInitTrackInfo: LoadStep = async (frame, _signal, deps) => {\n    const { op } = frame;\n    if (op.type !== 'append-init' || !frame.data) return;\n\n    const slot = containerSlot(deps);\n    if (peek(slot)?.[trackType]?.timescale !== undefined) return; // already have it (any rung of this type)\n\n    frame.data = await peekHead(frame.data, (bytes) => {\n      const track = findMediaTrack(bytes, handlerType);\n      if (track === undefined) return false;\n\n      writeContainer(slot, trackType, { trackId: track.trackId, timescale: track.timescale });\n      return true;\n    });\n  };\n\n  /**\n   * Media-segment step: head-peek the `tfdt` baseMediaDecodeTime of the media track's `traf` (matched by the `track_id`\n   * discovered from the init), recording the segment's 0-based `startTime` with it — the origin is `bmdt/ts −\n   * segmentStartTime`, so the first _loaded_ segment need not be the 0th. Without a discovered `track_id` (non-fMP4 /\n   * mock init) there's no media track to relocate, so the step no-ops and the append stays native.\n   */\n  const readSegmentOrigin: LoadStep = async (frame, _signal, deps) => {\n    const { op } = frame;\n    if (op.type !== 'append-segment' || !frame.data) return;\n\n    const slot = containerSlot(deps);\n    const container = peek(slot)?.[trackType];\n    if (container?.baseMediaDecodeTime !== undefined) return; // established\n\n    const { trackId } = container ?? {};\n    if (trackId === undefined) return; // init didn't identify a media track — nothing to match\n\n    const segmentStartTime = op.meta.startTime;\n\n    frame.data = await peekHead(frame.data, (bytes) => {\n      const baseMediaDecodeTime = readBaseMediaDecodeTime(bytes, trackId);\n      if (baseMediaDecodeTime === undefined) return false;\n\n      writeContainer(slot, trackType, { baseMediaDecodeTime, segmentStartTime });\n      return true;\n    });\n  };\n\n  /**\n   * Stamp step — tier-agnostic apply. Relocate by the `derive`d `startMediaTime` for this type (`offset =\n   * −startMediaTime`). Applies the **same** `derive` the reactor uses, over the shared `mediaContainerData` slot — so\n   * the buffer offset matches the model's stamped `startMediaTime`, and it's robust to `established` + late tracks (the\n   * slot persists; the model value may not be re-stamped after the reactor goes sticky). Awaited: per-type resolves at\n   * once (own origin discovered earlier in this pipeline); shared-`min` waits until every selected A/V origin is in —\n   * the barrier, filled by the other type's discover step. A derived `0` (0-PTS / below threshold) leaves the append\n   * native — setting `timestampOffset` at all can ripple.\n   */\n  const stampStartMediaTime: LoadStep = async (frame, signal, deps) => {\n    if (frame.op.type !== 'append-segment') return;\n\n    const state = relocationState(deps);\n    // Liveness guard: if THIS type's own origin wasn't discovered — `readSegmentOrigin`\n    // ran earlier in this pipeline and found no `tfdt` (mock / TS / containerless) — the\n    // source isn't relocatable, so leave the append native and DON'T wait. Only a\n    // discoverable type awaits the derived origin (which for shared-`min` legitimately\n    // blocks on the other selected type — the barrier).\n    const own = peek(state.mediaContainerData)?.[trackType];\n\n    if (own?.timescale === undefined || own.baseMediaDecodeTime === undefined || own.segmentStartTime === undefined) {\n      return;\n    }\n\n    const startMediaTime = await awaitDefined(() => {\n      const containerData = state.mediaContainerData.get();\n      if (!containerData) return undefined;\n\n      return derive(containerData, {\n        selectedVideoTrackId: state.selectedVideoTrackId?.get(),\n        selectedAudioTrackId: state.selectedAudioTrackId?.get(),\n      })[trackType];\n    });\n    if (signal.aborted || startMediaTime === 0) return;\n\n    frame.meta = { ...(frame.meta ?? frame.op.meta), timestampOffset: -startMediaTime };\n  };\n\n  return () => ({\n    remove: [dispatchStep],\n    'append-init': [fetchStep, readInitTrackInfo, dispatchStep],\n    'append-segment': [fetchStep, readSegmentOrigin, stampStartMediaTime, dispatchStep],\n  });\n}\n\n// ============================================================================\n// TEXT (cue relocation)\n// ============================================================================\n\n/**\n * Resolve step for the relocation text pipeline. Reuses the injected host resolver (the loader's folded\n * `resolveSegment`, via `textStepWiring`) for cues and fetches the `X-TIMESTAMP-MAP` header in parallel, stashing it on\n * `frame.metadata` for `relocateCuesStep`. Replaces the base `resolveCuesStep` (which fetches cues only) — text's\n * native `<track>` parser discards the header, so the map needs its own raw-bytes fetch.\n */\nconst resolveWithMetadataStep = async <C extends Cue>(\n  frame: TextFrame<C>,\n  signal: AbortSignal,\n  deps: TextStepDeps\n): Promise<void> => {\n  const [cues, metadata] = await Promise.all([\n    textStepWiring<C>(deps).resolveSegment(frame.op.segment.url),\n    resolveVttSegmentMetadata(frame.op.segment.url),\n  ]);\n\n  if (signal.aborted) return;\n\n  frame.cues = cues;\n  frame.metadata = metadata;\n};\n\n/**\n * Relocate step — shifts each cue onto the 0-based presentation timeline: `cueFinal = cueNative − startMediaTime`,\n * where `startMediaTime` is the primary A/V track's origin (selected **video**, else **audio** — the single-anchor\n * rule, and defensive like the reactor's optional selection) and `cueNative` folds in the `X-TIMESTAMP-MAP` correction\n * (`mpegts/90000 − local`) for map-bearing VTT (Apple) or is the absolute cue time (no map, e.g. Mux). Text can resolve\n * before A/V establishes, so the origin is awaited; fMP4 always establishes it (0-PTS → 0), and a text-only source (no\n * A/V selected) simply gets offset 0.\n */\nconst relocateCuesStep = async <C extends Cue>(\n  frame: TextFrame<C>,\n  signal: AbortSignal,\n  deps: TextStepDeps\n): Promise<void> => {\n  if (!frame.cues?.length) return;\n\n  const state = deps.state as unknown as StateSignals<RelocationSlots>;\n  const startMediaTime = await awaitDefined(() => {\n    const presentation = state.presentation.get();\n    if (!presentation) return undefined;\n\n    const primaryId = state.selectedVideoTrackId.get() ?? state.selectedAudioTrackId.get();\n\n    if (primaryId !== undefined) {\n      // A/V selected: use its origin once stamped (undefined until then → keep waiting).\n      return findTrackById(presentation, primaryId)?.startMediaTime;\n    }\n\n    // No A/V selected. Distinguish \"not selected YET\" from \"text-only source\". If the\n    // presentation has A/V tracks, one WILL be selected and stamped — wait for it, or the\n    // cues get shifted by the full `mapCorrection` (e.g. +10s on Apple X-TIMESTAMP-MAP\n    // sources) when text relocation wins the race against A/V selection. Only a genuinely\n    // text-only source (no A/V origin ever coming) legitimately relocates by offset 0.\n    const hasAv =\n      getTracksByType(presentation, 'video').length > 0 || getTracksByType(presentation, 'audio').length > 0;\n\n    return hasAv ? undefined : 0;\n  });\n\n  if (signal.aborted) return;\n\n  const { timestampMap } = (frame.metadata as TextSegmentMetadata | undefined) ?? {};\n  const mapCorrection = timestampMap ? timestampMap.mpegts / 90000 - timestampMap.local : 0;\n  const delta = mapCorrection - startMediaTime;\n\n  if (delta !== 0) {\n    for (const cue of frame.cues) {\n      cue.startTime += delta;\n      cue.endTime += delta;\n    }\n  }\n};\n\n/**\n * Relocation text pipeline — the text analog of `relocationPipelinesFor(type)`. `resolveWithMetadata` (cues +\n * `X-TIMESTAMP-MAP`) → `relocateCues` (shift by the primary A/V origin) → `dispatchCues`.\n */\nexport const relocatingTextPipelines = <C extends Cue>(): TextLoadStep<C>[] => [\n  resolveWithMetadataStep,\n  relocateCuesStep,\n  dispatchCuesStep,\n];\n"],"mappings":"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"}

package/dist/dev/playback/primitives/report-track-conditions.d.ts

@@ -0,0 +1,8 @@
+import { ResolvedTrack } from "../../media/types/index.js";
+import { SvtaError } from "../../media/errors.js";
+//#region src/playback/primitives/report-track-conditions.d.ts
+/** Conditions worth reporting about a just-resolved track. Return an empty array (or omit the seam) to report nothing. */
+type ReportUnsupportedTrackConditions = (track: ResolvedTrack) => readonly SvtaError[];
+//#endregion
+export { ReportUnsupportedTrackConditions };
+//# sourceMappingURL=report-track-conditions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"report-track-conditions.d.ts","names":[],"sources":["../../../../src/playback/primitives/report-track-conditions.ts"],"mappings":";;;;KAwBY,oCAAoC,OAAO,2BAA2B"}

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

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

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

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

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

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

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

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

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

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