mattebox 0.1.0

package/dist/es2015/kernel/reducer.js

@@ -0,0 +1,1051 @@
+import { normalizeMimeType } from "./mime.js";
+import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+import { bufferedEndFrom, schedule } from "./scheduler.js";
+import { canSwitchTo, codecFamily, createArbiter, planPinApply } from "./rendition-select.js";
+import { sbIdFor } from "./sinks/mse-sink.js";
+import _objectWithoutProperties from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectWithoutProperties.js";
+//#region src/kernel/reducer.ts
+const _excluded = ["repeat"];
+const _excluded2 = ["initFor"];
+/**
+* The default tuning. Every value is overridable through the `config`
+* parameters of `initialState` and `createReducer`; these are starting
+* points, not policy.
+*/
+const DEFAULT_KERNEL_CONFIG = {
+	ewmaAlpha: .2,
+	ewmaFastAlpha: .6,
+	ewmaMinSampleBytes: 1e4,
+	bufferErrorLimit: 3,
+	repeatFetchLimit: 5,
+	backBufferSeconds: 30,
+	bufferGoalSeconds: 30,
+	manifestTimeoutMs: 1e4,
+	traceCapacity: 500,
+	baseRetryDelayMs: 400,
+	mediaTimeNormalized: false
+};
+function resolveConfig(config) {
+	return _objectSpread2(_objectSpread2({}, DEFAULT_KERNEL_CONFIG), config);
+}
+function initialState(config) {
+	const cfg = resolveConfig(config);
+	return {
+		lifecycle: { phase: "idle" },
+		presentation: null,
+		timeline: {
+			periodOffsets: /* @__PURE__ */ new Map(),
+			discontinuitySeq: 0
+		},
+		buffers: /* @__PURE__ */ new Map(),
+		bufferErrors: /* @__PURE__ */ new Map(),
+		cues: /* @__PURE__ */ new Map(),
+		live: null,
+		scheduling: {
+			inflight: /* @__PURE__ */ new Map(),
+			bufferGoal: cfg.bufferGoalSeconds,
+			tokenSeq: 0
+		},
+		tracks: {
+			active: /* @__PURE__ */ new Map(),
+			available: []
+		},
+		quality: {
+			version: 0,
+			constraints: /* @__PURE__ */ new Map(),
+			pinned: null,
+			active: null,
+			appendLog: []
+		},
+		stats: {
+			throughputEwma: 0,
+			throughputFastEwma: 0
+		},
+		playback: {
+			currentTime: 0,
+			buffered: [],
+			seeking: false
+		}
+	};
+}
+/** Gap width treated as continuous when measuring buffered spans. */
+const GAP_TOLERANCE = .25;
+/** The codecs part of an MSE type string ('video/mp4; codecs="avc1.42c00d"' -> 'avc1.42c00d'). */
+function bufferCodecString(type) {
+	var _match$;
+	const match = /codecs="?([^"]+)"?/.exec(type);
+	return (_match$ = match === null || match === void 0 ? void 0 : match[1]) !== null && _match$ !== void 0 ? _match$ : null;
+}
+function reject(state, command, reason) {
+	return [state, [{
+		kind: "emit",
+		event: "command:rejected",
+		payload: {
+			command,
+			reason
+		}
+	}]];
+}
+/**
+* A manifest that will never yield a presentation. Every path lands here:
+* an adapter's parse failure (MANIFEST_FAILED), a fetch failure on the
+* manifest request, a `mimeType` no adapter accepts, and bytes no adapter
+* claims. One phase transition and one error shape, so an integrator
+* handles a single code per cause.
+*/
+function failManifest(state, error, extra = {}) {
+	const phase = error.fatal ? "error" : state.lifecycle.phase;
+	return [_objectSpread2(_objectSpread2({}, state), {}, { lifecycle: { phase } }), [{
+		kind: "emit",
+		event: "error",
+		payload: _objectSpread2({
+			category: error.category,
+			code: error.code,
+			fatal: error.fatal,
+			recoverable: error.recoverable
+		}, extra)
+	}]];
+}
+/** The in-flight manifest request a SEGMENT_LOADED fact answers, or null. At most one is ever in flight. */
+function manifestRequestFor(state, msg) {
+	if (msg.trackId !== "manifest") return null;
+	for (const request of state.scheduling.inflight.values()) if (request.trackId === "manifest" && (msg.token === void 0 || msg.token === request.token)) return request;
+	return null;
+}
+function bumped(quality) {
+	return _objectSpread2(_objectSpread2({}, quality), {}, { version: quality.version + 1 });
+}
+/**
+* Forgets the last fetch decision. A pin or a seek legitimately makes the
+* scheduler repeat itself; only unprompted repetition means a stuck loop.
+*/
+function clearRepeat(scheduling) {
+	if (scheduling.repeat === void 0) return scheduling;
+	const { repeat: _repeat } = scheduling;
+	return _objectWithoutProperties(scheduling, _excluded);
+}
+function ewma(previous, sample, alpha) {
+	return previous === 0 ? sample : alpha * sample + (1 - alpha) * previous;
+}
+/** Companion groups present, as `contentType:groupId`, for the coupling filter. */
+function availableGroups(state) {
+	var _state$presentation$p, _state$presentation;
+	const groups = /* @__PURE__ */ new Set();
+	for (const period of (_state$presentation$p = (_state$presentation = state.presentation) === null || _state$presentation === void 0 ? void 0 : _state$presentation.periods) !== null && _state$presentation$p !== void 0 ? _state$presentation$p : []) for (const track of period.tracks) {
+		if (track.contentType !== "audio" && track.contentType !== "text") continue;
+		const colon = track.id.indexOf(":");
+		const group = colon === -1 ? track.id : track.id.slice(0, colon);
+		groups.add(`${track.contentType}:${group}`);
+	}
+	return groups;
+}
+/** Merges one span into a sorted coverage list, coalescing overlaps. */
+function mergeCoverage(coverage, added) {
+	const merged = [];
+	let pending = added;
+	for (const range of coverage) if (range.end < pending.start || range.start > pending.end) merged.push(range);
+	else pending = {
+		start: Math.min(range.start, pending.start),
+		end: Math.max(range.end, pending.end)
+	};
+	merged.push(pending);
+	return merged.sort((a, b) => a.start - b.start);
+}
+function findTrack(presentation, trackId) {
+	if (presentation === null) return null;
+	for (const period of presentation.periods) for (const track of period.tracks) if (track.id === trackId) return track;
+	return null;
+}
+function findTrackSite(presentation, trackId) {
+	for (const period of presentation.periods) for (const track of period.tracks) if (track.id === trackId) return {
+		track,
+		period
+	};
+	return null;
+}
+function findRendition(presentation, renditionId) {
+	if (presentation === null) return null;
+	for (const period of presentation.periods) for (const track of period.tracks) for (const rendition of track.renditions) if (rendition.id === renditionId) return {
+		rendition,
+		track,
+		period
+	};
+	return null;
+}
+/**
+* Whether a completed request feeds the throughput estimate: only media of
+* the lead track (video where there is one, else audio). An audio segment
+* beside video, a text cue, or a playlist is a small transfer whose time
+* is latency, not bandwidth.
+*/
+function samplesThroughput(state, request) {
+	var _state$tracks$active$;
+	const lead = (_state$tracks$active$ = state.tracks.active.get("video")) !== null && _state$tracks$active$ !== void 0 ? _state$tracks$active$ : state.tracks.active.get("audio");
+	return lead === void 0 ? request.renditionId === void 0 : request.trackId === lead;
+}
+/** Abort effects for every matching in-flight request, plus the state with them removed. */
+function abortInflight(state, trackId) {
+	const effects = [];
+	const inflight = new Map(state.scheduling.inflight);
+	for (const [token, request] of state.scheduling.inflight) {
+		if (trackId !== void 0 && request.trackId !== trackId) continue;
+		effects.push({
+			kind: "abort",
+			token
+		});
+		inflight.delete(token);
+	}
+	if (effects.length === 0) return [state, []];
+	return [_objectSpread2(_objectSpread2({}, state), {}, { scheduling: _objectSpread2(_objectSpread2({}, state.scheduling), {}, { inflight }) }), effects];
+}
+function reduceCommand(state, msg, cfg, hooks) {
+	switch (msg.type) {
+		case "ATTACH":
+			if (state.lifecycle.phase !== "idle") return reject(state, msg.type, "already attached");
+			return [_objectSpread2(_objectSpread2({}, state), {}, { lifecycle: { phase: "attaching" } }), []];
+		case "DETACH": {
+			const [, aborts] = abortInflight(state);
+			return [initialState(cfg), aborts];
+		}
+		case "LOAD": {
+			if (state.lifecycle.phase === "idle") return reject(state, msg.type, "not attached");
+			if (state.lifecycle.phase !== "attaching") return reject(state, msg.type, "already loaded");
+			if (msg.mimeType !== void 0 && hooks.manifestTypes !== void 0) {
+				const mimeType = normalizeMimeType(msg.mimeType);
+				if (!hooks.manifestTypes.has(mimeType)) return failManifest(state, {
+					category: "manifest",
+					code: "MANIFEST_UNSUPPORTED",
+					fatal: true,
+					recoverable: false
+				}, { mimeType });
+			}
+			const tokenSeq = state.scheduling.tokenSeq + 1;
+			const token = `t${tokenSeq}:manifest`;
+			const inflight = new Map(state.scheduling.inflight);
+			inflight.set(token, {
+				token,
+				trackId: "manifest",
+				seq: 0,
+				url: msg.url
+			});
+			return [_objectSpread2(_objectSpread2({}, state), {}, {
+				lifecycle: { phase: "loading" },
+				scheduling: _objectSpread2(_objectSpread2({}, state.scheduling), {}, {
+					inflight,
+					tokenSeq
+				})
+			}), [{
+				kind: "fetch",
+				token,
+				url: msg.url,
+				timeout: cfg.manifestTimeoutMs
+			}]];
+		}
+		case "UNLOAD": {
+			const [, aborts] = abortInflight(state);
+			const fresh = initialState(cfg);
+			const phase = state.lifecycle.phase === "idle" ? "idle" : "attaching";
+			const clears = [...state.cues.keys()].map((trackId) => ({
+				kind: "clearCues",
+				trackId,
+				start: 0,
+				end: Number.POSITIVE_INFINITY
+			}));
+			return [_objectSpread2(_objectSpread2({}, fresh), {}, {
+				lifecycle: { phase },
+				scheduling: _objectSpread2(_objectSpread2({}, fresh.scheduling), {}, { tokenSeq: state.scheduling.tokenSeq })
+			}), [...aborts, ...clears]];
+		}
+		case "SEEK": {
+			if (state.presentation === null) return reject(state, msg.type, "no source");
+			const [next, aborts] = abortInflight(state);
+			const to = state.live === null ? msg.to : Math.min(Math.max(msg.to, state.live.span.start), state.live.edge);
+			return [_objectSpread2(_objectSpread2({}, next), {}, { scheduling: clearRepeat(next.scheduling) }), [...aborts, {
+				kind: "seekElement",
+				to
+			}]];
+		}
+		case "SEEK_TO_LIVE_EDGE": {
+			if (state.presentation === null || !state.presentation.isLive) return reject(state, msg.type, "not live");
+			if (state.live === null) return reject(state, msg.type, "no live support loaded");
+			const [next, aborts] = abortInflight(state);
+			return [_objectSpread2(_objectSpread2({}, next), {}, { scheduling: clearRepeat(next.scheduling) }), [...aborts, {
+				kind: "seekElement",
+				to: state.live.edge
+			}]];
+		}
+		case "SELECT_TRACK": {
+			const track = findTrack(state.presentation, msg.trackId);
+			if (track === null) return reject(state, msg.type, `unknown track: ${msg.trackId}`);
+			const previous = state.tracks.active.get(track.contentType);
+			const active = new Map(state.tracks.active);
+			active.set(track.contentType, track.id);
+			const effects = [];
+			let buffers = state.buffers;
+			let inflight = state.scheduling.inflight;
+			if (previous !== void 0 && previous !== track.id && (track.contentType === "audio" || track.contentType === "video")) {
+				const sbId = sbIdFor(track.contentType);
+				if (state.buffers.has(sbId)) {
+					effects.push({
+						kind: "remove",
+						sbId,
+						start: 0,
+						end: Number.POSITIVE_INFINITY
+					});
+					const buffer = state.buffers.get(sbId);
+					if (buffer !== void 0) {
+						const next = new Map(state.buffers);
+						const { initFor: _initFor } = buffer, rest = _objectWithoutProperties(buffer, _excluded2);
+						next.set(sbId, rest);
+						buffers = next;
+					}
+					const pruned = new Map(state.scheduling.inflight);
+					for (const [token, request] of state.scheduling.inflight) if (request.trackId === previous) {
+						effects.push({
+							kind: "abort",
+							token
+						});
+						pruned.delete(token);
+					}
+					inflight = pruned;
+				}
+			}
+			if (previous !== track.id) effects.push({
+				kind: "emit",
+				event: "tracks:selected",
+				payload: {
+					contentType: track.contentType,
+					trackId: track.id
+				}
+			});
+			return [_objectSpread2(_objectSpread2({}, state), {}, {
+				tracks: _objectSpread2(_objectSpread2({}, state.tracks), {}, { active }),
+				buffers,
+				scheduling: clearRepeat(_objectSpread2(_objectSpread2({}, state.scheduling), {}, { inflight })),
+				quality: bumped(state.quality)
+			}), effects];
+		}
+		case "DESELECT_TRACK": {
+			if (msg.contentType !== "text" && msg.contentType !== "metadata") return reject(state, msg.type, "video and audio always keep a selection");
+			const trackId = state.tracks.active.get(msg.contentType);
+			if (trackId === void 0) return [state, []];
+			const active = new Map(state.tracks.active);
+			active.delete(msg.contentType);
+			const cues = new Map(state.cues);
+			cues.delete(trackId);
+			const [aborted, abortEffects] = abortInflight(state, trackId);
+			return [_objectSpread2(_objectSpread2({}, aborted), {}, {
+				tracks: _objectSpread2(_objectSpread2({}, state.tracks), {}, { active }),
+				cues,
+				quality: bumped(state.quality)
+			}), [
+				...abortEffects,
+				{
+					kind: "clearCues",
+					trackId,
+					start: 0,
+					end: Number.POSITIVE_INFINITY
+				},
+				{
+					kind: "emit",
+					event: "tracks:selected",
+					payload: {
+						contentType: msg.contentType,
+						trackId: null
+					}
+				}
+			]];
+		}
+		case "PIN_RENDITION": {
+			var _state$buffers$get$ra, _state$buffers$get;
+			const site = findRendition(state.presentation, msg.renditionId);
+			if (site === null) return reject(state, msg.type, `unknown rendition: ${msg.renditionId}`);
+			const pinnedState = _objectSpread2(_objectSpread2({}, state), {}, { quality: bumped(_objectSpread2(_objectSpread2({}, state.quality), {}, {
+				pinned: site.rendition.id,
+				active: site.rendition.id
+			})) });
+			if (site.track.contentType !== "video" && site.track.contentType !== "audio") return [pinnedState, []];
+			const sbId = sbIdFor(site.track.contentType);
+			const inflightTokens = [];
+			for (const request of state.scheduling.inflight.values()) if (request.trackId === site.track.id) inflightTokens.push(request.token);
+			const plan = planPinApply({
+				strategy: msg.apply,
+				currentTime: state.playback.currentTime,
+				ranges: (_state$buffers$get$ra = (_state$buffers$get = state.buffers.get(sbId)) === null || _state$buffers$get === void 0 ? void 0 : _state$buffers$get.ranges) !== null && _state$buffers$get$ra !== void 0 ? _state$buffers$get$ra : [],
+				sbId,
+				trackId: site.track.id,
+				inflightTokens,
+				period: site.period,
+				rendition: site.rendition,
+				tokenSeq: state.scheduling.tokenSeq
+			});
+			const inflight = new Map(state.scheduling.inflight);
+			for (const token of inflightTokens) inflight.delete(token);
+			for (const request of plan.requests) inflight.set(request.token, request);
+			return [_objectSpread2(_objectSpread2({}, pinnedState), {}, { scheduling: clearRepeat(_objectSpread2(_objectSpread2({}, state.scheduling), {}, {
+				inflight,
+				tokenSeq: plan.tokenSeq
+			})) }), plan.effects];
+		}
+		case "RELEASE_PIN": return [_objectSpread2(_objectSpread2({}, state), {}, { quality: bumped(_objectSpread2(_objectSpread2({}, state.quality), {}, { pinned: null })) }), []];
+		case "CONSTRAIN": {
+			const constraints = new Map(state.quality.constraints);
+			constraints.set(msg.source, msg.constraint);
+			return [_objectSpread2(_objectSpread2({}, state), {}, {
+				quality: bumped(_objectSpread2(_objectSpread2({}, state.quality), {}, { constraints })),
+				scheduling: clearRepeat(state.scheduling)
+			}), []];
+		}
+		case "RELEASE_CONSTRAINT": {
+			if (!state.quality.constraints.has(msg.source)) return [state, []];
+			const constraints = new Map(state.quality.constraints);
+			constraints.delete(msg.source);
+			return [_objectSpread2(_objectSpread2({}, state), {}, {
+				quality: bumped(_objectSpread2(_objectSpread2({}, state.quality), {}, { constraints })),
+				scheduling: clearRepeat(state.scheduling)
+			}), []];
+		}
+		case "SET_BUFFER_GOAL":
+			if (!Number.isFinite(msg.seconds) || msg.seconds <= 0) return reject(state, msg.type, "invalid buffer goal");
+			return [_objectSpread2(_objectSpread2({}, state), {}, { scheduling: _objectSpread2(_objectSpread2({}, state.scheduling), {}, { bufferGoal: msg.seconds }) }), []];
+		case "ABORT_INFLIGHT": return abortInflight(state, msg.trackId);
+	}
+}
+function reduceFact(state, msg, cfg, hooks) {
+	switch (msg.type) {
+		case "ELEMENT_ATTACHED":
+		case "MEDIASOURCE_OPEN":
+		case "MEDIASOURCE_CLOSED": return [state, []];
+		case "MANIFEST_LOADED": {
+			const available = [];
+			for (const period of msg.presentation.periods) for (const track of period.tracks) available.push(track.id);
+			const inflight = new Map(state.scheduling.inflight);
+			for (const [token, request] of inflight) if (request.trackId === "manifest") inflight.delete(token);
+			const phase = state.lifecycle.phase === "loading" ? "ready" : state.lifecycle.phase;
+			const active = new Map(state.tracks.active);
+			for (const period of msg.presentation.periods) for (const track of period.tracks) if ((track.contentType === "video" || track.contentType === "audio") && !active.has(track.contentType)) active.set(track.contentType, track.id);
+			const loaded = _objectSpread2(_objectSpread2({}, state), {}, {
+				lifecycle: { phase },
+				presentation: msg.presentation,
+				scheduling: _objectSpread2(_objectSpread2({}, state.scheduling), {}, { inflight }),
+				tracks: {
+					active,
+					available
+				},
+				quality: bumped(state.quality)
+			});
+			const manifestEffects = available.length === state.tracks.available.length && available.every((id, index) => id === state.tracks.available[index]) ? [] : [{
+				kind: "emit",
+				event: "tracks:changed",
+				payload: { available }
+			}];
+			const schemes = msg.presentation.periods.flatMap((period) => period.tracks.flatMap((track) => {
+				var _track$protection$sch, _track$protection;
+				return (_track$protection$sch = (_track$protection = track.protection) === null || _track$protection === void 0 ? void 0 : _track$protection.schemes) !== null && _track$protection$sch !== void 0 ? _track$protection$sch : [];
+			}));
+			if (schemes.length > 0) manifestEffects.push({
+				kind: "emit",
+				event: "presentation:protection",
+				payload: schemes
+			});
+			if (!msg.presentation.isLive && msg.presentation.duration !== void 0) manifestEffects.push({
+				kind: "setDuration",
+				seconds: msg.presentation.duration
+			});
+			return [loaded, manifestEffects];
+		}
+		case "MANIFEST_FAILED": return failManifest(state, msg.error);
+		case "PLAYLIST_REFRESHED": return [state, []];
+		case "SEGMENT_LOADED": {
+			let matched = null;
+			if (msg.token !== void 0) {
+				var _state$scheduling$inf;
+				matched = (_state$scheduling$inf = state.scheduling.inflight.get(msg.token)) !== null && _state$scheduling$inf !== void 0 ? _state$scheduling$inf : null;
+			} else for (const request of state.scheduling.inflight.values()) if (request.trackId === msg.trackId && request.seq === msg.seq) {
+				matched = request;
+				break;
+			}
+			if (matched === null) return [state, []];
+			const inflight = new Map(state.scheduling.inflight);
+			inflight.delete(matched.token);
+			const sampleBps = msg.rtt > 0 && msg.size >= cfg.ewmaMinSampleBytes && samplesThroughput(state, matched) ? msg.size * 8e3 / msg.rtt : null;
+			const stats = sampleBps === null ? state.stats : {
+				throughputEwma: ewma(state.stats.throughputEwma, sampleBps, cfg.ewmaAlpha),
+				throughputFastEwma: ewma(state.stats.throughputFastEwma, sampleBps, cfg.ewmaFastAlpha)
+			};
+			let buffers = state.buffers;
+			let timeline = state.timeline;
+			let quality = state.quality;
+			let cues = state.cues;
+			const effects = [];
+			const cueTrack = matched.sbId === void 0 ? findTrack(state.presentation, matched.trackId) : null;
+			if (cueTrack !== null && (cueTrack.contentType === "text" || cueTrack.contentType === "metadata") && matched.segmentStart !== void 0) {
+				var _matched$segmentDurat, _cues$get, _matched$renditionId, _matched$segmentDurat2;
+				const span = {
+					start: matched.segmentStart,
+					end: matched.segmentStart + ((_matched$segmentDurat = matched.segmentDuration) !== null && _matched$segmentDurat !== void 0 ? _matched$segmentDurat : 0)
+				};
+				const next = new Map(cues);
+				next.set(matched.trackId, mergeCoverage((_cues$get = cues.get(matched.trackId)) !== null && _cues$get !== void 0 ? _cues$get : [], span));
+				cues = next;
+				effects.push({
+					kind: "deliver",
+					trackId: matched.trackId,
+					contentType: cueTrack.contentType,
+					data: msg.bytes,
+					meta: {
+						trackId: matched.trackId,
+						renditionId: (_matched$renditionId = matched.renditionId) !== null && _matched$renditionId !== void 0 ? _matched$renditionId : "",
+						contentType: cueTrack.contentType,
+						seq: matched.seq,
+						start: matched.segmentStart,
+						duration: (_matched$segmentDurat2 = matched.segmentDuration) !== null && _matched$segmentDurat2 !== void 0 ? _matched$segmentDurat2 : 0,
+						isInit: matched.seq < 0
+					}
+				});
+			}
+			if (matched.sbId !== void 0) {
+				var _buffers$get;
+				if (matched.seq < 0 && matched.renditionId !== void 0) {
+					const buffer = state.buffers.get(matched.sbId);
+					if (buffer !== void 0) {
+						var _targetSite$rendition;
+						const targetSite = findRendition(state.presentation, matched.renditionId);
+						const targetCodecs = targetSite === null ? buffer.codecs : targetSite.rendition.codecs === null ? targetSite.rendition.mimeType : `${targetSite.rendition.mimeType}; codecs="${targetSite.rendition.codecs}"`;
+						const familyChanged = codecFamily((_targetSite$rendition = targetSite === null || targetSite === void 0 ? void 0 : targetSite.rendition.codecs) !== null && _targetSite$rendition !== void 0 ? _targetSite$rendition : null) !== codecFamily(bufferCodecString(buffer.codecs));
+						const nextBuffers = new Map(state.buffers);
+						if (targetCodecs !== buffer.codecs && familyChanged) effects.push({
+							kind: "changeType",
+							sbId: matched.sbId,
+							codecs: targetCodecs
+						});
+						nextBuffers.set(matched.sbId, _objectSpread2(_objectSpread2({}, buffer), {}, {
+							initFor: matched.renditionId,
+							codecs: targetCodecs
+						}));
+						buffers = nextBuffers;
+					}
+				}
+				const initFor = (_buffers$get = buffers.get(matched.sbId)) === null || _buffers$get === void 0 ? void 0 : _buffers$get.initFor;
+				if (matched.seq >= 0 && matched.renditionId !== void 0 && initFor !== void 0 && initFor !== matched.renditionId) return [_objectSpread2(_objectSpread2({}, state), {}, {
+					scheduling: _objectSpread2(_objectSpread2({}, state.scheduling), {}, { inflight }),
+					stats,
+					buffers,
+					cues
+				}), [...effects, {
+					kind: "emit",
+					event: "quality:stale-segment",
+					payload: {
+						renditionId: matched.renditionId,
+						seq: matched.seq,
+						initFor
+					}
+				}]];
+				if (matched.timestampOffset !== void 0 && state.timeline.periodOffsets.get(matched.sbId) !== matched.timestampOffset) {
+					effects.push({
+						kind: "setTimestampOffset",
+						sbId: matched.sbId,
+						offset: matched.timestampOffset
+					});
+					const periodOffsets = new Map(state.timeline.periodOffsets);
+					periodOffsets.set(matched.sbId, matched.timestampOffset);
+					timeline = _objectSpread2(_objectSpread2({}, state.timeline), {}, { periodOffsets });
+				}
+				effects.push(_objectSpread2(_objectSpread2(_objectSpread2({
+					kind: "append",
+					sbId: matched.sbId,
+					data: msg.bytes
+				}, matched.segmentStart !== void 0 ? { start: matched.segmentStart } : {}), matched.renditionId !== void 0 ? { renditionId: matched.renditionId } : {}), {}, { seq: matched.seq }));
+				const buffer = buffers.get(matched.sbId);
+				if (buffer !== void 0) {
+					const nextBuffers = new Map(buffers);
+					nextBuffers.set(matched.sbId, _objectSpread2(_objectSpread2({}, buffer), {}, { pendingAppends: buffer.pendingAppends + 1 }));
+					buffers = nextBuffers;
+				}
+				if (matched.sbId === sbIdFor("video") && matched.renditionId !== void 0 && matched.segmentStart !== void 0) {
+					var _matched$segmentDurat3;
+					const watermark = state.playback.currentTime - cfg.backBufferSeconds;
+					const appendLog = [...state.quality.appendLog.filter(([range]) => range.end > watermark), [{
+						start: matched.segmentStart,
+						end: matched.segmentStart + ((_matched$segmentDurat3 = matched.segmentDuration) !== null && _matched$segmentDurat3 !== void 0 ? _matched$segmentDurat3 : 0)
+					}, matched.renditionId]];
+					quality = _objectSpread2(_objectSpread2({}, quality), {}, { appendLog });
+				}
+			}
+			return [_objectSpread2(_objectSpread2({}, state), {}, {
+				buffers,
+				timeline,
+				quality,
+				cues,
+				scheduling: _objectSpread2(_objectSpread2({}, state.scheduling), {}, { inflight }),
+				stats
+			}), effects];
+		}
+		case "SEGMENT_FAILED": {
+			var _msg$status2;
+			const inflight = new Map(state.scheduling.inflight);
+			for (const [token, request] of inflight) if (request.trackId === msg.trackId && request.seq === msg.seq) inflight.delete(token);
+			if (msg.trackId === "manifest") {
+				var _msg$error$context, _msg$status;
+				const contentType = (_msg$error$context = msg.error.context) === null || _msg$error$context === void 0 ? void 0 : _msg$error$context.contentType;
+				return failManifest(_objectSpread2(_objectSpread2({}, state), {}, { scheduling: _objectSpread2(_objectSpread2({}, state.scheduling), {}, { inflight }) }), _objectSpread2(_objectSpread2({}, msg.error), {}, {
+					fatal: true,
+					recoverable: false
+				}), _objectSpread2({ status: (_msg$status = msg.status) !== null && _msg$status !== void 0 ? _msg$status : null }, typeof contentType === "string" ? { contentType } : {}));
+			}
+			const failedTrack = findTrack(state.presentation, msg.trackId);
+			const isCueTrack = failedTrack !== null && (failedTrack.contentType === "text" || failedTrack.contentType === "metadata");
+			let cues = state.cues;
+			if (isCueTrack) {
+				const request = [...state.scheduling.inflight.values()].find((r) => r.trackId === msg.trackId && r.seq === msg.seq);
+				if ((request === null || request === void 0 ? void 0 : request.segmentStart) !== void 0) {
+					var _cues$get2, _request$segmentDurat;
+					const next = new Map(cues);
+					next.set(msg.trackId, mergeCoverage((_cues$get2 = cues.get(msg.trackId)) !== null && _cues$get2 !== void 0 ? _cues$get2 : [], {
+						start: request.segmentStart,
+						end: request.segmentStart + ((_request$segmentDurat = request.segmentDuration) !== null && _request$segmentDurat !== void 0 ? _request$segmentDurat : 0)
+					}));
+					cues = next;
+				}
+			}
+			const failEffects = [{
+				kind: "emit",
+				event: "error",
+				payload: {
+					category: msg.error.category,
+					code: msg.error.code,
+					fatal: isCueTrack ? false : msg.error.fatal,
+					recoverable: msg.error.recoverable,
+					trackId: msg.trackId,
+					seq: msg.seq,
+					status: (_msg$status2 = msg.status) !== null && _msg$status2 !== void 0 ? _msg$status2 : null
+				}
+			}];
+			if (!isCueTrack) failEffects.push({
+				kind: "schedule",
+				token: "kernel:retry",
+				delayMs: cfg.baseRetryDelayMs,
+				then: {
+					type: "TICK",
+					token: "kernel:retry"
+				}
+			});
+			return [_objectSpread2(_objectSpread2({}, state), {}, {
+				cues,
+				scheduling: _objectSpread2(_objectSpread2({}, state.scheduling), {}, { inflight })
+			}), failEffects];
+		}
+		case "SOURCEBUFFER_CREATED": {
+			const buffers = new Map(state.buffers);
+			buffers.set(msg.sbId, {
+				codecs: msg.codecs,
+				ranges: [],
+				pendingAppends: 0
+			});
+			return [_objectSpread2(_objectSpread2({}, state), {}, { buffers }), []];
+		}
+		case "SOURCEBUFFER_UPDATEEND": {
+			const buffer = state.buffers.get(msg.sbId);
+			if (buffer === void 0) return [state, []];
+			const buffers = new Map(state.buffers);
+			buffers.set(msg.sbId, _objectSpread2(_objectSpread2(_objectSpread2({}, buffer), msg.ranges !== void 0 ? { ranges: msg.ranges } : {}), {}, { pendingAppends: Math.max(0, buffer.pendingAppends - 1) }));
+			let bufferErrors = state.bufferErrors;
+			if (bufferErrors.has(msg.sbId)) {
+				bufferErrors = new Map(bufferErrors);
+				bufferErrors.delete(msg.sbId);
+			}
+			return driveScheduling(_objectSpread2(_objectSpread2({}, state), {}, {
+				buffers,
+				bufferErrors
+			}), hooks, cfg);
+		}
+		case "SOURCEBUFFER_ERROR": {
+			var _state$bufferErrors$g;
+			const count = ((_state$bufferErrors$g = state.bufferErrors.get(msg.sbId)) !== null && _state$bufferErrors$g !== void 0 ? _state$bufferErrors$g : 0) + 1;
+			const bufferErrors = new Map(state.bufferErrors);
+			bufferErrors.set(msg.sbId, count);
+			const fatal = msg.error.fatal || count >= cfg.bufferErrorLimit;
+			const phase = fatal ? "error" : state.lifecycle.phase;
+			const effects = [{
+				kind: "emit",
+				event: "error",
+				payload: _objectSpread2({
+					category: msg.error.category,
+					code: msg.error.code,
+					fatal,
+					recoverable: msg.error.recoverable,
+					sbId: msg.sbId
+				}, fatal && !msg.error.fatal ? { consecutiveFailures: count } : {})
+			}];
+			let inflight = state.scheduling.inflight;
+			if (fatal) {
+				const pruned = new Map(state.scheduling.inflight);
+				for (const [token, request] of state.scheduling.inflight) if (request.sbId === msg.sbId) {
+					effects.push({
+						kind: "abort",
+						token
+					});
+					pruned.delete(token);
+				}
+				inflight = pruned;
+			}
+			return [_objectSpread2(_objectSpread2({}, state), {}, {
+				bufferErrors,
+				lifecycle: { phase },
+				scheduling: _objectSpread2(_objectSpread2({}, state.scheduling), {}, { inflight })
+			}), effects];
+		}
+		case "QUOTA_EXCEEDED": {
+			const boundary = Math.max(0, state.playback.currentTime - cfg.backBufferSeconds);
+			if (boundary <= 0) return [state, [{
+				kind: "emit",
+				event: "quota:exhausted",
+				payload: { sbId: msg.sbId }
+			}]];
+			return [state, [{
+				kind: "remove",
+				sbId: msg.sbId,
+				start: 0,
+				end: boundary
+			}]];
+		}
+		case "TIME_UPDATE": return driveScheduling(_objectSpread2(_objectSpread2({}, state), {}, { playback: _objectSpread2(_objectSpread2({}, state.playback), {}, {
+			currentTime: msg.currentTime,
+			buffered: msg.buffered
+		}) }), hooks, cfg);
+		case "SEEKING": {
+			const phase = state.lifecycle.phase === "ended" ? "ready" : state.lifecycle.phase;
+			return [_objectSpread2(_objectSpread2({}, state), {}, {
+				lifecycle: { phase },
+				playback: _objectSpread2(_objectSpread2({}, state.playback), {}, {
+					currentTime: msg.to,
+					seeking: true
+				})
+			}), []];
+		}
+		case "SEEKED": return [_objectSpread2(_objectSpread2({}, state), {}, { playback: _objectSpread2(_objectSpread2({}, state.playback), {}, {
+			currentTime: msg.at,
+			seeking: false
+		}) }), []];
+		case "STALLED": return [state, [{
+			kind: "emit",
+			event: "playback:stalled",
+			payload: { at: msg.at }
+		}]];
+		case "ENCRYPTED": return [state, [{
+			kind: "emit",
+			event: "drm:encrypted",
+			payload: {
+				initDataType: msg.initDataType,
+				initData: msg.initData
+			}
+		}]];
+		case "LIVE_WINDOW_CHANGED": {
+			var _state$presentation2;
+			const firstWindow = state.live === null;
+			const withLive = _objectSpread2(_objectSpread2({}, state), {}, { live: {
+				span: {
+					start: msg.start,
+					end: msg.end
+				},
+				edge: msg.edge
+			} });
+			const spanEffects = [];
+			if (firstWindow && ((_state$presentation2 = state.presentation) === null || _state$presentation2 === void 0 ? void 0 : _state$presentation2.duration) === void 0) spanEffects.push({
+				kind: "setDuration",
+				seconds: Number.POSITIVE_INFINITY
+			});
+			spanEffects.push({
+				kind: "setLiveSeekableRange",
+				start: msg.start,
+				end: msg.end
+			});
+			if (firstWindow && msg.edge > state.playback.currentTime + 1) {
+				const [scheduled, effects] = driveScheduling(_objectSpread2(_objectSpread2({}, withLive), {}, { playback: _objectSpread2(_objectSpread2({}, withLive.playback), {}, { currentTime: msg.edge }) }), hooks, cfg);
+				return [scheduled, [
+					...spanEffects,
+					{
+						kind: "seekElement",
+						to: msg.edge
+					},
+					...effects
+				]];
+			}
+			const [scheduled, effects] = driveScheduling(withLive, hooks, cfg);
+			return [scheduled, [...spanEffects, ...effects]];
+		}
+		case "TICK": return [state, []];
+		case "ENDED":
+			if (state.lifecycle.phase !== "ready") return [state, []];
+			return [_objectSpread2(_objectSpread2({}, state), {}, { lifecycle: { phase: "ended" } }), [{
+				kind: "emit",
+				event: "playback:ended",
+				payload: { at: msg.at }
+			}]];
+		case "THROUGHPUT_SAMPLE": return [_objectSpread2(_objectSpread2({}, state), {}, { stats: {
+			throughputEwma: ewma(state.stats.throughputEwma, msg.bps, cfg.ewmaAlpha),
+			throughputFastEwma: ewma(state.stats.throughputFastEwma, msg.bps, cfg.ewmaFastAlpha)
+		} }), []];
+	}
+}
+/**
+* The buffer-goal loop, run on TIME_UPDATE. Pure: rendition choice comes
+* from arbitration over state, buffer knowledge from the ranges snapshots
+* the updateend facts carried into state. Live presentations wait for
+* the live stages to supply availability bounds; until then nothing is
+* scheduled.
+*/
+function driveScheduling(state, hooks, cfg) {
+	var _state$live$span, _state$live;
+	if (state.lifecycle.phase !== "ready" || state.presentation === null) return [state, []];
+	if (state.presentation.isLive && state.live === null) return [state, []];
+	const effects = [];
+	const tracks = [];
+	const initFetches = [];
+	let quality = state.quality;
+	for (const contentType of ["video", "audio"]) {
+		var _state$buffers$get$pe, _state$buffers$get2, _state$buffers$get$ra2, _state$buffers$get3, _hooks$abr, _hooks$switchPolicy, _state$buffers$get4, _state$buffers$get$ra3, _state$buffers$get5;
+		const trackId = state.tracks.active.get(contentType);
+		if (trackId === void 0) continue;
+		const found = findTrackSite(state.presentation, trackId);
+		if (found === null || found.track.renditions.length === 0) continue;
+		const sbId = sbIdFor(contentType);
+		if (((_state$buffers$get$pe = (_state$buffers$get2 = state.buffers.get(sbId)) === null || _state$buffers$get2 === void 0 ? void 0 : _state$buffers$get2.pendingAppends) !== null && _state$buffers$get$pe !== void 0 ? _state$buffers$get$pe : 0) > 0) continue;
+		const bufferAhead = bufferedEndFrom((_state$buffers$get$ra2 = (_state$buffers$get3 = state.buffers.get(sbId)) === null || _state$buffers$get3 === void 0 ? void 0 : _state$buffers$get3.ranges) !== null && _state$buffers$get$ra2 !== void 0 ? _state$buffers$get$ra2 : [], state.playback.currentTime, GAP_TOLERANCE) - state.playback.currentTime;
+		const memoKey = hooks.abr == null ? state.quality.version : `${state.quality.version}:${Math.round(state.stats.throughputEwma / 25e3)}:${Math.round(state.stats.throughputFastEwma / 25e3)}:${Math.round(bufferAhead)}:${state.quality.active}`;
+		const outcome = arbiterFor(hooks, contentType).run({
+			renditions: found.track.renditions,
+			constraints: state.quality.constraints,
+			pinned: state.quality.pinned,
+			current: state.quality.active,
+			couplings: state.presentation.couplings,
+			activeTracks: state.tracks.active,
+			availableGroups: availableGroups(state),
+			abr: (_hooks$abr = hooks.abr) !== null && _hooks$abr !== void 0 ? _hooks$abr : null,
+			telemetry: {
+				throughputEwma: state.stats.throughputEwma,
+				throughputFastEwma: state.stats.throughputFastEwma,
+				bufferAhead,
+				current: state.quality.active,
+				currentTime: state.playback.currentTime,
+				canSwitchTo: (_hooks$switchPolicy = hooks.switchPolicy) !== null && _hooks$switchPolicy !== void 0 ? _hooks$switchPolicy : canSwitchTo
+			}
+		}, memoKey);
+		for (const event of outcome.events) effects.push(event);
+		const rendition = found.track.renditions.find((r) => r.id === outcome.result.selected);
+		if (rendition === void 0) continue;
+		if (contentType === "video" && quality.active !== rendition.id) quality = _objectSpread2(_objectSpread2({}, quality), {}, { active: rendition.id });
+		const inflight = [];
+		for (const request of state.scheduling.inflight.values()) if (request.trackId === trackId) inflight.push(request);
+		if (!state.buffers.has(sbId) && inflight.length === 0) {
+			const codecs = rendition.codecs === null ? rendition.mimeType : `${rendition.mimeType}; codecs="${rendition.codecs}"`;
+			effects.push({
+				kind: "createSourceBuffer",
+				sbId,
+				codecs
+			});
+		}
+		if (rendition.init !== void 0 && ((_state$buffers$get4 = state.buffers.get(sbId)) === null || _state$buffers$get4 === void 0 ? void 0 : _state$buffers$get4.initFor) !== rendition.id && inflight.length === 0) {
+			initFetches.push({
+				trackId,
+				sbId,
+				rendition: rendition.id,
+				init: rendition.init
+			});
+			continue;
+		}
+		tracks.push({
+			trackId,
+			period: found.period,
+			rendition,
+			ranges: (_state$buffers$get$ra3 = (_state$buffers$get5 = state.buffers.get(sbId)) === null || _state$buffers$get5 === void 0 ? void 0 : _state$buffers$get5.ranges) !== null && _state$buffers$get$ra3 !== void 0 ? _state$buffers$get$ra3 : [],
+			sbId,
+			inflight
+		});
+	}
+	for (const contentType of ["text", "metadata"]) {
+		var _state$cues$get;
+		const trackId = state.tracks.active.get(contentType);
+		if (trackId === void 0) continue;
+		const found = findTrackSite(state.presentation, trackId);
+		const rendition = found === null || found === void 0 ? void 0 : found.track.renditions[0];
+		if (found === null || rendition === void 0) continue;
+		const inflight = [];
+		for (const request of state.scheduling.inflight.values()) if (request.trackId === trackId) inflight.push(request);
+		tracks.push({
+			trackId,
+			period: found.period,
+			rendition,
+			ranges: (_state$cues$get = state.cues.get(trackId)) !== null && _state$cues$get !== void 0 ? _state$cues$get : [],
+			inflight
+		});
+	}
+	const result = schedule({
+		currentTime: state.playback.currentTime,
+		bufferGoal: state.scheduling.bufferGoal,
+		tokenSeq: state.scheduling.tokenSeq + initFetches.length,
+		tracks,
+		liveWindow: state.presentation.isLive ? (_state$live$span = (_state$live = state.live) === null || _state$live === void 0 ? void 0 : _state$live.span) !== null && _state$live$span !== void 0 ? _state$live$span : null : null,
+		mediaTimeNormalized: cfg.mediaTimeNormalized
+	});
+	const decisionKey = [...initFetches.map((p) => `${p.trackId}:init:${p.rendition}`), ...result.requests.map((r) => {
+		var _r$renditionId;
+		return `${r.trackId}:${r.seq}:${(_r$renditionId = r.renditionId) !== null && _r$renditionId !== void 0 ? _r$renditionId : ""}`;
+	})].join("|");
+	let repeat = state.scheduling.repeat;
+	if (decisionKey !== "") {
+		repeat = repeat !== void 0 && repeat.key === decisionKey ? {
+			key: decisionKey,
+			count: repeat.count + 1
+		} : {
+			key: decisionKey,
+			count: 1
+		};
+		if (repeat.count > cfg.repeatFetchLimit) {
+			effects.push({
+				kind: "emit",
+				event: "error",
+				payload: {
+					category: "internal",
+					code: "INTERNAL_ASSERTION",
+					fatal: true,
+					recoverable: false,
+					context: {
+						reason: "the same fetch decision repeated without progress",
+						decisionKey
+					}
+				}
+			});
+			return [_objectSpread2(_objectSpread2({}, state), {}, {
+				quality,
+				lifecycle: { phase: "error" },
+				scheduling: _objectSpread2(_objectSpread2({}, state.scheduling), {}, { repeat })
+			}), effects];
+		}
+	}
+	let tokenSeq = state.scheduling.tokenSeq;
+	const inflight = new Map(state.scheduling.inflight);
+	for (const pending of initFetches) {
+		tokenSeq += 1;
+		const token = `t${tokenSeq}:${pending.trackId}:init`;
+		effects.push(_objectSpread2({
+			kind: "fetch",
+			token,
+			url: pending.init.url
+		}, pending.init.byteRange !== void 0 ? { range: pending.init.byteRange } : {}));
+		inflight.set(token, {
+			token,
+			trackId: pending.trackId,
+			seq: -1,
+			url: pending.init.url,
+			sbId: pending.sbId,
+			renditionId: pending.rendition
+		});
+	}
+	for (const effect of result.effects) effects.push(effect);
+	for (const request of result.requests) inflight.set(request.token, request);
+	const mediaTracks = tracks.filter((track) => track.sbId !== void 0);
+	if (state.presentation.duration !== void 0 && initFetches.length === 0 && result.effects.length === 0 && mediaTracks.length > 0 && mediaTracks.every((track) => {
+		var _state$presentation$d, _state$presentation3;
+		return bufferedEndFrom(track.ranges, state.playback.currentTime, .25) >= ((_state$presentation$d = (_state$presentation3 = state.presentation) === null || _state$presentation3 === void 0 ? void 0 : _state$presentation3.duration) !== null && _state$presentation$d !== void 0 ? _state$presentation$d : 0) - .5;
+	})) effects.push({ kind: "endOfStream" });
+	if (effects.length === 0 && quality === state.quality) return [state, []];
+	return [_objectSpread2(_objectSpread2({}, state), {}, {
+		quality,
+		scheduling: _objectSpread2(_objectSpread2({}, state.scheduling), {}, {
+			inflight,
+			tokenSeq: result.tokenSeq
+		}, repeat !== void 0 ? { repeat } : {})
+	}), effects];
+}
+const arbiters = /* @__PURE__ */ new WeakMap();
+function arbiterFor(hooks, contentType) {
+	let pair = arbiters.get(hooks);
+	if (pair === void 0) {
+		pair = {
+			video: createArbiter(),
+			audio: createArbiter()
+		};
+		arbiters.set(hooks, pair);
+	}
+	return pair[contentType];
+}
+const COMMAND_TYPES = {
+	ATTACH: true,
+	DETACH: true,
+	LOAD: true,
+	UNLOAD: true,
+	SEEK: true,
+	SEEK_TO_LIVE_EDGE: true,
+	DESELECT_TRACK: true,
+	SELECT_TRACK: true,
+	PIN_RENDITION: true,
+	RELEASE_PIN: true,
+	CONSTRAIN: true,
+	RELEASE_CONSTRAINT: true,
+	SET_BUFFER_GOAL: true,
+	ABORT_INFLIGHT: true
+};
+function isCommand(msg) {
+	return msg.type in COMMAND_TYPES;
+}
+/**
+* Builds the root reducer from the built-in kernel logic plus stage slices.
+* A slice reducer receives its own slice (undefined on first run) and a
+* read-only view of kernel state. A throwing slice reducer is contained: its
+* slice keeps the previous value and an error event effect is emitted, so
+* one broken stage cannot corrupt kernel state.
+*/
+function createReducer(slices, config, hooks = {}) {
+	const sliceList = slices ? [...slices] : [];
+	const cfg = resolveConfig(config);
+	const DRIVING_FACTS = /* @__PURE__ */ new Set([
+		"MANIFEST_LOADED",
+		"SEGMENT_LOADED",
+		"SOURCEBUFFER_UPDATEEND",
+		"SEEKING",
+		"SEEKED",
+		"LIVE_WINDOW_CHANGED",
+		"TICK"
+	]);
+	return (state, msg) => {
+		const manifestRequest = !isCommand(msg) && msg.type === "SEGMENT_LOADED" ? manifestRequestFor(state, msg) : null;
+		let [next, effects] = isCommand(msg) ? reduceCommand(state, msg, cfg, hooks) : reduceFact(state, msg, cfg, hooks);
+		if (!isCommand(msg) && DRIVING_FACTS.has(msg.type)) {
+			const [driven, driveEffects] = driveScheduling(next, hooks, cfg);
+			next = driven;
+			if (driveEffects.length > 0) effects = [...effects, ...driveEffects];
+		}
+		let claimed = manifestRequest === null;
+		for (const [name, slice] of sliceList) try {
+			const [sliceState, sliceEffects] = slice(next[name], msg, next);
+			next = _objectSpread2(_objectSpread2({}, next), {}, { [name]: sliceState });
+			if (sliceEffects.length > 0) {
+				effects = [...effects, ...sliceEffects];
+				if (sliceEffects.some((effect) => effect.kind !== "emit")) claimed = true;
+			}
+		} catch (err) {
+			effects = [...effects, {
+				kind: "emit",
+				event: "kernel:slice-error",
+				payload: {
+					slice: name,
+					message: String(err)
+				}
+			}];
+		}
+		if (!claimed && manifestRequest !== null && next.lifecycle.phase === "loading") {
+			const [failed, failEffects] = failManifest(next, {
+				category: "manifest",
+				code: "MANIFEST_UNSUPPORTED",
+				fatal: true,
+				recoverable: false
+			}, { url: manifestRequest.url });
+			next = failed;
+			effects = [...effects, ...failEffects];
+		}
+		return [next, effects];
+	};
+}
+//#endregion
+export { DEFAULT_KERNEL_CONFIG, createReducer, initialState, isCommand, resolveConfig };