mattebox 0.1.0

package/dist/es2015/presets/kernel/index.js

@@ -0,0 +1,10 @@
+import { definePreset } from "../define.js";
+//#region src/presets/kernel/index.ts
+/**
+* The `kernel` preset: the engine with zero stages. It attaches and manages
+* buffers but parses nothing; it is the floor the size budget measures and
+* the base to build a fully custom stack on with `stages`.
+*/
+const preset = definePreset("kernel", () => []);
+//#endregion
+export { preset as default };

package/dist/es2015/presets/storage.js

@@ -0,0 +1,24 @@
+//#region src/presets/storage.ts
+const KEY = "mattebox:throughput";
+function localThroughputStorage(key = KEY) {
+	return {
+		get() {
+			try {
+				var _globalThis$localStor;
+				const value = (_globalThis$localStor = globalThis.localStorage) === null || _globalThis$localStor === void 0 ? void 0 : _globalThis$localStor.getItem(key);
+				const bps = value === null || value === void 0 ? NaN : Number(value);
+				return Number.isFinite(bps) && bps > 0 ? bps : null;
+			} catch (_unused) {
+				return null;
+			}
+		},
+		set(bps) {
+			try {
+				var _globalThis$localStor2;
+				(_globalThis$localStor2 = globalThis.localStorage) === null || _globalThis$localStor2 === void 0 || _globalThis$localStor2.setItem(key, String(Math.round(bps)));
+			} catch (_unused2) {}
+		}
+	};
+}
+//#endregion
+export { localThroughputStorage };

package/dist/es2015/presets/tiers.js

@@ -0,0 +1,93 @@
+import textWebvttSegmented from "../stages/text-webvtt-segmented/index.js";
+import textWebvtt from "../stages/text-webvtt/index.js";
+import textCea608 from "../stages/text-cea608/index.js";
+import recovery from "../stages/recovery/index.js";
+import pdt from "../stages/pdt/index.js";
+import nalScan from "../stages/nal-scan/index.js";
+import metaId3 from "../stages/meta-id3/index.js";
+import emeFairplay from "../stages/eme-fairplay/index.js";
+import emeCore from "../stages/eme-core/index.js";
+import emeCenc from "../stages/eme-cenc/index.js";
+import contentSteering from "../stages/content-steering/index.js";
+import codecSwitch from "../stages/codec-switch/index.js";
+import cmafTiming from "../stages/cmaf-timing/index.js";
+import altAudio from "../stages/alt-audio/index.js";
+import aes128 from "../stages/aes-128/index.js";
+import abrPersist from "../stages/abr-persist/index.js";
+import abrCapSize from "../stages/abr-cap-size/index.js";
+import abr from "../stages/abr/index.js";
+import hlsLive from "../protocols/hls-live/index.js";
+import hlsCmaf from "../protocols/hls-cmaf/index.js";
+import dashLive from "../protocols/dash-live/index.js";
+import dashCmaf from "../protocols/dash-cmaf/index.js";
+import packedAudio from "../containers/packed-audio/index.js";
+import tsTransmux from "../containers/ts-transmux/index.js";
+import { localThroughputStorage } from "./storage.js";
+//#region src/presets/tiers.ts
+/**
+* The building blocks of the preset matrix. Three axes answer a technical
+* requirement, each set by the packaging backend or the rights situation:
+* the protocol line (HLS, DASH, both), the container tier (CMAF only, or
+* legacy MPEG-TS as well, an HLS-side axis), and the DRM tier. Every preset
+* carries the same base on top of its line. Each group is a function so a
+* preset gets fresh stage instances, and a group a preset never calls
+* tree-shakes out of it with the stages it imports.
+*/
+/** HLS on demand and live, with program date time. */
+function hlsLine() {
+	return [
+		hlsCmaf(),
+		hlsLive(),
+		pdt(),
+		aes128()
+	];
+}
+/** DASH on demand and live. */
+function dashLine() {
+	return [dashCmaf(), dashLive()];
+}
+/**
+* What every preset carries: adaptive quality with a size cap and bandwidth
+* memory, recovery, content steering (inert until a manifest asks for it),
+* alternate audio with codec switching, WebVTT subtitles, and CMAF live
+* timing, which corrects the broadcast-clock tfdt some live packagers write
+* and leaves VOD untouched.
+*/
+function base() {
+	return [
+		abr(),
+		abrCapSize(),
+		abrPersist(localThroughputStorage()),
+		recovery(),
+		contentSteering(),
+		codecSwitch(),
+		altAudio(),
+		textWebvtt(),
+		textWebvttSegmented(),
+		cmafTiming()
+	];
+}
+/**
+* Legacy MPEG-TS: the transmuxer and packed audio, plus what rides on the
+* transport stream, CEA-608 captions and ID3 metadata. nal-scan is included
+* so a mixed backend gets the same captions from its CMAF renditions.
+*/
+function tsTier() {
+	return [
+		tsTransmux(),
+		packedAudio(),
+		nalScan(),
+		textCea608(),
+		metaId3()
+	];
+}
+/** The EME stages: sessions, CENC (Widevine, PlayReady, ClearKey), FairPlay. */
+function drmTier() {
+	return [
+		emeCore(),
+		emeCenc(),
+		emeFairplay()
+	];
+}
+//#endregion
+export { base, dashLine, drmTier, hlsLine, tsTier };

