mattebox 0.1.0

package/dist/es2015/protocols/hls-live/index.js

@@ -0,0 +1,296 @@
+import _objectSpread2 from "../../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+import { mergePlaylist, parseMediaPlaylist } from "../hls-cmaf/parse.js";
+import { registerLiveNamespace } from "../live-shared.js";
+//#region src/protocols/hls-live/index.ts
+const REFRESH_TOKEN = "hls:live:refresh";
+const TICK_TOKEN = "hls-live:reload";
+const INITIAL = {
+	manifestUrl: null,
+	target: null,
+	companions: [],
+	round: 0,
+	tickPending: false,
+	inflight: null,
+	lastEndSeq: -1,
+	awaitingTarget: false
+};
+/**
+* A two-hour DVR playlist is tens of kilobytes; reloading four of them every
+* target duration saturates a slow link. The audio and text companions keep
+* the full cadence because playback consumes them; the other video rungs
+* only need to be fresh enough for a switch, which reloads the new target
+* at once anyway.
+*/
+const LADDER_EVERY = 3;
+/**
+* Every reload names its rendition in the token, the target's included. A
+* response is merged into the rendition it was fetched for, never into
+* whichever rendition is the target when it lands: a switch while a
+* reload is in flight would otherwise file one rendition's segment URLs
+* under another, and the scheduler would then append the wrong bytes under
+* a matching rendition id, which no init guard can catch.
+*/
+function refreshToken(renditionId) {
+	return `${REFRESH_TOKEN}:${renditionId}`;
+}
+function renditionOfToken(token) {
+	return token.startsWith(`${REFRESH_TOKEN}:`) ? token.slice(17) : null;
+}
+function findRendition(presentation, renditionId) {
+	for (const period of presentation.periods) for (const track of period.tracks) for (const rendition of track.renditions) if (rendition.id === renditionId) return rendition;
+	return null;
+}
+/**
+* The active tracks' playlists other than the window rendition's: every
+* other video rendition, the audio group rendition, a segmented subtitle
+* playlist. The whole video ladder reloads because a switch can only land
+* on a rendition whose playlist reaches the playhead; one left at its
+* startup window can never be scheduled from, so the switch never happens.
+* Renditions without a playlist of their own (muxed audio, a text track in
+* a single file) need no reload.
+*/
+function companionTargets(presentation, kernel, windowRenditionId) {
+	const activeIds = new Set([
+		"video",
+		"audio",
+		"text"
+	].map((contentType) => kernel.tracks.active.get(contentType)).filter((id) => id !== void 0));
+	const out = [];
+	for (const period of presentation.periods) for (const track of period.tracks) {
+		if (!activeIds.has(track.id)) continue;
+		for (const rendition of track.renditions) {
+			if (rendition.id === windowRenditionId || rendition.playlistUrl === void 0) continue;
+			out.push({
+				url: rendition.playlistUrl,
+				renditionId: rendition.id,
+				ladder: track.contentType === "video"
+			});
+		}
+	}
+	return out;
+}
+/** Loops a message back into the bus through a zero-delay schedule effect. */
+function feed(message) {
+	return {
+		kind: "schedule",
+		token: "hls-live:loopback",
+		delayMs: 0,
+		then: message
+	};
+}
+function tick(delaySeconds) {
+	return {
+		kind: "schedule",
+		token: TICK_TOKEN,
+		delayMs: Math.max(500, delaySeconds * 1e3),
+		then: {
+			type: "TICK",
+			token: TICK_TOKEN
+		}
+	};
+}
+/**
+* The rendition whose playlist drives the live window: the active video
+* rendition, else the first with segments. Video leads, but an audio-only
+* presentation (a radio or packed-audio DVR stream) has no video track, so
+* audio drives the window there.
+*/
+function windowRendition(presentation, kernel) {
+	let fallback = null;
+	for (const contentType of ["video", "audio"]) {
+		for (const period of presentation.periods) for (const track of period.tracks) {
+			if (track.contentType !== contentType) continue;
+			for (const rendition of track.renditions) {
+				var _fallback;
+				if (!Array.isArray(rendition.segments) || rendition.segments.length === 0) continue;
+				if (rendition.id === kernel.quality.active) return rendition;
+				fallback = (_fallback = fallback) !== null && _fallback !== void 0 ? _fallback : rendition;
+			}
+		}
+		if (fallback !== null) return fallback;
+	}
+	return fallback;
+}
+/**
+* The window fact for the rendition's current segment list, or null when
+* the kernel already holds exactly that window: every companion reload
+* feeds a MANIFEST_LOADED, and a window that has not moved is not news.
+*/
+function windowFact(presentation, rendition, kernel) {
+	var _presentation$live$ho, _presentation$live, _presentation$live$up, _presentation$live2;
+	const segments = rendition.segments;
+	if (!Array.isArray(segments) || segments.length === 0) return null;
+	const first = segments[0];
+	const last = segments[segments.length - 1];
+	if (first === void 0 || last === void 0) return null;
+	const end = last.start + last.duration;
+	const holdBack = (_presentation$live$ho = (_presentation$live = presentation.live) === null || _presentation$live === void 0 ? void 0 : _presentation$live.holdBack) !== null && _presentation$live$ho !== void 0 ? _presentation$live$ho : 3 * ((_presentation$live$up = (_presentation$live2 = presentation.live) === null || _presentation$live2 === void 0 ? void 0 : _presentation$live2.updatePeriod) !== null && _presentation$live$up !== void 0 ? _presentation$live$up : last.duration);
+	const start = first.start;
+	const edge = Math.max(start, end - holdBack);
+	const known = kernel.live;
+	if (known !== null && known.span.start === start && known.span.end === end && known.edge === edge) return null;
+	return feed({
+		type: "LIVE_WINDOW_CHANGED",
+		start,
+		end,
+		edge
+	});
+}
+/** The playlist URL a rendition's reload resolves against. */
+function playlistUrlFor(presentation, renditionId, target) {
+	const rendition = findRendition(presentation, renditionId);
+	if ((rendition === null || rendition === void 0 ? void 0 : rendition.playlistUrl) !== void 0) return rendition.playlistUrl;
+	return target !== null && target.renditionId === renditionId ? target.url : null;
+}
+const reduceHlsLive = (slice, msg, kernel) => {
+	const state = slice !== null && slice !== void 0 ? slice : INITIAL;
+	if (msg.type === "LOAD") return [_objectSpread2(_objectSpread2({}, INITIAL), {}, { manifestUrl: msg.url }), []];
+	if (msg.type === "UNLOAD" || msg.type === "DETACH") return [INITIAL, []];
+	if (msg.type === "MANIFEST_LOADED") {
+		var _rendition$playlistUr, _rendition$id;
+		if (!msg.presentation.isLive) return [_objectSpread2(_objectSpread2({}, state), {}, {
+			target: null,
+			companions: [],
+			inflight: null
+		}), []];
+		const rendition = windowRendition(msg.presentation, kernel);
+		const effects = [];
+		const url = (_rendition$playlistUr = rendition === null || rendition === void 0 ? void 0 : rendition.playlistUrl) !== null && _rendition$playlistUr !== void 0 ? _rendition$playlistUr : state.manifestUrl;
+		const target = url !== null && rendition !== null ? {
+			url,
+			renditionId: rendition.id,
+			ladder: false
+		} : state.target;
+		const companions = companionTargets(msg.presentation, kernel, (_rendition$id = rendition === null || rendition === void 0 ? void 0 : rendition.id) !== null && _rendition$id !== void 0 ? _rendition$id : null);
+		const switched = state.target !== null && target !== null && target.renditionId !== state.target.renditionId;
+		let awaitingTarget = state.awaitingTarget;
+		let inflight = state.inflight;
+		if (switched && target !== null) {
+			if (inflight !== target.renditionId) {
+				effects.push({
+					kind: "fetch",
+					token: refreshToken(target.renditionId),
+					url: target.url
+				});
+				inflight = target.renditionId;
+			}
+			awaitingTarget = true;
+		} else if (!awaitingTarget && rendition !== null) {
+			const window = windowFact(msg.presentation, rendition, kernel);
+			if (window !== null) effects.push(window);
+		}
+		let tickPending = state.tickPending;
+		if (!tickPending && inflight === null && target !== null) {
+			var _msg$presentation$liv, _msg$presentation$liv2;
+			effects.push(tick((_msg$presentation$liv = (_msg$presentation$liv2 = msg.presentation.live) === null || _msg$presentation$liv2 === void 0 ? void 0 : _msg$presentation$liv2.updatePeriod) !== null && _msg$presentation$liv !== void 0 ? _msg$presentation$liv : 4));
+			tickPending = true;
+		}
+		return [_objectSpread2(_objectSpread2({}, state), {}, {
+			target,
+			companions,
+			tickPending,
+			inflight,
+			awaitingTarget
+		}), effects];
+	}
+	if (msg.type === "TICK" && msg.token === TICK_TOKEN) {
+		var _kernel$presentation;
+		if (state.target === null || ((_kernel$presentation = kernel.presentation) === null || _kernel$presentation === void 0 ? void 0 : _kernel$presentation.isLive) !== true) return [_objectSpread2(_objectSpread2({}, state), {}, {
+			tickPending: false,
+			inflight: null
+		}), []];
+		const effects = [];
+		let inflight = state.inflight;
+		if (inflight !== state.target.renditionId) {
+			effects.push({
+				kind: "fetch",
+				token: refreshToken(state.target.renditionId),
+				url: state.target.url
+			});
+			inflight = state.target.renditionId;
+		}
+		for (const companion of state.companions) {
+			if (companion.ladder && state.round % LADDER_EVERY !== 0) continue;
+			effects.push({
+				kind: "fetch",
+				token: refreshToken(companion.renditionId),
+				url: companion.url
+			});
+		}
+		return [_objectSpread2(_objectSpread2({}, state), {}, {
+			round: state.round + 1,
+			tickPending: false,
+			inflight
+		}), effects];
+	}
+	if (msg.type === "SEGMENT_FAILED") {
+		const renditionId = renditionOfToken(msg.trackId);
+		if (renditionId === null) return [state, []];
+		if (state.target === null || renditionId !== state.target.renditionId) return [state, []];
+		if (state.tickPending) return [_objectSpread2(_objectSpread2({}, state), {}, { inflight: null }), []];
+		return [_objectSpread2(_objectSpread2({}, state), {}, {
+			inflight: null,
+			tickPending: true
+		}), [tick(2)]];
+	}
+	if (msg.type === "SEGMENT_LOADED") {
+		var _lastSegment$seq;
+		const renditionId = renditionOfToken(msg.trackId);
+		if (renditionId === null || kernel.presentation === null) return [state, []];
+		const isTarget = state.target !== null && renditionId === state.target.renditionId;
+		const url = playlistUrlFor(kernel.presentation, renditionId, state.target);
+		if (url === null) return [state, []];
+		const text = new TextDecoder().decode(msg.bytes);
+		const media = parseMediaPlaylist(text, url);
+		if (media.playlist === null) {
+			if (!isTarget) return [state, []];
+			if (state.tickPending) return [_objectSpread2(_objectSpread2({}, state), {}, { inflight: null }), []];
+			return [_objectSpread2(_objectSpread2({}, state), {}, {
+				inflight: null,
+				tickPending: true
+			}), [tick(2)]];
+		}
+		const refreshed = mergePlaylist(kernel.presentation, renditionId, media.playlist);
+		const effects = [feed({
+			type: "PLAYLIST_REFRESHED",
+			trackId: renditionId,
+			renditionId,
+			mediaSequence: media.playlist.mediaSequence,
+			segments: media.playlist.segments
+		}), feed({
+			type: "MANIFEST_LOADED",
+			presentation: refreshed
+		})];
+		if (!isTarget) return [state, effects];
+		const lastSegment = media.playlist.segments[media.playlist.segments.length - 1];
+		const endSeq = (_lastSegment$seq = lastSegment === null || lastSegment === void 0 ? void 0 : lastSegment.seq) !== null && _lastSegment$seq !== void 0 ? _lastSegment$seq : -1;
+		const changed = endSeq !== state.lastEndSeq;
+		const cadence = media.playlist.targetDuration || 4;
+		let tickPending = state.tickPending;
+		if (!media.playlist.endlist && !tickPending) {
+			effects.push(tick(changed ? cadence : cadence / 2));
+			tickPending = true;
+		}
+		return [_objectSpread2(_objectSpread2({}, state), {}, {
+			lastEndSeq: endSeq,
+			tickPending,
+			inflight: null,
+			awaitingTarget: false
+		}), effects];
+	}
+	return [state, []];
+};
+/** The stage factory. Requires hls-cmaf; the loader enforces it. */
+function hlsLive() {
+	return {
+		name: "hls-live",
+		provides: ["hls-live"],
+		requires: ["hls-cmaf"],
+		install(ctx) {
+			ctx.reduce("hls-live", reduceHlsLive);
+			registerLiveNamespace(ctx);
+		}
+	};
+}
+//#endregion
+export { hlsLive as default };

