mattebox 0.1.0

package/dist/es2015/kernel/loader.js

@@ -0,0 +1,108 @@
+import { isManifestType, normalizeMimeType } from "./mime.js";
+//#region src/kernel/loader.ts
+/**
+* Names the kernel itself provides. A stage's `requires` naming one of
+* these is always satisfied; everything else must match a composed stage's
+* name or a capability it provides.
+*/
+const KERNEL_PROVIDES = /* @__PURE__ */ new Set([
+	"bus",
+	"reducer",
+	"effects",
+	"trace",
+	"mse",
+	"append-queue",
+	"evictor",
+	"scheduler",
+	"transport",
+	"timeline",
+	"track-registry",
+	"rendition-select"
+]);
+function capabilityKey(capability) {
+	if (typeof capability === "string") return capability;
+	return `${capability.contentType}:${capability.mimeType}`;
+}
+/**
+* Capabilities that name a shared trait rather than a singleton service, so
+* more than one stage may provide them without conflict. `media-transform`
+* is the marker every byte-transform container (ts-transmux, packed-audio)
+* carries so the composition root knows to route media appends through the
+* transform pipeline; several such containers coexist by design.
+*/
+const SHARED_CAPABILITIES = /* @__PURE__ */ new Set(["media-transform", "media-time-normalized"]);
+/** Validates and orders a stage set. Throws on any composition error. */
+function compose(stages) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const stage of stages) {
+		if (byName.has(stage.name)) throw new Error(`duplicate stage name '${stage.name}'`);
+		byName.set(stage.name, stage);
+	}
+	const capabilityOwners = /* @__PURE__ */ new Map();
+	const capabilities = [];
+	for (const stage of stages) {
+		var _stage$provides;
+		for (const capability of (_stage$provides = stage.provides) !== null && _stage$provides !== void 0 ? _stage$provides : []) {
+			const key = capabilityKey(capability);
+			if (SHARED_CAPABILITIES.has(key)) {
+				if (!capabilityOwners.has(key)) {
+					capabilityOwners.set(key, stage.name);
+					capabilities.push(capability);
+				}
+				continue;
+			}
+			const owner = capabilityOwners.get(key);
+			if (owner !== void 0 && owner !== stage.name) throw new Error(`'${owner}' and '${stage.name}' both provide '${key}'`);
+			if (owner === void 0) {
+				capabilityOwners.set(key, stage.name);
+				capabilities.push(capability);
+			}
+		}
+	}
+	function providerOf(requirement) {
+		var _byName$get;
+		if (KERNEL_PROVIDES.has(requirement)) return "kernel";
+		const direct = byName.get(requirement);
+		if (direct !== void 0) return direct;
+		const owner = capabilityOwners.get(requirement);
+		if (owner !== void 0) return (_byName$get = byName.get(owner)) !== null && _byName$get !== void 0 ? _byName$get : null;
+		return null;
+	}
+	const order = [];
+	const state = /* @__PURE__ */ new Map();
+	function visit(stage, path) {
+		var _stage$requires;
+		const mark = state.get(stage.name);
+		if (mark === "done") return;
+		if (mark === "visiting") throw new Error(`circular requires: ${[...path, stage.name].join(" -> ")}`);
+		state.set(stage.name, "visiting");
+		for (const requirement of (_stage$requires = stage.requires) !== null && _stage$requires !== void 0 ? _stage$requires : []) {
+			const alternatives = Array.isArray(requirement) ? requirement : [requirement];
+			let resolved = null;
+			for (const alternative of alternatives) {
+				const provider = providerOf(alternative);
+				if (provider !== null) {
+					resolved = provider;
+					break;
+				}
+			}
+			if (resolved === null) {
+				const names = alternatives.map((a) => `'${a}'`).join(" or ");
+				throw new Error(`'${stage.name}' requires ${names}, which nothing provides`);
+			}
+			if (resolved !== "kernel") visit(resolved, [...path, stage.name]);
+		}
+		state.set(stage.name, "done");
+		order.push(stage);
+	}
+	for (const stage of stages) visit(stage, []);
+	const manifestTypes = /* @__PURE__ */ new Set();
+	for (const capability of capabilities) if (typeof capability === "string" && isManifestType(capability)) manifestTypes.add(normalizeMimeType(capability));
+	return {
+		order,
+		capabilities,
+		manifestTypes
+	};
+}
+//#endregion
+export { KERNEL_PROVIDES, compose };

