@videojs/spf 10.0.0-beta.9 → 10.0.0-rc.2

package/dist/default/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/default/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":";;;;;;;;;;AAmDA,SAAS,gBAAgB,MAA+C;CACtE,OAAO,KAAK;AACd;AAEA,SAAS,cAAc,MAA+B;CACpD,OAAO,gBAAgB,IAAI,CAAC,CAAC;AAC/B;;AAGA,SAAS,eAAe,MAAqB,WAAmB,OAA0C;CACxG,OAAO,OAAO,aAAa;EAAE,GAAG;GAAU,YAAY;GAAE,GAAG,UAAU;GAAY,GAAG;EAAM;CAAE,EAAE;AAChG;;;;;;AAOA,SAAS,aAAa,MAAiD;CACrE,OAAO,IAAI,SAAS,YAAY;EAC9B,IAAI;EAEJ,OAAO,aAAa;GAClB,MAAM,QAAQ,KAAK;GAEnB,IAAI,UAAU,KAAA,GAAW;IACvB,OAAO;IACP,QAAQ,KAAK;GACf;EACF,CAAC;CACH,CAAC;AACH;;;;;;;;AASA,SAAgB,uBAAuB,WAA8B,QAAgD;CACnH,MAAM,cAAgC,cAAc,UAAU,SAAS;;;;;;CAOvE,MAAM,oBAA8B,OAAO,OAAO,SAAS,SAAS;EAClE,MAAM,EAAE,OAAO;EACf,IAAI,GAAG,SAAS,iBAAiB,CAAC,MAAM,MAAM;EAE9C,MAAM,OAAO,cAAc,IAAI;EAC/B,IAAI,KAAK,IAAI,CAAC,GAAG,UAAU,EAAE,cAAc,KAAA,GAAW;EAEtD,MAAM,OAAO,MAAM,SAAS,MAAM,OAAO,UAAU;GACjD,MAAM,QAAQ,eAAe,OAAO,WAAW;GAC/C,IAAI,UAAU,KAAA,GAAW,OAAO;GAEhC,eAAe,MAAM,WAAW;IAAE,SAAS,MAAM;IAAS,WAAW,MAAM;GAAU,CAAC;GACtF,OAAO;EACT,CAAC;CACH;;;;;;;CAQA,MAAM,oBAA8B,OAAO,OAAO,SAAS,SAAS;EAClE,MAAM,EAAE,OAAO;EACf,IAAI,GAAG,SAAS,oBAAoB,CAAC,MAAM,MAAM;EAEjD,MAAM,OAAO,cAAc,IAAI;EAC/B,MAAM,YAAY,KAAK,IAAI,CAAC,GAAG;EAC/B,IAAI,WAAW,wBAAwB,KAAA,GAAW;EAElD,MAAM,EAAE,YAAY,aAAa,CAAC;EAClC,IAAI,YAAY,KAAA,GAAW;EAE3B,MAAM,mBAAmB,GAAG,KAAK;EAEjC,MAAM,OAAO,MAAM,SAAS,MAAM,OAAO,UAAU;GACjD,MAAM,sBAAsB,wBAAwB,OAAO,OAAO;GAClE,IAAI,wBAAwB,KAAA,GAAW,OAAO;GAE9C,eAAe,MAAM,WAAW;IAAE;IAAqB;GAAiB,CAAC;GACzE,OAAO;EACT,CAAC;CACH;;;;;;;;;;CAWA,MAAM,sBAAgC,OAAO,OAAO,QAAQ,SAAS;EACnE,IAAI,MAAM,GAAG,SAAS,kBAAkB;EAExC,MAAM,QAAQ,gBAAgB,IAAI;EAMlC,MAAM,MAAM,KAAK,MAAM,kBAAkB,CAAC,GAAG;EAE7C,IAAI,KAAK,cAAc,KAAA,KAAa,IAAI,wBAAwB,KAAA,KAAa,IAAI,qBAAqB,KAAA,GACpG;EAGF,MAAM,iBAAiB,MAAM,mBAAmB;GAC9C,MAAM,gBAAgB,MAAM,mBAAmB,IAAI;GACnD,IAAI,CAAC,eAAe,OAAO,KAAA;GAE3B,OAAO,OAAO,eAAe;IAC3B,sBAAsB,MAAM,sBAAsB,IAAI;IACtD,sBAAsB,MAAM,sBAAsB,IAAI;GACxD,CAAC,CAAC,CAAC;EACL,CAAC;EACD,IAAI,OAAO,WAAW,mBAAmB,GAAG;EAE5C,MAAM,OAAO;GAAE,GAAI,MAAM,QAAQ,MAAM,GAAG;GAAO,iBAAiB,CAAC;EAAe;CACpF;CAEA,cAAc;EACZ,QAAQ,CAAC,YAAY;EACrB,eAAe;GAAC;GAAW;GAAmB;EAAY;EAC1D,kBAAkB;GAAC;GAAW;GAAmB;GAAqB;EAAY;CACpF;AACF;;;;;;;AAYA,MAAM,0BAA0B,OAC9B,OACA,QACA,SACkB;CAClB,MAAM,CAAC,MAAM,YAAY,MAAM,QAAQ,IAAI,CACzC,eAAkB,IAAI,CAAC,CAAC,eAAe,MAAM,GAAG,QAAQ,GAAG,GAC3D,0BAA0B,MAAM,GAAG,QAAQ,GAAG,CAChD,CAAC;CAED,IAAI,OAAO,SAAS;CAEpB,MAAM,OAAO;CACb,MAAM,WAAW;AACnB;;;;;;;;;AAUA,MAAM,mBAAmB,OACvB,OACA,QACA,SACkB;CAClB,IAAI,CAAC,MAAM,MAAM,QAAQ;CAEzB,MAAM,QAAQ,KAAK;CACnB,MAAM,iBAAiB,MAAM,mBAAmB;EAC9C,MAAM,eAAe,MAAM,aAAa,IAAI;EAC5C,IAAI,CAAC,cAAc,OAAO,KAAA;EAE1B,MAAM,YAAY,MAAM,qBAAqB,IAAI,KAAK,MAAM,qBAAqB,IAAI;EAErF,IAAI,cAAc,KAAA,GAEhB,OAAO,cAAc,cAAc,SAAS,CAAC,EAAE;EAWjD,OAFE,gBAAgB,cAAc,OAAO,CAAC,CAAC,SAAS,KAAK,gBAAgB,cAAc,OAAO,CAAC,CAAC,SAAS,IAExF,KAAA,IAAY;CAC7B,CAAC;CAED,IAAI,OAAO,SAAS;CAEpB,MAAM,EAAE,iBAAkB,MAAM,YAAgD,CAAC;CAEjF,MAAM,SADgB,eAAe,aAAa,SAAS,MAAQ,aAAa,QAAQ,KAC1D;CAE9B,IAAI,UAAU,GACZ,KAAK,MAAM,OAAO,MAAM,MAAM;EAC5B,IAAI,aAAa;EACjB,IAAI,WAAW;CACjB;AAEJ;;;;;AAMA,MAAa,gCAAkE;CAC7E;CACA;CACA;AACF"}

