mattebox 0.1.0

package/dist/es2015/containers/ts-transmux/transmux.js

@@ -0,0 +1,210 @@
+import { ccTriplesFromSei } from "../sei.js";
+import { parseAdts } from "../adts.js";
+import { writeInitSegment, writeMediaSegment } from "../fmp4/writer.js";
+import { demux, unrollTimestamps } from "./demux.js";
+import { NAL_TYPE, accessUnitFromNals, nalType, splitNalUnits, spsDimensions, toAccessUnit } from "./h264.js";
+//#region src/containers/ts-transmux/transmux.ts
+/**
+* The transmux core: MPEG-TS bytes to a self-contained fragmented MP4. Each
+* call is independent and pure, so identical input plus identical
+* presentation start yields identical output, on the main thread or in the
+* Worker. A muxed segment produces one init with a video and an audio track
+* and one media fragment carrying both, so a single SourceBuffer decodes it.
+*
+* Segment timing is anchored to the playlist presentation start, not the raw
+* PES timestamps: legacy TS streams begin at an arbitrary PTS, and aligning
+* baseMediaDecodeTime to the playlist is what keeps the buffer where the
+* scheduler expects it. Sample durations still come from the PES timeline.
+*/
+const VIDEO_TIMESCALE = 9e4;
+const VIDEO_TRACK_ID = 1;
+const AUDIO_TRACK_ID = 2;
+/** Fallback duration for a lone trailing video sample: 30 fps in 90 kHz. */
+const DEFAULT_FRAME_DURATION = 3e3;
+function concat(parts) {
+	let length = 0;
+	for (const part of parts) length += part.byteLength;
+	const out = new Uint8Array(length);
+	let offset = 0;
+	for (const part of parts) {
+		out.set(part, offset);
+		offset += part.byteLength;
+	}
+	return out;
+}
+/**
+* Reframes video access units. Access units do not align with PES packet
+* boundaries in the wild: a picture's tail spills into the next PES packet,
+* whose header carries the next picture's timestamps. So the elementary stream
+* is concatenated and split into units by access-unit delimiter, and each unit
+* takes the timestamps of the PES packet its delimiter falls in. A stream with
+* no delimiters falls back to one unit per PES, which is correct when the muxer
+* did align them.
+*/
+function frameAccessUnits(packets) {
+	let total = 0;
+	for (const p of packets) total += p.data.byteLength;
+	const es = new Uint8Array(total);
+	const boundaries = [];
+	let offset = 0;
+	for (const p of packets) {
+		boundaries.push({
+			offset,
+			pts: p.pts,
+			dts: p.dts
+		});
+		es.set(p.data, offset);
+		offset += p.data.byteLength;
+	}
+	const nals = splitNalUnits(es);
+	if (!nals.some((n) => nalType(n) === NAL_TYPE.accessUnitDelimiter)) return packets.map((p) => ({
+		unit: toAccessUnit(p.data),
+		pts: p.pts,
+		dts: p.dts
+	}));
+	const framed = [];
+	let group = [];
+	let groupOffset = 0;
+	let boundaryIndex = 0;
+	const flush = () => {
+		if (group.length === 0) return;
+		while (boundaryIndex + 1 < boundaries.length && boundaries[boundaryIndex + 1].offset <= groupOffset) boundaryIndex += 1;
+		const b = boundaries[boundaryIndex];
+		framed.push({
+			unit: accessUnitFromNals(group),
+			pts: b.pts,
+			dts: b.dts
+		});
+		group = [];
+	};
+	for (const nal of nals) {
+		if (nalType(nal) === NAL_TYPE.accessUnitDelimiter && group.length > 0) flush();
+		if (group.length === 0) groupOffset = nal.byteOffset - es.byteOffset;
+		group.push(nal);
+	}
+	flush();
+	return framed;
+}
+function buildVideo(packets, presentationStart, wantCaptions) {
+	if (packets.length === 0) return null;
+	const framed = frameAccessUnits(packets);
+	const units = framed.map((f) => f.unit);
+	let sps = null;
+	let pps = null;
+	for (const unit of units) {
+		if (unit.sps !== null) sps = unit.sps;
+		if (unit.pps !== null) pps = unit.pps;
+	}
+	if (sps === null || pps === null) return null;
+	const dts = unrollTimestamps(framed.map((f) => f.dts));
+	const pts = unrollTimestamps(framed.map((f) => f.pts));
+	const base = Math.round(presentationStart * VIDEO_TIMESCALE);
+	const captions = [];
+	if (wantCaptions) {
+		var _pts$;
+		const firstPts = (_pts$ = pts[0]) !== null && _pts$ !== void 0 ? _pts$ : 0;
+		for (let i = 0; i < units.length; i += 1) {
+			const unit = units[i];
+			if (unit.sei.length === 0) continue;
+			const triples = unit.sei.flatMap((nal) => ccTriplesFromSei(nal));
+			if (triples.length === 0) continue;
+			const time = presentationStart + (pts[i] - firstPts) / VIDEO_TIMESCALE;
+			captions.push({
+				time,
+				triples
+			});
+		}
+	}
+	const samples = [];
+	for (let i = 0; i < units.length; i += 1) {
+		const duration = i + 1 < units.length ? Math.max(0, dts[i + 1] - dts[i]) : DEFAULT_FRAME_DURATION;
+		samples.push({
+			data: units[i].avcc,
+			duration: duration || DEFAULT_FRAME_DURATION,
+			cts: pts[i] - dts[i],
+			isKeyframe: units[i].isKeyframe
+		});
+	}
+	const { width, height } = spsDimensions(sps);
+	return {
+		config: {
+			id: VIDEO_TRACK_ID,
+			kind: "video",
+			timescale: VIDEO_TIMESCALE,
+			sps,
+			pps,
+			width,
+			height
+		},
+		fragment: {
+			trackId: VIDEO_TRACK_ID,
+			baseMediaDecodeTime: base,
+			samples
+		},
+		captions
+	};
+}
+function buildAudio(packets, presentationStart) {
+	if (packets.length === 0) return null;
+	const adts = parseAdts(concat(packets.map((p) => p.data)));
+	if (adts.frames.length === 0) return null;
+	const base = Math.round(presentationStart * adts.sampleRate);
+	const samples = adts.frames.map((frame) => ({
+		data: frame.data,
+		duration: 1024,
+		cts: 0,
+		isKeyframe: true
+	}));
+	return {
+		config: {
+			id: AUDIO_TRACK_ID,
+			kind: "audio",
+			timescale: adts.sampleRate,
+			audioObjectType: adts.audioObjectType,
+			samplingFrequencyIndex: adts.samplingFrequencyIndex,
+			channelConfig: adts.channelConfig
+		},
+		fragment: {
+			trackId: AUDIO_TRACK_ID,
+			baseMediaDecodeTime: base,
+			samples
+		}
+	};
+}
+function transmux(input, presentationStart = 0, wantCaptions = false) {
+	var _video$captions;
+	const streams = demux(input);
+	if (streams.notTransportStream) return {
+		bytes: null,
+		notTransportStream: true,
+		empty: false,
+		captions: []
+	};
+	const video = buildVideo(streams.video, presentationStart, wantCaptions);
+	const audio = buildAudio(streams.audio, presentationStart);
+	if (video === null && audio === null) return {
+		bytes: null,
+		notTransportStream: false,
+		empty: true,
+		captions: []
+	};
+	const configs = [];
+	const fragments = [];
+	if (video !== null) {
+		configs.push(video.config);
+		fragments.push(video.fragment);
+	}
+	if (audio !== null) {
+		configs.push(audio.config);
+		fragments.push(audio.fragment);
+	}
+	const sequenceNumber = Math.max(1, Math.round(presentationStart) + 1);
+	return {
+		bytes: concat([writeInitSegment(configs), writeMediaSegment(sequenceNumber, fragments)]),
+		notTransportStream: false,
+		empty: false,
+		captions: (_video$captions = video === null || video === void 0 ? void 0 : video.captions) !== null && _video$captions !== void 0 ? _video$captions : []
+	};
+}
+//#endregion
+export { transmux };