package/dist/es2015/kernel/mime.js

@@ -0,0 +1,20 @@
+//#region src/kernel/mime.ts
+/**
+* MIME type normalization, shared by the composition root, the reducer, and
+* the protocol adapters. A caller's `mimeType` hint and a server's
+* Content-Type header both arrive with arbitrary case and optional
+* parameters (`; charset=utf-8`); every comparison in the engine runs on the
+* normalized form so `Application/X-MPEGURL` and `application/x-mpegurl`
+* name the same format.
+*/
+/** Lowercases a MIME type and drops its parameters. Whitespace is trimmed. */
+function normalizeMimeType(value) {
+	const semicolon = value.indexOf(";");
+	return (semicolon === -1 ? value : value.slice(0, semicolon)).trim().toLowerCase();
+}
+/** True for a capability string that names a manifest format: a MIME type, the only capability strings containing '/'. */
+function isManifestType(capability) {
+	return capability.includes("/");
+}
+//#endregion
+export { isManifestType, normalizeMimeType };

package/dist/es2015/kernel/mse.js

@@ -0,0 +1,426 @@
+import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+import { createAppendQueue } from "./append-queue.js";
+import { createEvictor } from "./evictor.js";
+import _asyncToGenerator from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/asyncToGenerator.js";
+//#region src/kernel/mse.ts
+function managedMediaSource() {
+	return globalThis.ManagedMediaSource;
+}
+function appendMeta(sbId, start, renditionId, seq) {
+	return {
+		trackId: sbId,
+		renditionId,
+		contentType: sbId === "sb:audio" ? "audio" : "video",
+		seq,
+		start,
+		duration: 0,
+		isInit: seq < 0
+	};
+}
+/** Whether a SourceBuffer type names its codecs; a bare `video/mp4` does not. */
+function declaresCodecs(type) {
+	return /codecs\s*=/i.test(type);
+}
+function createMseController(options) {
+	const { absorb } = options;
+	const evictor = createEvictor(_objectSpread2(_objectSpread2({}, options.backBufferSeconds !== void 0 ? { backBufferSeconds: options.backBufferSeconds } : {}), options.maxEvictionPasses !== void 0 ? { maxPasses: options.maxEvictionPasses } : {}));
+	let element = null;
+	let mediaSource = null;
+	let managed = false;
+	const buffers = /* @__PURE__ */ new Map();
+	const appendChains = /* @__PURE__ */ new Map();
+	/** Buffers requested without codecs, waiting for their first bytes to be typed. */
+	const deferred = /* @__PURE__ */ new Map();
+	let objectUrl = null;
+	let liveObjectUrls = 0;
+	let pendingEndOfStream = null;
+	let pendingDuration = null;
+	let pendingLiveRange = null;
+	let unobserveManaged = null;
+	const tracked = [];
+	function listen(target, type, fn) {
+		target.addEventListener(type, fn);
+		tracked.push({
+			target,
+			type,
+			fn
+		});
+	}
+	function unlistenAll() {
+		for (const { target, type, fn } of tracked) target.removeEventListener(type, fn);
+		tracked.length = 0;
+	}
+	function currentTime() {
+		var _element$currentTime;
+		return (_element$currentTime = element === null || element === void 0 ? void 0 : element.currentTime) !== null && _element$currentTime !== void 0 ? _element$currentTime : 0;
+	}
+	function readyState() {
+		var _mediaSource$readySta;
+		return (_mediaSource$readySta = mediaSource === null || mediaSource === void 0 ? void 0 : mediaSource.readyState) !== null && _mediaSource$readySta !== void 0 ? _mediaSource$readySta : "detached";
+	}
+	function allIdle() {
+		for (const { queue } of buffers.values()) if (!queue.idle()) return false;
+		return true;
+	}
+	/** endOfStream and duration assignment both throw while any buffer updates; run them at quiet points. */
+	function runDeferredGlobalOps() {
+		if (mediaSource === null || mediaSource.readyState !== "open" || !allIdle()) return;
+		if (pendingDuration !== null) {
+			const seconds = pendingDuration;
+			pendingDuration = null;
+			try {
+				mediaSource.duration = seconds;
+			} catch (_unused) {}
+		}
+		if (pendingLiveRange !== null) {
+			const { start, end } = pendingLiveRange;
+			pendingLiveRange = null;
+			const source = mediaSource;
+			if (typeof source.setLiveSeekableRange === "function" && end > start && start >= 0) try {
+				source.setLiveSeekableRange(start, end);
+			} catch (_unused2) {}
+		}
+		if (pendingEndOfStream !== null) {
+			const reason = pendingEndOfStream;
+			pendingEndOfStream = null;
+			try {
+				if (reason === "none") mediaSource.endOfStream();
+				else mediaSource.endOfStream(reason);
+			} catch (_unused3) {}
+		}
+	}
+	function onQuota(sbId, attempt) {
+		absorb({
+			type: "QUOTA_EXCEEDED",
+			sbId
+		});
+		const entry = buffers.get(sbId);
+		if (entry === void 0) return;
+		let effective = attempt;
+		let plan = evictor.plan(entry.sb, currentTime(), effective);
+		while (plan !== null && plan.length === 0) {
+			effective += 1;
+			plan = evictor.plan(entry.sb, currentTime(), effective);
+		}
+		if (plan === null) {
+			entry.queue.abort();
+			absorb({
+				type: "SOURCEBUFFER_ERROR",
+				sbId,
+				error: {
+					category: "media",
+					code: "MEDIA_QUOTA_EXCEEDED",
+					fatal: true,
+					recoverable: false,
+					context: { attempts: attempt }
+				}
+			});
+			return;
+		}
+		for (let i = plan.length - 1; i >= 0; i -= 1) {
+			const range = plan[i];
+			if (range === void 0) continue;
+			entry.queue.enqueueFront({
+				op: "remove",
+				start: range.start,
+				end: range.end
+			});
+		}
+	}
+	function createQueue(sbId, sb) {
+		return createAppendQueue(sbId, sb, {
+			absorb,
+			onQuota,
+			onIdle: () => runDeferredGlobalOps()
+		});
+	}
+	function trimAllBackBuffers() {
+		for (const [, entry] of buffers) {
+			const plan = evictor.plan(entry.sb, currentTime(), 1);
+			if (plan === null) continue;
+			for (const range of plan) entry.queue.enqueue({
+				op: "remove",
+				start: range.start,
+				end: range.end
+			});
+		}
+	}
+	function attach(el) {
+		if (element !== null) throw Object.assign(/* @__PURE__ */ new Error("already attached"), {
+			category: "config",
+			code: "CONFIG_ELEMENT_OCCUPIED"
+		});
+		if (el.getAttribute("src") !== null || el.querySelector("source") !== null) throw Object.assign(/* @__PURE__ */ new Error("element already has a source"), {
+			category: "config",
+			code: "CONFIG_ELEMENT_OCCUPIED"
+		});
+		el.removeAttribute("src");
+		while (el.firstChild) el.removeChild(el.firstChild);
+		el.load();
+		const Managed = options.preferManaged === false ? void 0 : managedMediaSource();
+		managed = Managed !== void 0;
+		const ms = Managed !== void 0 ? new Managed() : new MediaSource();
+		element = el;
+		mediaSource = ms;
+		listen(ms, "sourceopen", () => {
+			if (objectUrl !== null) {
+				URL.revokeObjectURL(objectUrl);
+				objectUrl = null;
+				liveObjectUrls -= 1;
+			}
+			absorb({ type: "MEDIASOURCE_OPEN" });
+		});
+		listen(ms, "sourceclose", () => {
+			absorb({ type: "MEDIASOURCE_CLOSED" });
+		});
+		if (managed) {
+			unobserveManaged = evictor.observeManaged(ms, trimAllBackBuffers);
+			el.disableRemotePlayback = true;
+		}
+		let useSrcObject = options.attachMode !== "object-url" && "srcObject" in el;
+		if (useSrcObject) try {
+			el.srcObject = ms;
+			useSrcObject = el.srcObject === ms;
+		} catch (_unused4) {
+			useSrcObject = false;
+		}
+		if (!useSrcObject) {
+			objectUrl = URL.createObjectURL(ms);
+			liveObjectUrls += 1;
+			el.src = objectUrl;
+		}
+		absorb({
+			type: "ELEMENT_ATTACHED",
+			element: el
+		});
+	}
+	function detach() {
+		if (element === null && mediaSource === null) return;
+		const el = element;
+		const ms = mediaSource;
+		for (const [, entry] of buffers) {
+			if (ms !== null && ms.readyState === "open") entry.queue.abort();
+			entry.queue.destroy();
+			if (ms !== null && ms.readyState === "open") try {
+				ms.removeSourceBuffer(entry.sb);
+			} catch (_unused5) {}
+		}
+		buffers.clear();
+		appendChains.clear();
+		deferred.clear();
+		if (ms !== null && ms.readyState === "open") try {
+			ms.endOfStream();
+		} catch (_unused6) {}
+		unobserveManaged === null || unobserveManaged === void 0 || unobserveManaged();
+		unobserveManaged = null;
+		unlistenAll();
+		if (el !== null) {
+			if ("srcObject" in el) el.srcObject = null;
+			el.removeAttribute("src");
+			if (objectUrl !== null) {
+				URL.revokeObjectURL(objectUrl);
+				objectUrl = null;
+				liveObjectUrls -= 1;
+			}
+			el.load();
+		}
+		element = null;
+		mediaSource = null;
+		managed = false;
+		pendingEndOfStream = null;
+		pendingDuration = null;
+		pendingLiveRange = null;
+	}
+	/** Adds the SourceBuffer, reporting creation or a clean codec error. */
+	function open(sbId, type) {
+		const ms = mediaSource;
+		if (ms === null) return false;
+		try {
+			const sb = ms.addSourceBuffer(type);
+			buffers.set(sbId, {
+				sb,
+				queue: createQueue(sbId, sb)
+			});
+			absorb({
+				type: "SOURCEBUFFER_CREATED",
+				sbId,
+				codecs: type
+			});
+			return true;
+		} catch (err) {
+			absorb({
+				type: "SOURCEBUFFER_ERROR",
+				sbId,
+				error: {
+					category: "media",
+					code: "MEDIA_CODEC_UNSUPPORTED",
+					fatal: false,
+					recoverable: false,
+					context: {
+						codecs: type,
+						message: String(err)
+					}
+				}
+			});
+			return false;
+		}
+	}
+	/**
+	* Hands bytes to the buffer's queue, first opening a deferred buffer with
+	* the type the probe reads from them, or with the bare type when the probe
+	* reads nothing, which is what an unprobed composition does from the
+	* start. Bytes for a buffer that does not exist and is not deferred are
+	* dropped, as before.
+	*/
+	function enqueueAppend(sbId, data) {
+		var _buffers$get;
+		const bare = deferred.get(sbId);
+		if (bare !== void 0 && !buffers.has(sbId)) {
+			var _options$inferType, _options$inferType2;
+			deferred.delete(sbId);
+			if (!open(sbId, (_options$inferType = (_options$inferType2 = options.inferType) === null || _options$inferType2 === void 0 ? void 0 : _options$inferType2.call(options, new Uint8Array(data))) !== null && _options$inferType !== void 0 ? _options$inferType : bare)) return;
+		}
+		(_buffers$get = buffers.get(sbId)) === null || _buffers$get === void 0 || _buffers$get.queue.enqueue({
+			op: "append",
+			data
+		});
+	}
+	function registerHandlers(runner) {
+		runner.register("createSourceBuffer", (effect) => {
+			const ms = mediaSource;
+			if (ms === null || ms.readyState !== "open") {
+				absorb({
+					type: "SOURCEBUFFER_ERROR",
+					sbId: effect.sbId,
+					error: {
+						category: "media",
+						code: "MEDIA_SOURCE_CLOSED",
+						fatal: false,
+						recoverable: true,
+						context: { readyState: readyState() }
+					}
+				});
+				return;
+			}
+			if (buffers.has(effect.sbId) || deferred.has(effect.sbId)) return;
+			if (options.inferType !== void 0 && !declaresCodecs(effect.codecs)) {
+				deferred.set(effect.sbId, effect.codecs);
+				return;
+			}
+			open(effect.sbId, effect.codecs);
+		});
+		runner.register("append", (effect) => {
+			var _appendChains$get;
+			const { appendTransform } = options;
+			if (appendTransform === void 0) {
+				enqueueAppend(effect.sbId, effect.data);
+				return;
+			}
+			const next = ((_appendChains$get = appendChains.get(effect.sbId)) !== null && _appendChains$get !== void 0 ? _appendChains$get : Promise.resolve()).then(_asyncToGenerator(function* () {
+				var _effect$start, _effect$renditionId, _effect$seq;
+				const out = yield appendTransform(new Uint8Array(effect.data), appendMeta(effect.sbId, (_effect$start = effect.start) !== null && _effect$start !== void 0 ? _effect$start : 0, (_effect$renditionId = effect.renditionId) !== null && _effect$renditionId !== void 0 ? _effect$renditionId : "", (_effect$seq = effect.seq) !== null && _effect$seq !== void 0 ? _effect$seq : 0));
+				const bytes = out.byteOffset === 0 && out.byteLength === out.buffer.byteLength ? out.buffer : out.slice().buffer;
+				enqueueAppend(effect.sbId, bytes);
+			})).catch((err) => {
+				absorb({
+					type: "SOURCEBUFFER_ERROR",
+					sbId: effect.sbId,
+					error: {
+						category: "media",
+						code: "MEDIA_CONTAINER_INVALID",
+						fatal: false,
+						recoverable: false,
+						context: { message: String(err) }
+					}
+				});
+			});
+			appendChains.set(effect.sbId, next);
+		});
+		function sequenced(sbId, op) {
+			var _appendChains$get2;
+			if (options.appendTransform === void 0) {
+				op();
+				return;
+			}
+			const prior = (_appendChains$get2 = appendChains.get(sbId)) !== null && _appendChains$get2 !== void 0 ? _appendChains$get2 : Promise.resolve();
+			appendChains.set(sbId, prior.then(op).catch(() => void 0));
+		}
+		runner.register("remove", (effect) => {
+			sequenced(effect.sbId, () => {
+				const entry = buffers.get(effect.sbId);
+				if (entry === void 0) return;
+				const clamped = evictor.clamp(entry.sb, effect.start, effect.end, currentTime());
+				if (clamped === null) return;
+				entry.queue.enqueue({
+					op: "remove",
+					start: clamped.start,
+					end: clamped.end
+				});
+			});
+		});
+		runner.register("changeType", (effect) => {
+			sequenced(effect.sbId, () => {
+				var _buffers$get2;
+				(_buffers$get2 = buffers.get(effect.sbId)) === null || _buffers$get2 === void 0 || _buffers$get2.queue.enqueue({
+					op: "changeType",
+					type: effect.codecs
+				});
+			});
+		});
+		runner.register("setTimestampOffset", (effect) => {
+			sequenced(effect.sbId, () => {
+				var _buffers$get3;
+				(_buffers$get3 = buffers.get(effect.sbId)) === null || _buffers$get3 === void 0 || _buffers$get3.queue.enqueue({
+					op: "setTimestampOffset",
+					offset: effect.offset
+				});
+			});
+		});
+		runner.register("endOfStream", (effect) => {
+			var _effect$reason;
+			if (mediaSource === null || mediaSource.readyState !== "open") return;
+			pendingEndOfStream = (_effect$reason = effect.reason) !== null && _effect$reason !== void 0 ? _effect$reason : "none";
+			runDeferredGlobalOps();
+		});
+		runner.register("setDuration", (effect) => {
+			if (mediaSource === null || mediaSource.readyState !== "open") return void 0;
+			pendingDuration = effect.seconds;
+			runDeferredGlobalOps();
+		});
+		runner.register("setLiveSeekableRange", (effect) => {
+			if (mediaSource === null || mediaSource.readyState !== "open") return void 0;
+			pendingLiveRange = {
+				start: effect.start,
+				end: effect.end
+			};
+			runDeferredGlobalOps();
+		});
+	}
+	return {
+		attach,
+		detach,
+		registerHandlers,
+		isManaged: () => managed,
+		readyState,
+		buffered(sbId) {
+			const entry = buffers.get(sbId);
+			if (entry === void 0) return [];
+			const out = [];
+			const { buffered } = entry.sb;
+			for (let i = 0; i < buffered.length; i += 1) out.push({
+				start: buffered.start(i),
+				end: buffered.end(i)
+			});
+			return out;
+		},
+		diagnostics() {
+			return {
+				liveObjectUrls,
+				liveListeners: tracked.length,
+				sourceBuffers: buffers.size
+			};
+		}
+	};
+}
+//#endregion
+export { createMseController };