package/dist/default/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/default/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/default/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/default/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"}

package/dist/default/playback/primitives/selection-rules.js

@@ -0,0 +1,115 @@
+import { getCodecFamilies, getCodecFamily } from "../../media/utils/tracks.js";
+//#region src/playback/primitives/selection-rules.ts
+/**
+* Apply rules to a candidate list in order; the pick is the first survivor. Two responsibilities the rules don't carry:
+* a rule that returns nothing is skipped (fall-through — a preference never empties the set), and once one survivor
+* remains the chain stops (early-bail — later rules, including the bandwidth ranker, never run, so the effect doesn't
+* subscribe to their signals while the choice is fixed).
+*
+* @param rules - Rules to apply, most authoritative first
+* @param tracks - Candidate tracks
+* @param deps - The behavior's `{ state, context, config }`, passed through to each rule
+* @returns The surviving candidates, pick first
+*/
+function applyRules(rules, tracks, deps) {
+	let current = tracks;
+	for (const rule of rules) {
+		const remaining = rule(current, deps);
+		if (remaining.length === 0) continue;
+		current = remaining;
+		if (current.length === 1) break;
+	}
+	return current;
+}
+/**
+* Apply hard constraints to a candidate list — the pre-pass that runs before the rule chain. A constraint shares a
+* rule's signature but its exclusion is _hard_: it removes the unplayable (a codec the environment can't decode, a CDN
+* in failover cooldown) and a removed track is never attempted. Unlike `applyRules`, this never skips an empty result
+* and never early-bails — every constraint always applies, and an empty survivor set is a real outcome ("nothing
+* playable here"), not a fall-through. Because each constraint only removes, the order they run in can't change which
+* tracks survive — though one that also _reports_ reads the list at its own position, so placement matters.
+*
+* @param constraints - Constraints to apply, in order
+* @param tracks - Candidate tracks
+* @param deps - The behavior's `{ state, context, config }`, passed to each constraint
+* @returns The playable survivors (possibly empty)
+*/
+function applyConstraints(constraints, tracks, deps) {
+	let current = tracks;
+	for (const constraint of constraints) current = constraint(current, deps);
+	return current;
+}
+/**
+* Whether two candidate sets hold the same tracks, by id.
+*
+* The `equals` both selection behaviors give their candidate-set `computed`. A live playlist refresh swaps in a new
+* presentation object carrying the same variants, and a constraint's own inputs can churn without changing which tracks
+* survive; in both cases the set is unchanged and the reaction must not re-fire. Compares by id rather than array
+* identity for exactly that.
+*/
+function sameCandidateSet(a, b) {
+	return a.length === b.length && a.every((track) => b.some((other) => other.id === track.id));
+}
+/**
+* Capability constraint — a _hard_ filter for the {@link applyConstraints} pre-pass. Removes renditions this
+* environment can't decode, probed via the injected `canPlayTrack` (codec → `MediaSource.isTypeSupported`, plus the
+* container and encryption assertions that probe can't make). Constraining here — before selection — means an
+* unplayable variant is pruned upstream and never picked, instead of surviving into the pipeline to fail late at
+* `createSourceBuffer`. That late throw stays as a defensive structural guarantee; with this constraint it should
+* rarely fire.
+*
+* Lives here rather than beside `switchVideoTrack` for the reason this module exists: both the re-evaluating variant
+* and the pinned `selectVideoTrack` apply it, and reaching it through `behaviors/track-switching.ts` would drag the ABR
+* path into a composition that deliberately omits it.
+*
+* Passes everything through when there's no probe (a composition that didn't wire one, or DOM-free tests). When it
+* prunes _every_ track, the empty result is preserved (per `applyConstraints`) — "nothing playable" — which each
+* consuming behavior answers by clearing its selection; reporting the verdict is separate.
+*/
+function excludeUnplayableTracks(tracks, { config }) {
+	const canPlay = config?.canPlayTrack;
+	if (!canPlay) return tracks;
+	return tracks.filter((track) => canPlay(track));
+}
+/**
+* The codec families {@link preferCodecFamilies} narrows to when the config carries no `preferredCodecs`: AVC (both its
+* 4CCs) and AAC. The default is deliberate rather than neutral — SPF implements no `SourceBuffer.changeType()`, so on a
+* mixed-codec source the _initial_ family choice is the one ABR lives inside for the whole source (see
+* `stickToSelectedCodecs` in `behaviors/track-switching.ts`), and AVC/AAC is the family pair with the broadest decode
+* support. The cost, equally deliberate: on a ladder whose higher rungs are HEVC-only (a common 4K shape), the default
+* caps quality at the top AVC rung — configure `preferredCodecs` (or pass `[]`) to trade the other way.
+*/
+const DEFAULT_PREFERRED_CODECS = [
+	"avc1",
+	"avc3",
+	"mp4a"
+];
+/**
+* Codec-family preference — a _soft_ filter (scope) for a selection-rule chain; the `hevc-variant-selection` concern
+* from `internal/design/spf/track-switching-model.md`. Narrows to the tracks whose codec families are all in
+* `preferredCodecs` (family-compared, so entries may be 4CCs or full codec strings). Soft-filter semantics: a source
+* with no preferred-family rendition (an HEVC-only ladder under the AVC default) is left unnarrowed, and a track
+* without codecs never matches — on a ladder with no codecs anywhere (DOM-free tests) the rule is inert.
+*
+* `preferredCodecs` defaults to {@link DEFAULT_PREFERRED_CODECS}; explicitly pass `[]` to disable the preference while
+* keeping the rule composed.
+*
+* "All families" rather than "any" so a muxed rendition is judged as the unit it is: `hvc1,mp4a` must not count as
+* preferred just because its audio half matches.
+*
+* Lives here rather than beside `switchVideoTrack` for the module's usual reason: the pinned `selectVideoTrack` variant
+* can compose it without dragging the ABR path in.
+*/
+function preferCodecFamilies(tracks, { config }) {
+	const preferred = config?.preferredCodecs ?? DEFAULT_PREFERRED_CODECS;
+	if (!preferred.length) return tracks;
+	const preferredFamilies = new Set(preferred.map(getCodecFamily));
+	return tracks.filter((track) => {
+		const families = getCodecFamilies(track);
+		return !!families && families.every((family) => preferredFamilies.has(family));
+	});
+}
+//#endregion
+export { DEFAULT_PREFERRED_CODECS, applyConstraints, applyRules, excludeUnplayableTracks, preferCodecFamilies, sameCandidateSet };
+
+//# sourceMappingURL=selection-rules.js.map