package/dist/es2015/protocols/live-shared.js

@@ -0,0 +1,29 @@
+//#region src/protocols/live-shared.ts
+/** How far behind the edge still counts as at it, in seconds. */
+const AT_EDGE_SLACK = 2;
+function registerLiveNamespace(ctx) {
+	const api = {
+		get edge() {
+			var _ctx$getState$live$ed, _ctx$getState$live;
+			return (_ctx$getState$live$ed = (_ctx$getState$live = ctx.getState().live) === null || _ctx$getState$live === void 0 ? void 0 : _ctx$getState$live.edge) !== null && _ctx$getState$live$ed !== void 0 ? _ctx$getState$live$ed : null;
+		},
+		get latency() {
+			const state = ctx.getState();
+			if (state.live === null) return null;
+			return state.live.span.end - state.playback.currentTime;
+		},
+		get atEdge() {
+			const state = ctx.getState();
+			if (state.live === null) return false;
+			return state.playback.currentTime >= state.live.edge - AT_EDGE_SLACK;
+		},
+		seekToEdge() {
+			ctx.dispatch({ type: "SEEK_TO_LIVE_EDGE" });
+		}
+	};
+	try {
+		ctx.registerNamespace("live", api);
+	} catch (_unused) {}
+}
+//#endregion
+export { registerLiveNamespace };