package/dist/es2015/containers/ts-transmux/transmux.worker.js

@@ -0,0 +1,26 @@
+import { transmux } from "./transmux.js";
+//#region src/containers/ts-transmux/transmux.worker.ts
+const scope = self;
+scope.onmessage = (event) => {
+	const { id, bytes, presentationStart, wantCaptions } = event.data;
+	const result = transmux(new Uint8Array(bytes), presentationStart, wantCaptions);
+	const out = result.bytes;
+	if (out === null) {
+		scope.postMessage({
+			id,
+			bytes: null,
+			notTransportStream: result.notTransportStream,
+			captions: []
+		}, []);
+		return;
+	}
+	const buffer = new ArrayBuffer(out.byteLength);
+	new Uint8Array(buffer).set(out);
+	scope.postMessage({
+		id,
+		bytes: buffer,
+		notTransportStream: false,
+		captions: result.captions
+	}, [buffer]);
+};
+//#endregion

package/dist/es2015/index.js

@@ -0,0 +1,356 @@
+import { exportTrace, replay } from "./kernel/trace.js";
+import { createBus } from "./kernel/bus.js";
+import { createEffectRunner } from "./kernel/effects.js";
+import { normalizeMimeType } from "./kernel/mime.js";
+import _objectSpread2 from "./_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+import { canSwitchTo, createArbiter } from "./kernel/rendition-select.js";
+import { createMseSink } from "./kernel/sinks/mse-sink.js";
+import { createReducer, initialState, resolveConfig } from "./kernel/reducer.js";
+import { createLifecycle } from "./kernel/lifecycle.js";
+import { compose } from "./kernel/loader.js";
+import _asyncToGenerator from "./_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/asyncToGenerator.js";
+import { createMseController } from "./kernel/mse.js";
+import { createTrackRegistry } from "./kernel/track-registry.js";
+import { createTransport } from "./kernel/transport.js";
+//#region src/index.ts
+/**
+* Mattebox: a modular adaptive-streaming engine for HLS and DASH.
+* The public entry: the mattebox() factory composes the kernel with the
+* caller's stages; mattebox.from() finds an engine from its element. One
+* name for both, so the ESM import and the CDN global read the same.
+*/
+const registry = /* @__PURE__ */ new WeakMap();
+/** Creates an engine. The element is supplied later via `attach`. */
+function mattebox(options) {
+	var _options$stages, _options$config$media, _options$config, _options$transport, _options$transport2, _options$transport$re, _options$transport3, _options$transport$re2, _options$transport4;
+	const composition = compose((_options$stages = options.stages) !== null && _options$stages !== void 0 ? _options$stages : []);
+	const config = _objectSpread2(_objectSpread2({}, options.config), {}, { mediaTimeNormalized: (_options$config$media = (_options$config = options.config) === null || _options$config === void 0 ? void 0 : _options$config.mediaTimeNormalized) !== null && _options$config$media !== void 0 ? _options$config$media : composition.capabilities.includes("media-time-normalized") });
+	const cfg = resolveConfig(config);
+	const bus = createBus({
+		reducer: createReducer([], config),
+		initial: initialState(config),
+		traceCapacity: cfg.traceCapacity
+	});
+	const runner = createEffectRunner({ onEvent: (event, payload) => bus.emitEvent(event, payload) });
+	bus.setEffectSink((effects) => runner.run(effects));
+	const mediaTransforms = composition.capabilities.includes("media-transform");
+	const mse = createMseController(_objectSpread2({
+		absorb: (fact) => bus.absorb(fact),
+		backBufferSeconds: cfg.backBufferSeconds,
+		inferType: (bytes) => {
+			var _hooks$typeProbe, _hooks$typeProbe2;
+			return (_hooks$typeProbe = (_hooks$typeProbe2 = hooks.typeProbe) === null || _hooks$typeProbe2 === void 0 ? void 0 : _hooks$typeProbe2.call(hooks, bytes)) !== null && _hooks$typeProbe !== void 0 ? _hooks$typeProbe : null;
+		}
+	}, mediaTransforms ? { appendTransform: function() {
+		var _ref = _asyncToGenerator(function* (data, meta) {
+			let out = data;
+			for (const step of bus.transforms()) out = new Uint8Array(yield step.transform(out, meta));
+			return out;
+		});
+		return function appendTransform(_x, _x2) {
+			return _ref.apply(this, arguments);
+		};
+	}() } : {}));
+	mse.registerHandlers(runner);
+	const transport = createTransport(_objectSpread2(_objectSpread2({
+		absorb: (fact) => bus.absorb(fact),
+		inflight: (token) => bus.getState().scheduling.inflight.get(token),
+		acceptManifestType: (contentType) => {
+			const type = normalizeMimeType(contentType);
+			return !(type.startsWith("audio/") || type.startsWith("video/")) || accepts(type);
+		}
+	}, ((_options$transport = options.transport) === null || _options$transport === void 0 ? void 0 : _options$transport.retry) !== void 0 ? { retry: options.transport.retry } : {}), ((_options$transport2 = options.transport) === null || _options$transport2 === void 0 ? void 0 : _options$transport2.fetchImpl) !== void 0 ? { fetchImpl: options.transport.fetchImpl } : {}));
+	transport.registerHandlers(runner);
+	for (const hook of (_options$transport$re = (_options$transport3 = options.transport) === null || _options$transport3 === void 0 ? void 0 : _options$transport3.requestHooks) !== null && _options$transport$re !== void 0 ? _options$transport$re : []) transport.addRequestHook(hook);
+	for (const hook of (_options$transport$re2 = (_options$transport4 = options.transport) === null || _options$transport4 === void 0 ? void 0 : _options$transport4.responseHooks) !== null && _options$transport$re2 !== void 0 ? _options$transport$re2 : []) transport.addResponseHook(hook);
+	runner.register("emit", (effect) => {
+		bus.emitEvent(effect.event, effect.payload);
+	});
+	runner.register("schedule", (effect) => {
+		const id = setTimeout(() => {
+			runner.forget(effect.token);
+			const msg = effect.then.type === "TICK" ? _objectSpread2(_objectSpread2({}, effect.then), {}, { wallClock: Date.now() / 1e3 }) : effect.then;
+			bus.route(msg);
+		}, effect.delayMs);
+		return () => clearTimeout(id);
+	});
+	runner.register("seekElement", (effect) => {
+		const el = lifecycle.element();
+		if (el !== null) el.currentTime = effect.to;
+	});
+	const cueSinks = /* @__PURE__ */ new Map();
+	function cueSinkFor(contentType) {
+		const existing = cueSinks.get(contentType);
+		if (existing !== void 0) return existing;
+		const el = lifecycle.element();
+		if (el === null) return null;
+		const factory = bus.sinkFor(contentType);
+		if (factory === void 0) return null;
+		const sink = factory({ element: el });
+		cueSinks.set(contentType, sink);
+		return sink;
+	}
+	function contentTypeOfTrack(trackId) {
+		var _bus$getState$present, _bus$getState$present2;
+		for (const period of (_bus$getState$present = (_bus$getState$present2 = bus.getState().presentation) === null || _bus$getState$present2 === void 0 ? void 0 : _bus$getState$present2.periods) !== null && _bus$getState$present !== void 0 ? _bus$getState$present : []) for (const track of period.tracks) if (track.id === trackId) return track.contentType;
+		return null;
+	}
+	runner.register("emitCues", (effect) => {
+		var _cueSinkFor;
+		const contentType = contentTypeOfTrack(effect.trackId);
+		if (contentType !== "text" && contentType !== "metadata") return void 0;
+		(_cueSinkFor = cueSinkFor(contentType)) === null || _cueSinkFor === void 0 || _cueSinkFor.handleEmitCues(effect.trackId, effect.cues);
+	});
+	let deliverChain = Promise.resolve();
+	runner.register("deliver", (effect) => {
+		const sink = cueSinkFor(effect.contentType);
+		if (sink === null) return void 0;
+		deliverChain = deliverChain.then(_asyncToGenerator(function* () {
+			let data = new Uint8Array(effect.data);
+			for (const step of bus.transforms()) data = new Uint8Array(yield step.transform(data, effect.meta));
+			const bytes = data.byteOffset === 0 && data.byteLength === data.buffer.byteLength ? data.buffer : data.slice().buffer;
+			const produced = sink.accept(effect.trackId, bytes, effect.meta);
+			if (produced.length > 0) runner.run(produced);
+		})).catch(() => {
+			bus.emitEvent("error", {
+				category: "media",
+				code: "MEDIA_CONTAINER_INVALID",
+				fatal: false,
+				recoverable: false,
+				trackId: effect.trackId
+			});
+		});
+	});
+	runner.register("clearCues", (effect) => {
+		for (const sink of cueSinks.values()) sink.clear(effect.trackId, effect.start, effect.end);
+	});
+	const sinkInstances = /* @__PURE__ */ new Map();
+	for (const contentType of ["video", "audio"]) {
+		const sink = createMseSink(contentType, { buffered: (sbId) => mse.buffered(sbId) });
+		sinkInstances.set(contentType, sink);
+		bus.registerSink(contentType, () => sink);
+	}
+	for (const capability of composition.capabilities) bus.registerCapability(capability);
+	const tracks = createTrackRegistry({
+		getState: () => bus.getState(),
+		dispatch: (cmd) => bus.dispatch(cmd),
+		emitEvent: (event, payload) => bus.emitEvent(event, payload),
+		hasSink: (contentType) => bus.sinkFor(contentType) !== void 0
+	});
+	const arbiter = createArbiter();
+	const hooks = { manifestTypes: composition.manifestTypes };
+	let lastError = null;
+	function accepts(mimeType) {
+		return composition.manifestTypes.has(normalizeMimeType(mimeType));
+	}
+	function activeVideoRenditions() {
+		const state = bus.getState();
+		if (state.presentation === null) return [];
+		const activeId = state.tracks.active.get("video");
+		for (const period of state.presentation.periods) for (const track of period.tracks) {
+			if (track.contentType !== "video") continue;
+			if (activeId === void 0 || track.id === activeId) return track.renditions;
+		}
+		return [];
+	}
+	function arbitrated() {
+		var _state$presentation$c, _state$presentation;
+		const state = bus.getState();
+		return arbiter.run({
+			renditions: activeVideoRenditions(),
+			constraints: state.quality.constraints,
+			pinned: state.quality.pinned,
+			current: state.quality.active,
+			couplings: (_state$presentation$c = (_state$presentation = state.presentation) === null || _state$presentation === void 0 ? void 0 : _state$presentation.couplings) !== null && _state$presentation$c !== void 0 ? _state$presentation$c : [],
+			activeTracks: state.tracks.active,
+			availableGroups: (() => {
+				var _state$presentation$p, _state$presentation2;
+				const groups = /* @__PURE__ */ new Set();
+				for (const period of (_state$presentation$p = (_state$presentation2 = state.presentation) === null || _state$presentation2 === void 0 ? void 0 : _state$presentation2.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(":");
+					groups.add(`${track.contentType}:${colon === -1 ? track.id : track.id.slice(0, colon)}`);
+				}
+				return groups;
+			})(),
+			telemetry: {
+				throughputEwma: state.stats.throughputEwma,
+				throughputFastEwma: state.stats.throughputFastEwma,
+				current: state.quality.active,
+				currentTime: state.playback.currentTime
+			}
+		}, state.quality.version);
+	}
+	const facadeTarget = {};
+	const MEDIA_ERR = [
+		"",
+		"MEDIA_ERR_ABORTED",
+		"MEDIA_ERR_NETWORK",
+		"MEDIA_ERR_DECODE",
+		"MEDIA_ERR_SRC_NOT_SUPPORTED"
+	];
+	function onMediaError(el) {
+		var _el$error$code, _el$error, _MEDIA_ERR$code, _el$error$message, _el$error2;
+		const code = (_el$error$code = (_el$error = el.error) === null || _el$error === void 0 ? void 0 : _el$error.code) !== null && _el$error$code !== void 0 ? _el$error$code : 0;
+		if (code === 1 || lastError !== null) return;
+		bus.emitEvent("error", {
+			category: "media",
+			code: code === 4 ? "MEDIA_CODEC_UNSUPPORTED" : "MEDIA_DECODE_ERROR",
+			fatal: true,
+			recoverable: false,
+			context: {
+				mediaError: (_MEDIA_ERR$code = MEDIA_ERR[code]) !== null && _MEDIA_ERR$code !== void 0 ? _MEDIA_ERR$code : code,
+				message: (_el$error$message = (_el$error2 = el.error) === null || _el$error2 === void 0 ? void 0 : _el$error2.message) !== null && _el$error$message !== void 0 ? _el$error$message : ""
+			}
+		});
+	}
+	const base = {
+		get media() {
+			return lifecycle.element();
+		},
+		quality: {
+			get renditions() {
+				return activeVideoRenditions();
+			},
+			get allowed() {
+				const ids = arbitrated().result.allowed;
+				return activeVideoRenditions().filter((r) => ids.includes(r.id));
+			},
+			get active() {
+				var _activeVideoRendition;
+				const id = bus.getState().quality.active;
+				return (_activeVideoRendition = activeVideoRenditions().find((r) => r.id === id)) !== null && _activeVideoRendition !== void 0 ? _activeVideoRendition : null;
+			},
+			get playing() {
+				var _activeVideoRendition2;
+				const state = bus.getState();
+				const id = arbiter.playingAt(state.quality.appendLog, state.playback.currentTime);
+				return (_activeVideoRendition2 = activeVideoRenditions().find((r) => r.id === id)) !== null && _activeVideoRendition2 !== void 0 ? _activeVideoRendition2 : null;
+			},
+			get pinned() {
+				return bus.getState().quality.pinned;
+			},
+			get constraints() {
+				return bus.getState().quality.constraints;
+			},
+			constrain(source, constraint) {
+				bus.dispatch({
+					type: "CONSTRAIN",
+					source,
+					constraint
+				});
+			},
+			release(source) {
+				bus.dispatch({
+					type: "RELEASE_CONSTRAINT",
+					source
+				});
+			},
+			pin(renditionId, pinOptions) {
+				var _pinOptions$apply;
+				bus.dispatch({
+					type: "PIN_RENDITION",
+					renditionId,
+					apply: (_pinOptions$apply = pinOptions === null || pinOptions === void 0 ? void 0 : pinOptions.apply) !== null && _pinOptions$apply !== void 0 ? _pinOptions$apply : "soon"
+				});
+			},
+			auto() {
+				bus.dispatch({ type: "RELEASE_PIN" });
+			}
+		},
+		tracks,
+		stats: {
+			get throughput() {
+				return bus.getState().stats.throughputEwma;
+			},
+			trace() {
+				return bus.trace();
+			},
+			snapshot() {
+				return bus.getState();
+			}
+		},
+		get error() {
+			return lastError;
+		},
+		attach(el) {
+			return _asyncToGenerator(function* () {
+				lifecycle.attach(el);
+			})();
+		},
+		detach() {
+			return _asyncToGenerator(function* () {
+				lifecycle.detach();
+			})();
+		},
+		load(url, loadOptions) {
+			let absolute = url;
+			try {
+				var _globalThis$location;
+				absolute = new URL(url, (_globalThis$location = globalThis.location) === null || _globalThis$location === void 0 ? void 0 : _globalThis$location.href).href;
+			} catch (_unused) {}
+			lastError = null;
+			bus.dispatch(_objectSpread2({
+				type: "LOAD",
+				url: absolute
+			}, (loadOptions === null || loadOptions === void 0 ? void 0 : loadOptions.mimeType) !== void 0 ? { mimeType: loadOptions.mimeType } : {}));
+		},
+		unload() {
+			bus.dispatch({ type: "UNLOAD" });
+		},
+		dispatch(cmd) {
+			bus.dispatch(cmd);
+		},
+		capabilities() {
+			return composition.capabilities.map((capability) => typeof capability === "string" ? capability : `${capability.contentType}:${capability.mimeType}`);
+		},
+		accepts,
+		on(event, fn) {
+			return bus.on(event, fn);
+		}
+	};
+	bus.on("error", (payload) => {
+		const summary = payload;
+		if (summary.fatal === true) {
+			var _summary$category, _summary$code, _summary$recoverable;
+			lastError = {
+				category: (_summary$category = summary.category) !== null && _summary$category !== void 0 ? _summary$category : "internal",
+				code: (_summary$code = summary.code) !== null && _summary$code !== void 0 ? _summary$code : "INTERNAL_ASSERTION",
+				fatal: true,
+				recoverable: (_summary$recoverable = summary.recoverable) !== null && _summary$recoverable !== void 0 ? _summary$recoverable : false,
+				trace: bus.trace()
+			};
+		}
+	});
+	Object.defineProperties(facadeTarget, Object.getOwnPropertyDescriptors(base));
+	const engine = facadeTarget;
+	const lifecycle = createLifecycle({
+		bus,
+		mse,
+		composition,
+		facade: facadeTarget,
+		config,
+		hooks,
+		addRequestHook: (hook) => transport.addRequestHook(hook),
+		request: (url, init) => transport.request(url, init),
+		register: (el) => registry.set(el, engine),
+		unregister: (el) => {
+			registry.delete(el);
+			runner.cancelAll();
+			for (const sink of cueSinks.values()) sink.dispose();
+			cueSinks.clear();
+		},
+		onMediaError
+	});
+	return engine;
+}
+/**
+* Static lookup from an element to its engine, backed by a WeakMap. The
+* element itself carries no added surface and garbage-collects normally.
+*/
+mattebox.from = (el) => {
+	var _registry$get;
+	return (_registry$get = registry.get(el)) !== null && _registry$get !== void 0 ? _registry$get : null;
+};
+//#endregion
+export { canSwitchTo, createReducer, exportTrace, initialState, mattebox, replay, resolveConfig };