@bubo-squared/gyroview 0.2.0 → 0.3.1

package/dist/packages/adapters/fetch/src/HttpResource.js

@@ -0,0 +1,192 @@
+import { GyroViewError, isAbortError } from "../../../core/src/shared/errors/GyroViewError.js";
+import "../../../core/src/index.js";
+import { contentRangeOf } from "./contentRange.js";
+import { isPassing, passing, passingIfUnreachable } from "./passingFailures.js";
+import { EXPOSED_HEADERS_ADVICE, FIRST_BYTE_RANGE, discardBody, httpRequest, plainHttpRequest, withAbortSignal } from "./httpRequest.js";
+import { isSameVersion, versionOf } from "./recordingVersion.js";
+//#region ../../packages/adapters/fetch/src/HttpResource.ts
+var HTTP_OK = 200;
+var HTTP_PARTIAL_CONTENT = 206;
+var HTTP_SERVER_ERROR = 500;
+var DEFAULT_RETRY_DELAYS_MS = [250, 1e3];
+/**
+* One recording at a URL, as every reader of it sees it: its size, whether its server has shown
+* it lets this page read it (CORS), the version its first answer told of (ADR 0029), and how a
+* range that failed on the way is asked for again.
+* The server must answer `Range` requests with 206 and, for cross-origin use, send CORS headers
+* that expose `Content-Range`; both are hard requirements of playing a remote recording and are
+* reported with distinct error codes.
+*/
+var HttpResource = class {
+	url;
+	options;
+	retryDelaysMs;
+	sizePromise;
+	/**
+	* A range has come through: CORS is proven for this resource, so a request that fails from
+	* here on failed on the way, whatever the diagnosis says of an error page without CORS headers.
+	*/
+	hasReadRange = false;
+	version;
+	/**
+	* `signal` ends every request made for the resource, with the host's own `requestInit` signal.
+	*/
+	constructor(url, options = {}, signal) {
+		this.url = url;
+		this.options = signal ? withAbortSignal(options, signal) : options;
+		this.retryDelaysMs = options.retryDelaysMs ?? DEFAULT_RETRY_DELAYS_MS;
+	}
+	/**
+	* One HEAD request (or a one-byte range where HEAD is refused or gives no length), cached for
+	* the lifetime of the resource once it succeeded; a failed lookup is retried on the next call.
+	*/
+	size() {
+		this.sizePromise ??= this.rememberSize();
+		return this.sizePromise;
+	}
+	/**
+	* Servers clamp out-of-range requests instead of failing them; the port contracts want a
+	* typed error, so the range is checked against the (cached) size first.
+	*/
+	async ensureFits(range) {
+		range.ensureWithin(await this.size(), `resource ${this.url}`);
+	}
+	/**
+	* Runs `attempt`, and after a short wait again, a few times, while it fails on the way: one
+	* dropped connection must not end a long playback. What asking again cannot change (an abort,
+	* a refusal, a server ignoring ranges, CORS) fails at once.
+	*/
+	async askingAgain(attempt) {
+		for (const delayMs of this.retryDelaysMs) {
+			try {
+				return await attempt();
+			} catch (error) {
+				if (!isPassing(error)) throw error;
+			}
+			await wait(delayMs, this.options.requestInit?.signal);
+		}
+		return attempt();
+	}
+	/**
+	* The server's answer to a byte range, its body still to be read: a 206, or the refusal it
+	* amounts to. `signal` ends this request alone.
+	*/
+	async rangeAnswer(range, signal) {
+		const options = signal ? withAbortSignal(this.options, signal) : this.options;
+		const response = await this.requestRange(range, options);
+		if (response.status !== HTTP_PARTIAL_CONTENT) {
+			discardBody(response);
+			throw this.refusalOf(response.status);
+		}
+		this.hasReadRange = true;
+		this.ensureUnchanged(response);
+		return response;
+	}
+	/**
+	* Every answer is of the version the first one told of: bytes of a recording replaced while it
+	* plays must not be put together with the old ones'.
+	*/
+	ensureUnchanged(response) {
+		const seen = versionOf(response);
+		this.version ??= seen;
+		if (isSameVersion(this.version, seen)) return;
+		discardBody(response);
+		throw new GyroViewError("source-changed", `${this.url} was replaced while it played; load it again`);
+	}
+	/**
+	* A request that did not get through for want of a network is worth another try; one CORS
+	* refused before any range came through is not.
+	*/
+	async requestRange(range, options) {
+		const headers = { Range: `bytes=${range.offset}-${range.end - 1}` };
+		try {
+			return this.hasReadRange ? await plainHttpRequest(this.url, {
+				method: "GET",
+				headers
+			}, options) : await httpRequest(this.url, {
+				method: "GET",
+				headers
+			}, options);
+		} catch (error) {
+			throw this.hasReadRange ? this.passingOnceAnswered(error) : passingIfUnreachable(error);
+		}
+	}
+	passingOnceAnswered(error) {
+		const message = `${this.url} could not be reached for a byte range`;
+		return isAbortError(error) ? error : passing(new GyroViewError("source-unreadable", message, { cause: error }));
+	}
+	refusalOf(status) {
+		if (status === HTTP_OK) return new GyroViewError("range-unsupported", `${this.url} ignores Range requests (answered 200 to a byte range)`);
+		const message = `${this.url} answered ${status} to a byte range`;
+		return status >= HTTP_SERVER_ERROR ? passing(new GyroViewError("source-unreadable", message)) : new GyroViewError("source-unreadable", message);
+	}
+	async rememberSize() {
+		try {
+			return await this.fetchSize();
+		} catch (error) {
+			this.sizePromise = void 0;
+			throw error;
+		}
+	}
+	async fetchSize() {
+		const response = await this.request("HEAD");
+		discardBody(response);
+		if (!response.ok) return this.sizeFromContentRange();
+		this.ensureUnchanged(response);
+		const contentLength = Number(response.headers.get("content-length"));
+		return Number.isSafeInteger(contentLength) && contentLength > 0 ? contentLength : this.sizeFromContentRange();
+	}
+	/**
+	* Some servers omit Content-Length on HEAD or refuse HEAD; a one-byte range reveals the total.
+	*/
+	async sizeFromContentRange() {
+		const response = await this.request("GET", { Range: FIRST_BYTE_RANGE });
+		discardBody(response);
+		if (response.status !== HTTP_PARTIAL_CONTENT) throw new GyroViewError("source-unreadable", `${this.url} answered ${response.status} to a byte range; cannot determine the file size`);
+		this.hasReadRange = true;
+		this.ensureUnchanged(response);
+		return this.totalOf(response);
+	}
+	totalOf(response) {
+		if (!response.headers.has("content-range") && response.type === "cors") throw this.hiddenContentRange();
+		const total = contentRangeOf(response)?.total;
+		if (total === void 0) throw new GyroViewError("source-unreadable", `${this.url} reports neither Content-Length nor Content-Range; cannot determine the file size`);
+		return total;
+	}
+	hiddenContentRange() {
+		return new GyroViewError("cors", `${this.url} answered a byte range but hides its Content-Range from this origin; add ${EXPOSED_HEADERS_ADVICE}`);
+	}
+	request(method, headers) {
+		return httpRequest(this.url, {
+			method,
+			...headers && { headers }
+		}, this.options);
+	}
+};
+/**
+* A pause before asking again, which an abort of the resource's requests ends at once.
+*/
+function wait(ms, signal) {
+	return new Promise((resolve, reject) => {
+		signal?.throwIfAborted();
+		const settled = new AbortController();
+		const timer = setTimeout(() => {
+			settled.abort();
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(abortErrorOf(signal));
+		};
+		signal?.addEventListener("abort", onAbort, {
+			once: true,
+			signal: settled.signal
+		});
+	});
+}
+function abortErrorOf(signal) {
+	const reason = signal?.reason;
+	return reason instanceof Error ? reason : new DOMException("the read was aborted", "AbortError");
+}
+//#endregion
+export { HttpResource };

package/dist/packages/adapters/fetch/src/contentRange.js

@@ -0,0 +1,15 @@
+//#region ../../packages/adapters/fetch/src/contentRange.ts
+var CONTENT_RANGE = /^bytes (\d+)-(\d+)\/(\d+|\*)$/u;
+var UNKNOWN_TOTAL = "*";
+function contentRangeOf(response) {
+	const match = CONTENT_RANGE.exec(response.headers.get("content-range") ?? "");
+	if (!match) return void 0;
+	const [, first, last, total] = match;
+	return {
+		first: Number(first),
+		last: Number(last),
+		total: total === UNKNOWN_TOTAL ? void 0 : Number(total)
+	};
+}
+//#endregion
+export { contentRangeOf };

package/dist/packages/adapters/fetch/src/httpRequest.js

@@ -7,9 +7,11 @@ import "../../../core/src/index.js";
 */
 var FIRST_BYTE_RANGE = "bytes=0-0";
 /**
-* The response headers a cross-origin page must be let read, as the fix a CORS failure names.
+* The response headers a cross-origin page must be let read, as the fix a CORS failure names;
+* `ETag` is optional, and tells a recording replaced while it plays more surely than
+* `Last-Modified`, which a page may always read.
 */
-var EXPOSED_HEADERS_ADVICE = "Access-Control-Expose-Headers: Content-Range, Content-Length, Accept-Ranges";
+var EXPOSED_HEADERS_ADVICE = "Access-Control-Expose-Headers: Content-Range, Content-Length, Accept-Ranges, ETag";
 /**
 * What a server must add for a page to read it across origins. A request that carries the
 * visitor's cookies is held to more: the Fetch standard refuses a wildcard origin for it.
@@ -20,7 +22,7 @@ var CREDENTIALED_CORS_ADVICE = `Access-Control-Allow-Origin naming this page's o
 * Browsers keep byte ranges of one URL as a sparse cache entry and revalidate them with
 * conditional requests. A 304 to such a request makes the browser answer from that entry, and
 * Chrome has been seen to hand back an empty body for a range it believed it held (ADR 0013).
-* The demuxer caches what it needs itself, so nothing is lost by leaving the cache out.
+* The download holds what it needs itself, so nothing is lost by leaving the cache out.
 */
 var CACHE_MODE = "no-store";
 /**

package/dist/packages/adapters/fetch/src/index.js

@@ -1,3 +1,5 @@
+import { HttpByteStream } from "./HttpByteStream.js";
 import { HttpRangeSource } from "./HttpRangeSource.js";
+import { HttpResource } from "./HttpResource.js";
 import { HttpResourceLocator } from "./HttpResourceLocator.js";
-export { HttpRangeSource, HttpResourceLocator };
+export { HttpByteStream, HttpRangeSource, HttpResource, HttpResourceLocator };

package/dist/packages/adapters/fetch/src/passingFailures.js

@@ -0,0 +1,24 @@
+import { GyroViewError, hasErrorCode } from "../../../core/src/shared/errors/GyroViewError.js";
+import "../../../core/src/index.js";
+//#region ../../packages/adapters/fetch/src/passingFailures.ts
+/**
+* The failures on the way, which asking again may cure; any other fails the read at once. They
+* are `source-unreadable` errors like any other, so a caller that gets one after the retries
+* cannot tell, and need not: only the retry loop asks.
+*/
+var passingFailures = /* @__PURE__ */ new WeakSet();
+function passing(failure) {
+	passingFailures.add(failure);
+	return failure;
+}
+function isPassing(error) {
+	return error instanceof GyroViewError && passingFailures.has(error);
+}
+/**
+* A request that did not get through for want of a network is worth another try.
+*/
+function passingIfUnreachable(error) {
+	return hasErrorCode(error, "source-unreadable") && error instanceof Error ? passing(new GyroViewError("source-unreadable", error.message, { cause: error.cause })) : error;
+}
+//#endregion
+export { isPassing, passing, passingIfUnreachable };

package/dist/packages/adapters/fetch/src/rangeFailures.js

@@ -0,0 +1,17 @@
+import { GyroViewError } from "../../../core/src/shared/errors/GyroViewError.js";
+import "../../../core/src/index.js";
+import { passing } from "./passingFailures.js";
+//#region ../../packages/adapters/fetch/src/rangeFailures.ts
+/**
+* A body a dropped connection broke off after the headers: the most common way a network fails
+* during long playback, so it is `source-unreadable` as a refused request is, not a bug or a bad
+* file, and worth another try.
+*/
+function brokenOff(url, range, cause) {
+	return passing(new GyroViewError("source-unreadable", `${url} broke off the ${range.length}-byte range at ${range.offset}`, { cause }));
+}
+function truncated(url, received, range) {
+	return new GyroViewError("source-truncated", `${url} returned ${received} bytes for a ${range.length}-byte range at ${range.offset}`);
+}
+//#endregion
+export { brokenOff, truncated };

package/dist/packages/adapters/fetch/src/recordingVersion.js

@@ -0,0 +1,37 @@
+import { contentRangeOf } from "./contentRange.js";
+//#region ../../packages/adapters/fetch/src/recordingVersion.ts
+var HTTP_OK = 200;
+var WEAK_ETAG_PREFIX = /^W\//u;
+function versionOf(response) {
+	const etag = response.headers.get("etag");
+	const lastModified = response.headers.get("last-modified");
+	const size = sizeOf(response);
+	return {
+		...etag !== null && { etag },
+		...lastModified !== null && { lastModified },
+		...size !== void 0 && { size }
+	};
+}
+/**
+* Whether two answers are of one version of the recording, by the ETag where both tell one,
+* else by the Last-Modified and the size; what either does not tell is taken for the same, so
+* a server that tells nothing is never taken for one that changed its file.
+*/
+function isSameVersion(known, seen) {
+	return known.etag !== void 0 && seen.etag !== void 0 ? opaqueTagOf(known.etag) === opaqueTagOf(seen.etag) : isSameWhereTold(known.lastModified, seen.lastModified) && isSameWhereTold(known.size, seen.size);
+}
+/**
+* The tag without its weakness mark: a CDN may weaken a strong ETag it passes on.
+*/
+function opaqueTagOf(etag) {
+	return etag.replace(WEAK_ETAG_PREFIX, "");
+}
+function isSameWhereTold(known, seen) {
+	return known === void 0 || seen === void 0 || known === seen;
+}
+function sizeOf(response) {
+	const size = response.status === HTTP_OK ? Number(response.headers.get("content-length") ?? NaN) : contentRangeOf(response)?.total;
+	return size !== void 0 && Number.isSafeInteger(size) && size > 0 ? size : void 0;
+}
+//#endregion
+export { isSameVersion, versionOf };

package/dist/packages/adapters/mediabunny/src/MediabunnyAudioPackager.js

@@ -0,0 +1,129 @@
+import { GyroViewError } from "../../../core/src/shared/errors/GyroViewError.js";
+import "../../../core/src/index.js";
+import { SegmentChannel } from "./SegmentChannel.js";
+import { EncodedAudioPacketSource, EncodedPacket, Mp4OutputFormat, NullTarget, Output } from "mediabunny";
+//#region ../../packages/adapters/mediabunny/src/MediabunnyAudioPackager.ts
+/**
+* Seconds of audio per media segment: short enough that a seek has sound quickly, long enough
+* that appends stay cheap.
+*/
+var FRAGMENT_DURATION_SECONDS = 1;
+/**
+* Segments (each fragment is two: `moof` and `mdat`) that may wait for the consumer before
+* re-packaging pauses.
+*/
+var SEGMENTS_AHEAD = 4;
+/**
+* The codec strings of the audio the cameras record, AAC (`mp4a.40.2` for AAC-LC), and mediabunny's
+* name for it. Other codecs are not re-packaged: the picture then plays on a silent clock.
+*/
+var AAC_CODEC_STRING_PREFIX = "mp4a.40.";
+var AAC = "aac";
+/**
+* AudioPackager over mediabunny: the samples re-packaged, unchanged, into fragmented MP4.
+* Segments are taken from the muxer's box callbacks rather than from its byte stream: that
+* yields whole `ftyp`/`moov`/`moof`/`mdat` boxes and leaves out the `mfra` index the muxer
+* appends at the end, which Media Source Extensions do not accept. Fragmented output keeps the
+* track's own timestamps, so segments started mid-track land at their true time.
+*/
+var MediabunnyAudioPackager = class {
+	segmentsOf(samples, configuration) {
+		const codec = muxedCodecOf(configuration);
+		return {
+			mimeType: `audio/mp4; codecs="${configuration.codec}"`,
+			duration: samples.duration,
+			segmentsFrom: (from) => ({ [Symbol.asyncIterator]: () => remux({
+				samples,
+				configuration,
+				codec
+			}, from) })
+		};
+	}
+};
+function muxedCodecOf(configuration) {
+	if (configuration.codec.startsWith(AAC_CODEC_STRING_PREFIX)) return AAC;
+	throw new GyroViewError("codec-unsupported", `audio in ${configuration.codec} cannot be re-packaged for playback`);
+}
+/**
+* Starts re-packaging from `from` into a channel and hands out its consumer's side. When the
+* consumer leaves, the samples are let go of at once, even while one is awaited, and the muxer
+* once the producer has noticed.
+*/
+function remux(parts, from) {
+	const channel = new SegmentChannel(SEGMENTS_AHEAD);
+	const output = new Output({
+		format: fragmentedMp4Into(channel),
+		target: new NullTarget()
+	});
+	const source = new EncodedAudioPacketSource(parts.codec);
+	output.addAudioTrack(source);
+	const samples = parts.samples.samplesFrom(from)[Symbol.asyncIterator]();
+	const production = produce({
+		samples,
+		configuration: parts.configuration,
+		output,
+		source,
+		channel
+	});
+	return channel.segments(() => {
+		samples.return?.();
+		releaseAfter(production, output);
+	});
+}
+/**
+* Frees the muxer once the producer has noticed the closed channel, without making a consumer
+* that left early (a seek) wait for a sample still in flight.
+*/
+async function releaseAfter(production, output) {
+	await production;
+	if (output.state === "finalized") return;
+	try {
+		await output.cancel();
+	} catch {}
+}
+/**
+* Feeds samples to the muxer at the consumer's pace; every failure ends up in the channel.
+*/
+async function produce(run) {
+	try {
+		await run.output.start();
+		let meta = { decoderConfig: decoderConfigOf(run.configuration) };
+		for (let next = await run.samples.next(); next.done !== true; next = await run.samples.next()) {
+			await run.channel.waitForRoom();
+			if (run.channel.isClosed) return;
+			await run.source.add(packetOf(next.value), meta);
+			meta = void 0;
+		}
+		if (run.channel.isClosed) return;
+		await run.output.finalize();
+		run.channel.close();
+	} catch (error) {
+		run.channel.fail(error);
+	}
+}
+function packetOf(sample) {
+	return new EncodedPacket(sample.data, "key", sample.timestamp, sample.duration);
+}
+function decoderConfigOf(configuration) {
+	return {
+		codec: configuration.codec,
+		sampleRate: configuration.sampleRate,
+		numberOfChannels: configuration.numberOfChannels,
+		...configuration.description && { description: configuration.description }
+	};
+}
+function fragmentedMp4Into(channel) {
+	const forward = (data) => {
+		channel.push(new Uint8Array(data));
+	};
+	return new Mp4OutputFormat({
+		fastStart: "fragmented",
+		minimumFragmentDuration: FRAGMENT_DURATION_SECONDS,
+		onFtyp: forward,
+		onMoov: forward,
+		onMoof: forward,
+		onMdat: forward
+	});
+}
+//#endregion
+export { MediabunnyAudioPackager };

package/dist/packages/adapters/mediabunny/src/MediabunnyCodecReader.js

@@ -0,0 +1,80 @@
+import { GyroViewError, isAbortError } from "../../../core/src/shared/errors/GyroViewError.js";
+import "../../../core/src/index.js";
+import { audioConfigurationOf, videoConfigurationOf } from "./decoderConfigurations.js";
+import { ALL_FORMATS, BufferSource, Input } from "mediabunny";
+//#region ../../packages/adapters/mediabunny/src/MediabunnyCodecReader.ts
+/**
+* CodecReader over mediabunny: opens the file type and movie boxes as a file of their own, in
+* memory, and tells each track's decoder configuration. mediabunny reads a sample only for a
+* video codec without its configuration box; the samples are not there, so that track is
+* refused.
+*/
+var MediabunnyCodecReader = class {
+	async read(movieBytes) {
+		const input = new Input({
+			formats: ALL_FORMATS,
+			source: new BufferSource(movieBytes)
+		});
+		try {
+			const [videoTracks, audioTracks] = await Promise.all([input.getVideoTracks(), input.getAudioTracks()]);
+			return {
+				video: await Promise.all(videoTracks.map((track, index) => videoCodecOf(track, index))),
+				audio: (await Promise.all(audioTracks.map((track) => audioCodecOf(track)))).flat()
+			};
+		} catch (error) {
+			throw failureOf(error);
+		} finally {
+			input.dispose();
+		}
+	}
+};
+async function videoCodecOf(track, trackIndex) {
+	const [config, codedWidth, codedHeight] = await Promise.all([
+		configurationOrNull(track),
+		track.getCodedWidth(),
+		track.getCodedHeight()
+	]);
+	if (config === null) throw new GyroViewError("codec-unsupported", `video track ${trackIndex} has no decoder configuration in its sample entry`);
+	const description = {
+		trackIndex,
+		codedWidth,
+		codedHeight,
+		codec: config.codec
+	};
+	return {
+		trackId: track.id,
+		description,
+		configuration: videoConfigurationOf(config, description)
+	};
+}
+/**
+* The configuration of a codec that carries it in the movie box; null for one that would need
+* a sample, which the movie bytes do not hold.
+*/
+async function configurationOrNull(track) {
+	try {
+		return await track.getDecoderConfig();
+	} catch {
+		return null;
+	}
+}
+/**
+* An audio track mediabunny cannot configure is left out: the picture then plays without sound
+* rather than not at all.
+*/
+async function audioCodecOf(track) {
+	const config = await track.getDecoderConfig();
+	return config === null ? [] : [{
+		trackId: track.id,
+		configuration: audioConfigurationOf(config)
+	}];
+}
+/**
+* A caller's abort and the core's own failures pass as they are; anything else mediabunny
+* throws means the bytes are no movie it can read.
+*/
+function failureOf(error) {
+	return isAbortError(error) || error instanceof GyroViewError ? error : new GyroViewError("unsupported-container", "the movie box is not a readable movie", { cause: error });
+}
+//#endregion
+export { MediabunnyCodecReader };

package/dist/packages/adapters/mediabunny/src/SegmentChannel.js

@@ -1,4 +1,5 @@
 import { GyroViewError, ensureInvariant } from "../../../core/src/shared/errors/GyroViewError.js";
+import { ITERATION_END } from "../../../core/src/shared/async/iteration.js";
 import "../../../core/src/index.js";
 //#region ../../packages/adapters/mediabunny/src/SegmentChannel.ts
 /**
@@ -43,12 +44,20 @@ var SegmentChannel = class {
 		this.failure ??= error instanceof Error ? error : new GyroViewError("decode", "audio re-packaging failed", { cause: error });
 		this.close();
 	}
-	async *segments() {
-		let next = await this.take();
-		while (next) {
-			yield next;
-			next = await this.take();
-		}
+	/**
+	* The consumer's side: the segments in order until the channel is closed and drained, then
+	* the producer's failure if it had one. Returning closes the channel at once, even while a
+	* segment is awaited, which then comes as the end. `onEnd` hears once of the end, however it
+	* came: the producer's resources may go.
+	*/
+	segments(onEnd = doNothing) {
+		return new SegmentReading({
+			take: () => this.take(),
+			close: () => {
+				this.close();
+			},
+			onEnd
+		});
 	}
 	/**
 	* The next segment; undefined once closed and drained; the producer's failure, if it had one.
@@ -80,5 +89,48 @@ var SegmentChannel = class {
 		for (const resolve of waiters) resolve();
 	}
 };
+/**
+* Iterates a channel's segments. A class, not a generator: a generator's return waits behind the
+* segment it awaits, and the producer would re-package another fragment for nobody.
+*/
+var SegmentReading = class {
+	parts;
+	hasEnded = false;
+	constructor(parts) {
+		this.parts = parts;
+	}
+	async next() {
+		if (this.hasEnded) return ITERATION_END;
+		try {
+			const segment = await this.parts.take();
+			return segment === void 0 || this.wasEnded() ? this.end() : {
+				done: false,
+				value: segment
+			};
+		} catch (error) {
+			this.end();
+			throw error;
+		}
+	}
+	return() {
+		this.parts.close();
+		return Promise.resolve(this.end());
+	}
+	[Symbol.asyncIterator]() {
+		return this;
+	}
+	/**
+	* Asked afresh after the wait: the consumer may have returned meanwhile.
+	*/
+	wasEnded() {
+		return this.hasEnded;
+	}
+	end() {
+		if (!this.hasEnded) this.parts.onEnd();
+		this.hasEnded = true;
+		return ITERATION_END;
+	}
+};
+function doNothing() {}
 //#endregion
 export { SegmentChannel };

package/dist/packages/adapters/mediabunny/src/decoderConfigurations.js

@@ -0,0 +1,28 @@
+import { copyOfBytes } from "./bufferSources.js";
+//#region ../../packages/adapters/mediabunny/src/decoderConfigurations.ts
+/**
+* A WebCodecs video decoder configuration in the core's terms; the coded size comes from the
+* track where the configuration leaves it out.
+*/
+function videoConfigurationOf(config, description) {
+	return {
+		codec: config.codec,
+		codedWidth: config.codedWidth ?? description.codedWidth,
+		codedHeight: config.codedHeight ?? description.codedHeight,
+		description: config.description === void 0 ? void 0 : copyOfBytes(config.description),
+		isFullRange: config.colorSpace?.fullRange ?? void 0
+	};
+}
+/**
+* A WebCodecs audio decoder configuration in the core's terms.
+*/
+function audioConfigurationOf(config) {
+	return {
+		codec: config.codec,
+		sampleRate: config.sampleRate,
+		numberOfChannels: config.numberOfChannels,
+		description: config.description === void 0 ? void 0 : copyOfBytes(config.description)
+	};
+}
+//#endregion
+export { audioConfigurationOf, videoConfigurationOf };

package/dist/packages/adapters/mediabunny/src/index.js

@@ -1,2 +1,3 @@
-import { MediabunnyDemuxer } from "./MediabunnyDemuxer.js";
-export { MediabunnyDemuxer };
+import { MediabunnyCodecReader } from "./MediabunnyCodecReader.js";
+import { MediabunnyAudioPackager } from "./MediabunnyAudioPackager.js";
+export { MediabunnyAudioPackager, MediabunnyCodecReader };