package/dist/es2015/stages/abr/index.js

@@ -0,0 +1,126 @@
+import _objectSpread2 from "../../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+import { canSwitchTo } from "../../kernel/rendition-select.js";
+//#region src/stages/abr/index.ts
+/**
+* Adaptive bitrate as a stage, not kernel. It registers one chooser
+* consulted at arbitration step 5 and one constraint source for
+* emergencies; it never mutates another source's constraints and playback
+* works identically without it, at the lowest permitted rendition.
+*
+* The chooser is a pure function of its arguments: every input comes from
+* kernel telemetry, so replaying a trace through the same composition
+* reproduces every decision. The emergency path lives in a slice reducer
+* for the same reason.
+*/
+const DEFAULTS = {
+	safetyFactor: .7,
+	upBufferSeconds: 8,
+	downBufferSeconds: 4,
+	emergencyFactor: .5,
+	recoveryFactor: 2
+};
+/** The conservative estimate: the minimum of the slow and fast EWMAs. */
+function estimateBps(telemetry) {
+	var _telemetry$throughput;
+	const slow = telemetry.throughputEwma;
+	const fast = (_telemetry$throughput = telemetry.throughputFastEwma) !== null && _telemetry$throughput !== void 0 ? _telemetry$throughput : slow;
+	if (slow === 0) return fast;
+	if (fast === 0) return slow;
+	return Math.min(slow, fast);
+}
+function choose(allowed, telemetry, options) {
+	var _allowed$find, _telemetry$bufferAhea, _telemetry$canSwitchT;
+	const sorted = [...allowed].sort((a, b) => a.bitrate - b.bitrate);
+	const lowestRendition = sorted[0];
+	const current = (_allowed$find = allowed.find((r) => r.id === telemetry.current)) !== null && _allowed$find !== void 0 ? _allowed$find : null;
+	const estimate = estimateBps(telemetry);
+	if (estimate === 0) return (current !== null && current !== void 0 ? current : lowestRendition).id;
+	let best = lowestRendition;
+	for (const candidate of sorted) if (candidate.bitrate <= estimate * options.safetyFactor) best = candidate;
+	if (current === null) return best.id;
+	if (best.id === current.id) return current.id;
+	const buffer = (_telemetry$bufferAhea = telemetry.bufferAhead) !== null && _telemetry$bufferAhea !== void 0 ? _telemetry$bufferAhea : 0;
+	const policy = (_telemetry$canSwitchT = telemetry.canSwitchTo) !== null && _telemetry$canSwitchT !== void 0 ? _telemetry$canSwitchT : canSwitchTo;
+	if (best.bitrate > current.bitrate) {
+		if (buffer < options.upBufferSeconds) return current.id;
+		if (policy(current, best) === "reload") return current.id;
+		return best.id;
+	}
+	if (buffer < options.downBufferSeconds || current.bitrate > estimate) {
+		if (policy(current, best) === "reload") return current.id;
+		return best.id;
+	}
+	return current.id;
+}
+const INITIAL = { emergencyCap: null };
+/** Loops a command back into the bus through a zero-delay schedule effect. */
+function feed(message) {
+	return {
+		kind: "schedule",
+		token: "abr:emergency",
+		delayMs: 0,
+		then: message
+	};
+}
+function activeBitrate(kernel) {
+	if (kernel.presentation === null || kernel.quality.active === null) return null;
+	for (const period of kernel.presentation.periods) for (const track of period.tracks) for (const rendition of track.renditions) if (rendition.id === kernel.quality.active) return rendition.bitrate;
+	return null;
+}
+/** The track ABR steers: video where there is one, else audio. */
+function leadTrack(kernel) {
+	var _kernel$tracks$active;
+	return (_kernel$tracks$active = kernel.tracks.active.get("video")) !== null && _kernel$tracks$active !== void 0 ? _kernel$tracks$active : kernel.tracks.active.get("audio");
+}
+function lowestBitrate(kernel) {
+	var _kernel$presentation$, _kernel$presentation;
+	let lowest = Number.POSITIVE_INFINITY;
+	for (const period of (_kernel$presentation$ = (_kernel$presentation = kernel.presentation) === null || _kernel$presentation === void 0 ? void 0 : _kernel$presentation.periods) !== null && _kernel$presentation$ !== void 0 ? _kernel$presentation$ : []) for (const track of period.tracks) {
+		if (track.contentType !== "video") continue;
+		for (const rendition of track.renditions) lowest = Math.min(lowest, rendition.bitrate);
+	}
+	return Number.isFinite(lowest) ? lowest : 0;
+}
+/** Samples smaller than this are jitter-dominated; ignore them for emergencies. */
+const MIN_SAMPLE_BYTES = 1e4;
+function createEmergencyReducer(options) {
+	return (slice, msg, kernel) => {
+		const state = slice !== null && slice !== void 0 ? slice : INITIAL;
+		if (msg.type === "UNLOAD" || msg.type === "DETACH") return [INITIAL, []];
+		let raw = null;
+		if (msg.type === "THROUGHPUT_SAMPLE") raw = msg.bps;
+		else if (msg.type === "SEGMENT_LOADED" && msg.seq >= 0 && msg.trackId === leadTrack(kernel) && msg.rtt > 0 && msg.size >= MIN_SAMPLE_BYTES) raw = msg.size * 8e3 / msg.rtt;
+		if (raw === null) return [state, []];
+		if (state.emergencyCap === null) {
+			const bitrate = activeBitrate(kernel);
+			if (bitrate === null || bitrate === 0) return [state, []];
+			if (raw >= bitrate * options.emergencyFactor) return [state, []];
+			const cap = Math.max(raw, lowestBitrate(kernel));
+			return [{ emergencyCap: cap }, [feed({
+				type: "CONSTRAIN",
+				source: "abr-emergency",
+				constraint: { maxBitrate: cap }
+			})]];
+		}
+		if (kernel.stats.throughputFastEwma >= state.emergencyCap * options.recoveryFactor) return [INITIAL, [feed({
+			type: "RELEASE_CONSTRAINT",
+			source: "abr-emergency"
+		})]];
+		return [state, []];
+	};
+}
+/** The stage factory. One chooser, one emergency constraint source. */
+function abr(options) {
+	const resolved = _objectSpread2(_objectSpread2({}, DEFAULTS), options);
+	return {
+		name: "abr",
+		provides: ["abr"],
+		requires: ["scheduler", "track-registry"],
+		install(ctx) {
+			ctx.registerChooser({ choose: (allowed, telemetry) => choose(allowed, telemetry, resolved) });
+			ctx.reduce("abr", createEmergencyReducer(resolved));
+		}
+	};
+}
+//#endregion
+export { abr as default };

