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

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

@@ -0,0 +1,203 @@
+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\n * `establishStartMediaTime` behavior (`../behaviors/establish-start-media-time`). The\n * reactor there owns the lifecycle and the `derive` coordination seam; this file supplies\n * the `messagePipelines` the segment/text loaders run to *fill and act on* that behavior's\n * state. It's the relocation analog of `track-switching`'s config-supplied constraint/rule\n * chain — a pluggable strategy handed to the machinery via config, not applied inline —\n * supplied to the loaders rather than applied by the behavior, so the two coordinate\n * through the shared `mediaContainerData` / `startMediaTime` slots alone, never by import.\n *\n * DOM-free: it composes the loader vocabularies (`segment-load-pipeline`,\n * `text-segment-load-pipeline`) through their structural sink seams and shifts cues via\n * the structural `Cue` type, so it names no `SourceBuffer`, `TextTracksActor`, or\n * `VTTCue`. The A/V pipeline is a plain `messagePipelines` array:\n *   - `discover` — init `track_id` + `mdhd` timescale for the buffered media track, then\n *     that same track's `tfdt` baseMediaDecodeTime, matched by `track_id` so a muxed\n *     segment reads the media track's origin, not the first `traf` — writes\n *     `state.mediaContainerData`.\n *   - `stamp` — reads that track's derived origin back and relocates via\n *     `timestampOffset = −startMediaTime`.\n * Steps read 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:\n * a `resolveWithMetadata → relocateCues → dispatchCues` pipeline that shifts cues onto the\n * same 0-based timeline, reading the primary A/V track's `startMediaTime` (the reactor's\n * 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\n * `derive`d origin — immediate for per-type, the shared-`min` barrier for coordinated)\n * and the text step (waits for the primary A/V origin). No bound: for fMP4 the origin\n * always establishes.\n */\nfunction awaitDefined(read: () => number | undefined): Promise<number> {\n  return new Promise((resolve) => {\n    let stop: (() => void) | undefined;\n    stop = effect(() => {\n      const value = read();\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`.\n * Keyed by **track type** (`'video'` / `'audio'`), so ABR rungs of a type share the\n * origin (discover skips once the type's value is present). The steps read/write\n * `state.mediaContainerData[trackType]` via their call-time `deps`; the stamp applies\n * the same `derive` seam the reactor uses (pass the composition's resolved\n * `deriveStartMediaTime` so the buffer offset and the model's `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\n   * `mediaContainerData[trackType]`. Matching by handler (`vide`/`soun`) skips a muxed\n   * `clcp` caption track, and the `track_id` lets `readSegmentOrigin` read *this*\n   * 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    const slot = containerSlot(deps);\n    if (peek(slot)?.[trackType]?.timescale !== undefined) return; // already have it (any rung of this type)\n    frame.data = await peekHead(frame.data, (bytes) => {\n      const track = findMediaTrack(bytes, handlerType);\n      if (track === undefined) return false;\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\n   * `traf` (matched by the `track_id` discovered from the init), recording the\n   * segment's 0-based `startTime` with it — the origin is `bmdt/ts − segmentStartTime`,\n   * so the first *loaded* segment need not be the 0th. Without a discovered `track_id`\n   * (non-fMP4 / mock init) there's no media track to relocate, so the step no-ops and\n   * 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    const slot = containerSlot(deps);\n    const container = peek(slot)?.[trackType];\n    if (container?.baseMediaDecodeTime !== undefined) return; // established\n    const { trackId } = container ?? {};\n    if (trackId === undefined) return; // init didn't identify a media track — nothing to match\n    const segmentStartTime = op.meta.startTime;\n    frame.data = await peekHead(frame.data, (bytes) => {\n      const baseMediaDecodeTime = readBaseMediaDecodeTime(bytes, trackId);\n      if (baseMediaDecodeTime === undefined) return false;\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\n   * this type (`offset = −startMediaTime`). Applies the **same** `derive` the reactor\n   * uses, over the shared `mediaContainerData` slot — so the buffer offset matches the\n   * model's stamped `startMediaTime`, and it's robust to `established` + late tracks\n   * (the slot persists; the model value may not be re-stamped after the reactor goes\n   * sticky). Awaited: per-type resolves at once (own origin discovered earlier in this\n   * pipeline); shared-`min` waits until every selected A/V origin is in — the barrier,\n   * filled by the other type's discover step. A derived `0` (0-PTS / below threshold)\n   * leaves the append 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    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    if (own?.timescale === undefined || own.baseMediaDecodeTime === undefined || own.segmentStartTime === undefined) {\n      return;\n    }\n    const startMediaTime = await awaitDefined(() => {\n      const containerData = state.mediaContainerData.get();\n      if (!containerData) return undefined;\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    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\n * (the loader's folded `resolveSegment`, via `textStepWiring`) for cues and fetches\n * the `X-TIMESTAMP-MAP` header in parallel, stashing it on `frame.metadata` for\n * `relocateCuesStep`. Replaces the\n * base `resolveCuesStep` (which fetches cues only) — text's native `<track>` parser\n * 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  if (signal.aborted) return;\n  frame.cues = cues;\n  frame.metadata = metadata;\n};\n\n/**\n * Relocate step — shifts each cue onto the 0-based presentation timeline:\n * `cueFinal = cueNative − startMediaTime`, where `startMediaTime` is the primary\n * A/V track's origin (selected **video**, else **audio** — the single-anchor rule,\n * and defensive like the reactor's optional selection) and `cueNative` folds in the\n * `X-TIMESTAMP-MAP` correction (`mpegts/90000 − local`) for map-bearing VTT (Apple)\n * or is the absolute cue time (no map, e.g. Mux). Text can resolve before A/V\n * establishes, so the origin is awaited; fMP4 always establishes it (0-PTS → 0),\n * and a text-only source (no 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  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    const primaryId = state.selectedVideoTrackId.get() ?? state.selectedAudioTrackId.get();\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    // 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    return hasAv ? undefined : 0;\n  });\n  if (signal.aborted) return;\n  const { timestampMap } = (frame.metadata as TextSegmentMetadata | undefined) ?? {};\n  const mapCorrection = timestampMap ? timestampMap.mpegts / 90000 - timestampMap.local : 0;\n  const delta = mapCorrection - startMediaTime;\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)`.\n * `resolveWithMetadata` (cues + `X-TIMESTAMP-MAP`) → `relocateCues` (shift by the\n * 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/default/playback/primitives/report-track-conditions.js

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

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

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

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

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

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

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

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

package/dist/dev/core/actors/actor.d.ts

@@ -1,5 +1,4 @@
 import { Machine, MachineSnapshot } from "../machine.js";
-
 //#region src/core/actors/actor.d.ts
 /**
  * Complete actor snapshot: finite state + non-finite context.

package/dist/dev/core/actors/actor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actor.d.ts","names":[],"sources":["../../../../src/core/actors/actor.ts"],"mappings":";;;;;;;UAeiB,aAAA,uDAAoE,eAAA,CAAgB,KAAA;EACnG,OAAA,EAAS,OAAA;AAAA;;UAIM,WAAA,uDACP,OAAA,CAAQ,aAAA,CAAc,KAAA,EAAO,OAAA;AADvC;;;;;;AAAA,UASiB,aAAA;EAAgC,IAAA;AAAA;EAC/C,IAAA,CAAK,OAAA,EAAS,OAAA;EACd,OAAA;AAAA"}
+{"version":3,"file":"actor.d.ts","names":[],"sources":["../../../../src/core/actors/actor.ts"],"mappings":";;;;;;UAeiB,cAAc,sBAAsB,gCAAgC,gBAAgB;EACnG,SAAS;;;UAIM,YAAY,sBAAsB,gCACzC,QAAQ,cAAc,OAAO;;;;;;;UAQtB,cAAc;EAAkB;;EAC/C,KAAK,SAAS;EACd"}

package/dist/dev/core/actors/create-machine-actor.d.ts

@@ -1,6 +1,5 @@
 import { TaskLike } from "../tasks/task.js";
 import { SignalActor } from "./actor.js";
-
 //#region src/core/actors/create-machine-actor.d.ts
 /**
  * Minimal interface for any runner that can be used with createMachineActor.
@@ -17,7 +16,8 @@ interface RunnerLike {
  * definition includes a runner factory.
  */
 type HandlerContext<UserState extends string, Context extends object, RunnerFactory extends (() => RunnerLike) | undefined> = {
-  transition: (to: UserState) => void; /** Context snapshot captured at dispatch time. Stale after any `setContext` call. */
+  transition: (to: UserState) => void;
+  /** Context snapshot captured at dispatch time. Stale after any `setContext` call. */
   context: Context;
   /**
    * Live untracked read of the current context. Use in async task closures that
@@ -42,10 +42,11 @@ type ActorStateDefinition<UserState extends string, Context extends object, Mess
    * re-registering after each `runner.schedule()` call so that
    * `abortAll()` + reschedule correctly supersedes stale callbacks.
    */
-  onSettled?: UserState; /** Message handlers active in this state. Messages with no handler are silently dropped. */
+  onSettled?: UserState;
+  /** Message handlers active in this state. Messages with no handler are silently dropped. */
   on?: { [M in Message as M['type']]?: (message: Extract<Message, {
     type: M['type'];
-  }>, ctx: HandlerContext<UserState, Context, RunnerFactory>) => void };
+  }>, ctx: HandlerContext<UserState, Context, RunnerFactory>) => void; };
 };
 /**
  * Full actor definition passed to `createMachineActor`.
@@ -63,8 +64,10 @@ type ActorDefinition<UserState extends string, Context extends object, Message e
    * @example
    * runner: () => new SerialRunner()
    */
-  runner?: RunnerFactory; /** Initial state. */
-  initial: UserState; /** Initial context. */
+  runner?: RunnerFactory;
+  /** Initial state. */
+  initial: UserState;
+  /** Initial context. */
   context: Context;
   /**
    * Per-state definitions. States with no definition silently drop all messages.

package/dist/dev/core/actors/create-machine-actor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-machine-actor.d.ts","names":[],"sources":["../../../../src/core/actors/create-machine-actor.ts"],"mappings":";;;;;;AAYA;UAAiB,UAAA;EACf,QAAA,8BAAsC,IAAA,EAAM,QAAA,CAAS,KAAA,EAAO,GAAA,IAAO,OAAA,CAAQ,KAAA;EAC3E,QAAA;EACA,OAAA;EACA,WAAA,CAAY,QAAA;AAAA;;;;;;KAYF,cAAA,gFAGmB,UAAA;EAE7B,UAAA,GAAa,EAAA,EAAI,SAAA,WApBoC;EAsBrD,OAAA,EAAS,OAAA;EAtB6B;;;;;;EA6BtC,UAAA,QAAkB,OAAA;EAClB,UAAA,GAAa,IAAA,EAAM,OAAA;AAAA,KAChB,aAAA;EAAwC,MAAA,EAAQ,CAAA;AAAA;;;;KAKzC,oBAAA;EAGQ,IAAA;AAAA,gCACW,UAAA;EAT1B;;;;;;EAiBH,SAAA,GAAY,SAAA,EA9BiB;EAgC7B,EAAA,WACQ,OAAA,IAAW,CAAA,aACf,OAAA,EAAS,OAAA,CAAQ,OAAA;IAAW,IAAA,EAAM,CAAA;EAAA,IAClC,GAAA,EAAK,cAAA,CAAe,SAAA,EAAW,OAAA,EAAS,aAAA;AAAA;;;;;;;KAWlC,eAAA;EAGQ,IAAA;AAAA,gCACW,UAAA;EArCuB;AAKtD;;;;;;EAyCE,MAAA,GAAS,aAAA,EAzBY;EA2BrB,OAAA,EAAS,SAAA,EA3BI;EA6Bb,OAAA,EAAS,OAAA;EA5B0B;;;;EAiCnC,MAAA,EAAQ,OAAA,CAAQ,MAAA,CAAO,SAAA,EAAW,oBAAA,CAAqB,SAAA,EAAW,OAAA,EAAS,OAAA,EAAS,aAAA;AAAA;;UAQrE,YAAA;EAA6E,IAAA;AAAA,WACpF,WAAA,CAAY,KAAA,EAAO,OAAA;EAC3B,IAAA,CAAK,OAAA,EAAS,OAAA;AAAA;;;;;;;;;;;;;;;;;;AAhChB;;;;;;;;;;;;;;;;;;;;;;iBA8EgB,kBAAA;EAGI,IAAA;AAAA,gCACW,UAAA,0BAAA,CAE7B,GAAA,EAAK,eAAA,CAAgB,SAAA,EAAW,OAAA,EAAS,OAAA,EAAS,aAAA,IACjD,YAAA,CAAa,SAAA,gBAAyB,OAAA,EAAS,OAAA"}
+{"version":3,"file":"create-machine-actor.d.ts","names":[],"sources":["../../../../src/core/actors/create-machine-actor.ts"],"mappings":";;;;;;UAYiB;EACf,SAAS,cAAc,eAAe,MAAM,SAAS,OAAO,OAAO,QAAQ;EAC3E;EACA;EACA,YAAY;;;;;;;KAYF,eACV,0BACA,wBACA,6BAA6B;EAE7B,aAAa,IAAI;;EAEjB,SAAS;;;;;;;EAOT,kBAAkB;EAClB,aAAa,MAAM;KAChB,mCAAkC;EAAM,QAAQ;;;;;KAKzC,qBACV,0BACA,wBACA;EAAkB;GAClB,6BAA6B;;;;;;;EAQ7B,YAAY;;EAEZ,QACG,KAAK,WAAW,cACf,SAAS,QAAQ;IAAW,MAAM;MAClC,KAAK,eAAe,WAAW,SAAS;;;;;;;;KAWlC,gBACV,0BACA,wBACA;EAAkB;GAClB,6BAA6B;;;;;;;;EAS7B,SAAS;;EAET,SAAS;;EAET,SAAS;;;;;EAKT,QAAQ,QAAQ,OAAO,WAAW,qBAAqB,WAAW,SAAS,SAAS;;;UAQrE,aAAa,sBAAsB,wBAAwB;EAAkB;WACpF,YAAY,OAAO;EAC3B,KAAK,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CA,mBACd,0BACA,wBACA;EAAkB;GAClB,6BAA6B,qCAE7B,KAAK,gBAAgB,WAAW,SAAS,SAAS,iBACjD,aAAa,yBAAyB,SAAS"}