package/dist/default/playback/primitives/selection-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-rules.js","names":[],"sources":["../../../../src/playback/primitives/selection-rules.ts"],"sourcesContent":["/**\n * The selection-rule substrate: the shape of a rule, and the two composers that turn a list of them into a pick.\n *\n * Lives here rather than beside `switchVideoTrack` so both track-selection behaviors can share rules. The simple\n * `selectVideoTrack` variant exists specifically to tree-shake the ABR path out, so importing a composer from\n * `behaviors/track-switching.ts` would drag the bandwidth estimator and quality selection back in with it. Nothing here\n * reaches past pure generics over a candidate list and small media-layer helpers, so either side can reach them\n * freely.\n *\n * See `internal/design/spf/track-switching-model.md` for the model these implement: a hard constraints pre-pass, then\n * an ordered chain of soft narrowing rules and rankers, with the pick as the first survivor.\n */\n\nimport type { CanPlayTrack } from '../../media/types';\nimport { getCodecFamilies, getCodecFamily } from '../../media/utils/tracks';\n\n/**\n * Deps handed to each rule and to `applyRules`, mirroring a behavior's setup deps so a rule reads from the same\n * surfaces a behavior does. `context` is optional — it's threaded through but absent on direct setup calls (and unread\n * by today's rules), so the whole deps object can pass straight through.\n */\nexport interface SelectionRuleDeps<State = unknown, Context = unknown, Config = unknown> {\n  state: State;\n  context?: Context;\n  config: Config;\n}\n\n/**\n * A selection rule narrows or reorders the candidate list. It reads the state, context, and config it needs at apply\n * time (tightly-coupled reads), so a rule's `.get()`s subscribe the running effect to exactly what it consulted.\n * Returning an empty list means \"no match\" — the composer skips it, so a soft filter never narrows the set to nothing.\n * A ranker returns the list with its pick at the head.\n */\nexport type SelectionRule<T, State = unknown, Context = unknown, Config = unknown> = (\n  tracks: readonly T[],\n  deps: SelectionRuleDeps<State, Context, Config>\n) => readonly T[];\n\n/**\n * Apply rules to a candidate list in order; the pick is the first survivor. Two responsibilities the rules don't carry:\n * a rule that returns nothing is skipped (fall-through — a preference never empties the set), and once one survivor\n * remains the chain stops (early-bail — later rules, including the bandwidth ranker, never run, so the effect doesn't\n * subscribe to their signals while the choice is fixed).\n *\n * @param rules - Rules to apply, most authoritative first\n * @param tracks - Candidate tracks\n * @param deps - The behavior's `{ state, context, config }`, passed through to each rule\n * @returns The surviving candidates, pick first\n */\nexport function applyRules<T, State, Context, Config>(\n  rules: readonly SelectionRule<T, State, Context, Config>[],\n  tracks: readonly T[],\n  deps: SelectionRuleDeps<State, Context, Config>\n): readonly T[] {\n  let current = tracks;\n\n  for (const rule of rules) {\n    const remaining = rule(current, deps);\n    if (remaining.length === 0) continue;\n\n    current = remaining;\n\n    if (current.length === 1) break;\n  }\n\n  return current;\n}\n\n/**\n * Apply hard constraints to a candidate list — the pre-pass that runs before the rule chain. A constraint shares a\n * rule's signature but its exclusion is _hard_: it removes the unplayable (a codec the environment can't decode, a CDN\n * in failover cooldown) and a removed track is never attempted. Unlike `applyRules`, this never skips an empty result\n * and never early-bails — every constraint always applies, and an empty survivor set is a real outcome (\"nothing\n * playable here\"), not a fall-through. Because each constraint only removes, the order they run in can't change which\n * tracks survive — though one that also _reports_ reads the list at its own position, so placement matters.\n *\n * @param constraints - Constraints to apply, in order\n * @param tracks - Candidate tracks\n * @param deps - The behavior's `{ state, context, config }`, passed to each constraint\n * @returns The playable survivors (possibly empty)\n */\nexport function applyConstraints<T, State, Context, Config>(\n  constraints: readonly SelectionRule<T, State, Context, Config>[],\n  tracks: readonly T[],\n  deps: SelectionRuleDeps<State, Context, Config>\n): readonly T[] {\n  let current = tracks;\n\n  for (const constraint of constraints) current = constraint(current, deps);\n\n  return current;\n}\n\n/**\n * Whether two candidate sets hold the same tracks, by id.\n *\n * The `equals` both selection behaviors give their candidate-set `computed`. A live playlist refresh swaps in a new\n * presentation object carrying the same variants, and a constraint's own inputs can churn without changing which tracks\n * survive; in both cases the set is unchanged and the reaction must not re-fire. Compares by id rather than array\n * identity for exactly that.\n */\nexport function sameCandidateSet<T extends { id: string }>(a: readonly T[], b: readonly T[]): boolean {\n  return a.length === b.length && a.every((track) => b.some((other) => other.id === track.id));\n}\n\n/**\n * What {@link excludeUnplayableTracks} reads off the config it is handed.\n *\n * Read through a cast rather than constraining the rule's `Config` generic, the same way `screenResolutionCap` reads\n * `screenResolution` off its state: a rule composes into chains whose config types have nothing else in common, and\n * constraining the generic would make every one of those a weak-type mismatch. Each engine defaults `canPlayTrack` to\n * the DOM-bound probe; unwired means \"no capability filtering\" and the constraint passes everything through.\n */\nexport interface CapabilityConstraintConfig {\n  canPlayTrack?: CanPlayTrack;\n}\n\n/**\n * Capability constraint — a _hard_ filter for the {@link applyConstraints} pre-pass. Removes renditions this\n * environment can't decode, probed via the injected `canPlayTrack` (codec → `MediaSource.isTypeSupported`, plus the\n * container and encryption assertions that probe can't make). Constraining here — before selection — means an\n * unplayable variant is pruned upstream and never picked, instead of surviving into the pipeline to fail late at\n * `createSourceBuffer`. That late throw stays as a defensive structural guarantee; with this constraint it should\n * rarely fire.\n *\n * Lives here rather than beside `switchVideoTrack` for the reason this module exists: both the re-evaluating variant\n * and the pinned `selectVideoTrack` apply it, and reaching it through `behaviors/track-switching.ts` would drag the ABR\n * path into a composition that deliberately omits it.\n *\n * Passes everything through when there's no probe (a composition that didn't wire one, or DOM-free tests). When it\n * prunes _every_ track, the empty result is preserved (per `applyConstraints`) — \"nothing playable\" — which each\n * consuming behavior answers by clearing its selection; reporting the verdict is separate.\n */\nexport function excludeUnplayableTracks<T, State, Context, Config>(\n  tracks: readonly T[],\n  { config }: SelectionRuleDeps<State, Context, Config>\n): readonly T[] {\n  const canPlay = (config as CapabilityConstraintConfig | undefined)?.canPlayTrack;\n  if (!canPlay) return tracks;\n\n  return tracks.filter((track) => canPlay(track as Parameters<CanPlayTrack>[0]));\n}\n\n/**\n * What {@link preferCodecFamilies} reads off the config it is handed — a cast view, for the same reason as\n * {@link CapabilityConstraintConfig}.\n */\nexport interface CodecPreferenceConfig {\n  preferredCodecs?: string[];\n}\n\n/**\n * The codec families {@link preferCodecFamilies} narrows to when the config carries no `preferredCodecs`: AVC (both its\n * 4CCs) and AAC. The default is deliberate rather than neutral — SPF implements no `SourceBuffer.changeType()`, so on a\n * mixed-codec source the _initial_ family choice is the one ABR lives inside for the whole source (see\n * `stickToSelectedCodecs` in `behaviors/track-switching.ts`), and AVC/AAC is the family pair with the broadest decode\n * support. The cost, equally deliberate: on a ladder whose higher rungs are HEVC-only (a common 4K shape), the default\n * caps quality at the top AVC rung — configure `preferredCodecs` (or pass `[]`) to trade the other way.\n */\nexport const DEFAULT_PREFERRED_CODECS: readonly string[] = ['avc1', 'avc3', 'mp4a'];\n\n/**\n * Codec-family preference — a _soft_ filter (scope) for a selection-rule chain; the `hevc-variant-selection` concern\n * from `internal/design/spf/track-switching-model.md`. Narrows to the tracks whose codec families are all in\n * `preferredCodecs` (family-compared, so entries may be 4CCs or full codec strings). Soft-filter semantics: a source\n * with no preferred-family rendition (an HEVC-only ladder under the AVC default) is left unnarrowed, and a track\n * without codecs never matches — on a ladder with no codecs anywhere (DOM-free tests) the rule is inert.\n *\n * `preferredCodecs` defaults to {@link DEFAULT_PREFERRED_CODECS}; explicitly pass `[]` to disable the preference while\n * keeping the rule composed.\n *\n * \"All families\" rather than \"any\" so a muxed rendition is judged as the unit it is: `hvc1,mp4a` must not count as\n * preferred just because its audio half matches.\n *\n * Lives here rather than beside `switchVideoTrack` for the module's usual reason: the pinned `selectVideoTrack` variant\n * can compose it without dragging the ABR path in.\n */\nexport function preferCodecFamilies<T, State, Context, Config>(\n  tracks: readonly T[],\n  { config }: SelectionRuleDeps<State, Context, Config>\n): readonly T[] {\n  const preferred = (config as CodecPreferenceConfig | undefined)?.preferredCodecs ?? DEFAULT_PREFERRED_CODECS;\n  if (!preferred.length) return tracks;\n\n  const preferredFamilies = new Set(preferred.map(getCodecFamily));\n\n  return tracks.filter((track) => {\n    const families = getCodecFamilies(track as { codecs?: string[] });\n\n    return !!families && families.every((family) => preferredFamilies.has(family));\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AAiDA,SAAgB,WACd,OACA,QACA,MACc;CACd,IAAI,UAAU;CAEd,KAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,YAAY,KAAK,SAAS,IAAI;EACpC,IAAI,UAAU,WAAW,GAAG;EAE5B,UAAU;EAEV,IAAI,QAAQ,WAAW,GAAG;CAC5B;CAEA,OAAO;AACT;;;;;;;;;;;;;;AAeA,SAAgB,iBACd,aACA,QACA,MACc;CACd,IAAI,UAAU;CAEd,KAAK,MAAM,cAAc,aAAa,UAAU,WAAW,SAAS,IAAI;CAExE,OAAO;AACT;;;;;;;;;AAUA,SAAgB,iBAA2C,GAAiB,GAA0B;CACpG,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,UAAU,EAAE,MAAM,UAAU,MAAM,OAAO,MAAM,EAAE,CAAC;AAC7F;;;;;;;;;;;;;;;;;AA8BA,SAAgB,wBACd,QACA,EAAE,UACY;CACd,MAAM,UAAW,QAAmD;CACpE,IAAI,CAAC,SAAS,OAAO;CAErB,OAAO,OAAO,QAAQ,UAAU,QAAQ,KAAoC,CAAC;AAC/E;;;;;;;;;AAkBA,MAAa,2BAA8C;CAAC;CAAQ;CAAQ;AAAM;;;;;;;;;;;;;;;;;AAkBlF,SAAgB,oBACd,QACA,EAAE,UACY;CACd,MAAM,YAAa,QAA8C,mBAAmB;CACpF,IAAI,CAAC,UAAU,QAAQ,OAAO;CAE9B,MAAM,oBAAoB,IAAI,IAAI,UAAU,IAAI,cAAc,CAAC;CAE/D,OAAO,OAAO,QAAQ,UAAU;EAC9B,MAAM,WAAW,iBAAiB,KAA8B;EAEhE,OAAO,CAAC,CAAC,YAAY,SAAS,OAAO,WAAW,kBAAkB,IAAI,MAAM,CAAC;CAC/E,CAAC;AACH"}

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

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

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

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