package/dist/es2015/stages/abr-cap-size/index.js

@@ -0,0 +1,22 @@
+//#region src/stages/abr-cap-size/index.ts
+function abrCapSize() {
+	return {
+		name: "abr-cap-size",
+		requires: ["rendition-select"],
+		install(ctx) {
+			const observer = new ResizeObserver(([entry]) => {
+				if (entry === void 0) return;
+				const dpr = Math.min(globalThis.devicePixelRatio || 1, 2);
+				ctx.dispatch({
+					type: "CONSTRAIN",
+					source: "element-size",
+					constraint: { maxHeight: entry.contentRect.height * dpr }
+				});
+			});
+			observer.observe(ctx.element);
+			return () => observer.disconnect();
+		}
+	};
+}
+//#endregion
+export { abrCapSize as default };

package/dist/es2015/stages/abr-persist/index.js

@@ -0,0 +1,52 @@
+import _objectSpread2 from "../../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+//#region src/stages/abr-persist/index.ts
+const INITIAL = {
+	seeded: false,
+	lastSaved: 0
+};
+const SAVE_EVENT = "abr-persist:save";
+/** Relative drift that triggers a save. */
+const DRIFT = .2;
+function abrPersist(storage) {
+	return {
+		name: "abr-persist",
+		requires: ["abr"],
+		install(ctx) {
+			const remembered = storage.get();
+			const reduce = (slice, msg, kernel) => {
+				const state = slice !== null && slice !== void 0 ? slice : INITIAL;
+				if (msg.type === "LOAD" && !state.seeded && remembered !== null && remembered > 0) {
+					const effects = [{
+						kind: "schedule",
+						token: "abr-persist:seed",
+						delayMs: 0,
+						then: {
+							type: "THROUGHPUT_SAMPLE",
+							bps: remembered,
+							trackId: "abr-persist"
+						}
+					}];
+					return [_objectSpread2(_objectSpread2({}, state), {}, {
+						seeded: true,
+						lastSaved: remembered
+					}), effects];
+				}
+				if (msg.type === "SEGMENT_LOADED") {
+					const current = kernel.stats.throughputEwma;
+					if (current > 0 && Math.abs(current - state.lastSaved) > state.lastSaved * DRIFT) return [_objectSpread2(_objectSpread2({}, state), {}, { lastSaved: current }), [{
+						kind: "emit",
+						event: SAVE_EVENT,
+						payload: current
+					}]];
+				}
+				return [state, []];
+			};
+			ctx.reduce("abr-persist", reduce);
+			return ctx.on(SAVE_EVENT, (bps) => {
+				if (typeof bps === "number") storage.set(Math.round(bps));
+			});
+		}
+	};
+}
+//#endregion
+export { abrPersist as default };