package/dist/es2015/protocols/dash-cmaf/index.js

@@ -0,0 +1,161 @@
+import { normalizeMimeType } from "../../kernel/mime.js";
+import _objectSpread2 from "../../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+import { mergeSidx, parse, sidxToSegments } from "./parse.js";
+//#region src/protocols/dash-cmaf/index.ts
+/**
+* The dash-cmaf protocol adapter as a stage. Inert module: exports a
+* factory, registers nothing at import time.
+*
+* A templated MPD (SegmentTemplate) is self-contained: one manifest fetch
+* parses straight into a complete Presentation with lazy indexed addressing.
+* The on-demand profile (SegmentBase) is not: each Representation is one file
+* indexed by a `sidx` box, so the concrete segments are unknown until that box
+* is fetched. That second phase mirrors HLS's media-playlist fetch: the parse
+* emits `sidx` addressing, this slice fetches the index byte range under a
+* `dash:idx:` token the transport correlates back, parses it, and merges the
+* resolved segments into the presentation.
+*/
+const INDEX_TOKEN = "dash:idx:";
+/** The MPD MIME type, ISO 23009-1 §C.2. */
+const MANIFEST_TYPES = ["application/dash+xml"];
+/** Unresolved on-demand addressing, or null for an explicit list or template. */
+function asSidx(addressing) {
+	if (addressing === void 0 || Array.isArray(addressing)) return null;
+	const candidate = addressing;
+	return candidate.kind === "sidx" ? candidate : null;
+}
+const INITIAL = {
+	manifestUrl: null,
+	mimeType: null,
+	pending: {}
+};
+/**
+* Whether this adapter owns the manifest bytes. An explicit mimeType
+* decides alone; without one, an MPD is an XML document and starts with
+* '<'. The parser reports a wrong root element as a parse failure.
+*/
+function claims(state, text) {
+	if (state.mimeType !== null) return MANIFEST_TYPES.includes(state.mimeType);
+	return text.trimStart().startsWith("<");
+}
+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 renditions whose sidx index still needs fetching: every rendition of
+* every active track. Resolving only the "chosen" one is not enough, because
+* the kernel selects the audio rendition independently (an audio adaptation
+* set often has several bitrates) and may pick a different one than this slice
+* would; its segments would then stay unresolved and the audio buffer would
+* never fill, stalling playback since the element's buffered range is the
+* intersection across all source buffers. Resolving them all also means an ABR
+* switch finds its target already indexed. The fetches are one small range
+* each, so the cost is negligible.
+*/
+function neededIndexes(kernel) {
+	const presentation = kernel.presentation;
+	if (presentation === null) return [];
+	const activeIds = new Set([
+		"video",
+		"audio",
+		"text"
+	].map((contentType) => kernel.tracks.active.get(contentType)).filter((id) => id !== void 0));
+	const needed = [];
+	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 (asSidx(rendition.segments) !== null) needed.push(rendition);
+	}
+	return needed;
+}
+/** Loops a message back into the bus through a zero-delay schedule effect. */
+function feed(message) {
+	return {
+		kind: "schedule",
+		token: "dash:loopback",
+		delayMs: 0,
+		then: message
+	};
+}
+const reduceDash = (slice, msg, kernel) => {
+	const state = slice !== null && slice !== void 0 ? slice : INITIAL;
+	if (msg.type === "LOAD") return [{
+		manifestUrl: msg.url,
+		mimeType: msg.mimeType === void 0 ? null : normalizeMimeType(msg.mimeType),
+		pending: {}
+	}, []];
+	if (msg.type === "UNLOAD" || msg.type === "DETACH") return [INITIAL, []];
+	if (msg.type === "SEGMENT_LOADED" && msg.trackId === "manifest" && state.manifestUrl !== null) {
+		const text = new TextDecoder().decode(msg.bytes);
+		if (!claims(state, text)) return [state, []];
+		const result = parse(text, state.manifestUrl);
+		if (result.presentation === null) {
+			var _result$error;
+			return [state, [feed({
+				type: "MANIFEST_FAILED",
+				error: (_result$error = result.error) !== null && _result$error !== void 0 ? _result$error : {
+					category: "manifest",
+					code: "MANIFEST_PARSE_FAILED",
+					fatal: true,
+					recoverable: false
+				}
+			})]];
+		}
+		return [state, [feed({
+			type: "MANIFEST_LOADED",
+			presentation: result.presentation
+		})]];
+	}
+	if (msg.type === "SEGMENT_LOADED" && msg.trackId.startsWith(INDEX_TOKEN)) {
+		const renditionId = state.pending[msg.trackId];
+		if (renditionId === void 0 || kernel.presentation === null) return [state, []];
+		const rendition = findRendition(kernel.presentation, renditionId);
+		const pending = _objectSpread2({}, state.pending);
+		delete pending[msg.trackId];
+		const sidx = asSidx(rendition === null || rendition === void 0 ? void 0 : rendition.segments);
+		if (sidx === null) return [_objectSpread2(_objectSpread2({}, state), {}, { pending }), []];
+		const segments = sidxToSegments(new Uint8Array(msg.bytes), sidx);
+		if (segments.length === 0) return [_objectSpread2(_objectSpread2({}, state), {}, { pending }), []];
+		const merged = mergeSidx(kernel.presentation, renditionId, segments);
+		return [_objectSpread2(_objectSpread2({}, state), {}, { pending }), [feed({
+			type: "MANIFEST_LOADED",
+			presentation: merged
+		})]];
+	}
+	if (msg.type === "MANIFEST_LOADED" || msg.type === "TIME_UPDATE") {
+		const needed = neededIndexes(kernel).filter((rendition) => !Object.values(state.pending).includes(rendition.id));
+		if (needed.length === 0) return [state, []];
+		const effects = [];
+		const pending = _objectSpread2({}, state.pending);
+		for (const rendition of needed) {
+			const token = `${INDEX_TOKEN}${rendition.id}`;
+			if (pending[token] !== void 0) continue;
+			const sidx = asSidx(rendition.segments);
+			if (sidx === null) continue;
+			pending[token] = rendition.id;
+			effects.push({
+				kind: "fetch",
+				token,
+				url: sidx.url,
+				range: sidx.indexRange
+			});
+		}
+		return [_objectSpread2(_objectSpread2({}, state), {}, { pending }), effects];
+	}
+	return [state, []];
+};
+/**
+* The stage factory. `mattebox({ stages: [dashCmaf()] })` is all a consumer
+* needs for DASH-CMAF VOD, templated or on-demand.
+*/
+function dashCmaf() {
+	return {
+		name: "dash-cmaf",
+		provides: ["dash-cmaf", ...MANIFEST_TYPES],
+		install(ctx) {
+			ctx.reduce("dash", reduceDash);
+		}
+	};
+}
+//#endregion
+export { dashCmaf as default };