package/dist/es2015/stages/aes-128/index.js

@@ -0,0 +1,76 @@
+import _asyncToGenerator from "../../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/asyncToGenerator.js";
+//#region src/stages/aes-128/index.ts
+/** Before the transmux (100) and the codec probe (5), which must read clear bytes. */
+const DECRYPT_ORDER = 1;
+/** The 16-byte IV: the explicit hex one, or the sequence number big-endian. */
+function ivFor(key, seq) {
+	const iv = /* @__PURE__ */ new Uint8Array(16);
+	if (key.iv !== void 0) {
+		const hex = key.iv.slice(-32).padStart(32, "0");
+		for (let i = 0; i < 16; i += 1) iv[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+		return iv;
+	}
+	const view = new DataView(iv.buffer);
+	view.setUint32(8, Math.floor(seq / Math.pow(2, 32)));
+	view.setUint32(12, seq >>> 0);
+	return iv;
+}
+function findSegment(state, renditionId, seq) {
+	if (state.presentation === null || renditionId === "") return null;
+	for (const period of state.presentation.periods) for (const track of period.tracks) for (const rendition of track.renditions) {
+		var _rendition$segments$f;
+		if (rendition.id !== renditionId || !Array.isArray(rendition.segments)) continue;
+		return (_rendition$segments$f = rendition.segments.find((segment) => segment.seq === seq)) !== null && _rendition$segments$f !== void 0 ? _rendition$segments$f : null;
+	}
+	return null;
+}
+function aes128() {
+	return {
+		name: "aes-128",
+		provides: ["aes-128", "media-transform"],
+		install(ctx) {
+			const keys = /* @__PURE__ */ new Map();
+			function keyFor(uri) {
+				let pending = keys.get(uri);
+				if (pending === void 0) {
+					pending = ctx.request(uri, {}).then(function() {
+						var _ref = _asyncToGenerator(function* (response) {
+							if (!response.ok) throw new Error(`key fetch failed: HTTP ${response.status}`);
+							const raw = yield response.arrayBuffer();
+							if (raw.byteLength !== 16) throw new Error(`key is ${raw.byteLength} bytes, not 16`);
+							return crypto.subtle.importKey("raw", raw, { name: "AES-CBC" }, false, ["decrypt"]);
+						});
+						return function(_x) {
+							return _ref.apply(this, arguments);
+						};
+					}()).catch((err) => {
+						keys.delete(uri);
+						throw err;
+					});
+					keys.set(uri, pending);
+				}
+				return pending;
+			}
+			ctx.registerTransform({
+				name: "aes-128",
+				order: DECRYPT_ORDER,
+				transform(data, meta) {
+					return _asyncToGenerator(function* () {
+						const segment = findSegment(ctx.getState(), meta.renditionId, meta.seq);
+						const key = segment === null || segment === void 0 ? void 0 : segment.key;
+						if (key === void 0) return data;
+						const cryptoKey = yield keyFor(key.uri);
+						const clear = yield crypto.subtle.decrypt({
+							name: "AES-CBC",
+							iv: ivFor(key, meta.seq)
+						}, cryptoKey, data);
+						return new Uint8Array(clear);
+					})();
+				}
+			});
+			return () => keys.clear();
+		}
+	};
+}
+//#endregion
+export { aes128 as default, ivFor };

package/dist/es2015/stages/alt-audio/index.js

@@ -0,0 +1,80 @@
+//#region src/stages/alt-audio/index.ts
+const INITIAL = { preferredLang: null };
+/** Audio tracks with their group parsed from the `group:name` id convention. */
+function audioTracks(kernel) {
+	var _kernel$presentation$, _kernel$presentation;
+	const out = [];
+	for (const period of (_kernel$presentation$ = (_kernel$presentation = kernel.presentation) === null || _kernel$presentation === void 0 ? void 0 : _kernel$presentation.periods) !== null && _kernel$presentation$ !== void 0 ? _kernel$presentation$ : []) for (const track of period.tracks) {
+		var _track$lang;
+		if (track.contentType !== "audio") continue;
+		const colon = track.id.indexOf(":");
+		out.push({
+			id: track.id,
+			group: colon === -1 ? track.id : track.id.slice(0, colon),
+			lang: (_track$lang = track.lang) !== null && _track$lang !== void 0 ? _track$lang : null,
+			isDefault: track.role === "main"
+		});
+	}
+	return out;
+}
+/** The audio group the active video rendition's coupling requires, or null. */
+function requiredGroup(kernel) {
+	var _kernel$presentation2, _coupling$requires$au;
+	const activeVideo = kernel.quality.active;
+	if (activeVideo === null) return null;
+	const coupling = (_kernel$presentation2 = kernel.presentation) === null || _kernel$presentation2 === void 0 ? void 0 : _kernel$presentation2.couplings.find((c) => c.renditionId === activeVideo);
+	return (_coupling$requires$au = coupling === null || coupling === void 0 ? void 0 : coupling.requires.audio) !== null && _coupling$requires$au !== void 0 ? _coupling$requires$au : null;
+}
+/** Picks the audio track in `group`, preferring a language, then default, then first. */
+function pickInGroup(tracks, group, preferredLang) {
+	var _ref, _ref2;
+	const inGroup = tracks.filter((t) => t.group === group);
+	if (inGroup.length === 0) return null;
+	return (_ref = (_ref2 = preferredLang !== null ? inGroup.find((t) => t.lang === preferredLang) : void 0) !== null && _ref2 !== void 0 ? _ref2 : inGroup.find((t) => t.isDefault)) !== null && _ref !== void 0 ? _ref : inGroup[0];
+}
+/** Loops a command back into the bus through a zero-delay schedule effect. */
+function select(trackId) {
+	return {
+		kind: "schedule",
+		token: "alt-audio:select",
+		delayMs: 0,
+		then: {
+			type: "SELECT_TRACK",
+			trackId
+		}
+	};
+}
+const reduceAltAudio = (slice, msg, kernel) => {
+	const state = slice !== null && slice !== void 0 ? slice : INITIAL;
+	if (msg.type === "LOAD" || msg.type === "UNLOAD" || msg.type === "DETACH") return [INITIAL, []];
+	if (msg.type === "SELECT_TRACK") {
+		const chosen = audioTracks(kernel).find((t) => t.id === msg.trackId);
+		if ((chosen === null || chosen === void 0 ? void 0 : chosen.lang) != null) return [{ preferredLang: chosen.lang }, []];
+		return [state, []];
+	}
+	if (msg.type === "MANIFEST_LOADED" || msg.type === "SEGMENT_LOADED") {
+		const group = requiredGroup(kernel);
+		if (group === null) return [state, []];
+		const active = kernel.tracks.active.get("audio");
+		const tracks = audioTracks(kernel);
+		const activeInfo = tracks.find((t) => t.id === active);
+		if (activeInfo !== void 0 && activeInfo.group === group) return [state, []];
+		const target = pickInGroup(tracks, group, state.preferredLang);
+		if (target === void 0 || target === null || target.id === active) return [state, []];
+		return [state, [select(target.id)]];
+	}
+	return [state, []];
+};
+/** The stage factory. */
+function altAudio() {
+	return {
+		name: "alt-audio",
+		provides: ["alt-audio"],
+		requires: ["scheduler", "codec-switch"],
+		install(ctx) {
+			ctx.reduce("alt-audio", reduceAltAudio);
+		}
+	};
+}
+//#endregion
+export { altAudio as default };