@bubo-squared/gyroview 0.1.0

package/dist/index.js

@@ -0,0 +1,13 @@
+import { GYRO_VIEW_ERROR_CODES, GyroViewError, hasErrorCode, isGyroViewErrorCode } from "./packages/core/src/shared/errors/GyroViewError.js";
+import { STABILIZATION_MODES } from "./packages/core/src/domain/motion/stabilization/Stabilizer.js";
+import { PICTURE_QUALITIES } from "./packages/core/src/domain/view/PictureQuality.js";
+import { VIEW_MODES } from "./packages/core/src/domain/view/ViewMode.js";
+import "./packages/core/src/index.js";
+import { attachKeyboard, attachViewGestures } from "./packages/player/src/controls/customControls.js";
+import { Player } from "./packages/player/src/player/Player.js";
+import { createBrowserPlayer } from "./packages/player/src/browserPlayer.js";
+import { inspectRecording } from "./packages/player/src/inspectRecording.js";
+import { GyroViewElement } from "./packages/player/src/element/GyroViewElement.js";
+import { GYRO_VIEW_TAG, defineGyroView } from "./packages/player/src/element/defineGyroView.js";
+import "./packages/player/src/index.js";
+export { GYRO_VIEW_ERROR_CODES, GYRO_VIEW_TAG, GyroViewElement, GyroViewError, PICTURE_QUALITIES, Player, STABILIZATION_MODES, VIEW_MODES, attachKeyboard, attachViewGestures, createBrowserPlayer, defineGyroView, hasErrorCode, inspectRecording, isGyroViewErrorCode };

package/dist/packages/adapters/blob/src/BlobRandomAccessSource.js

@@ -0,0 +1,37 @@
+import { GyroViewError } from "../../../core/src/shared/errors/GyroViewError.js";
+import "../../../core/src/index.js";
+//#region ../../packages/adapters/blob/src/BlobRandomAccessSource.ts
+/**
+* RandomAccessSource over a `Blob` (a `File` from a picker or a drop). Each read slices the
+* blob, which browsers serve from disk without loading the whole file, so multi-gigabyte
+* recordings play from local storage the same way they play from a URL.
+*/
+var BlobRandomAccessSource = class {
+	blob;
+	constructor(blob) {
+		this.blob = blob;
+	}
+	size() {
+		return Promise.resolve(this.blob.size);
+	}
+	async read(range) {
+		range.ensureWithin(this.blob.size, "blob");
+		if (range.length === 0) return /* @__PURE__ */ new Uint8Array();
+		const bytes = await this.bytesOf(this.blob.slice(range.offset, range.end));
+		if (bytes.byteLength !== range.length) throw new GyroViewError("source-truncated", `the blob yielded ${bytes.byteLength} bytes for a ${range.length}-byte range at ${range.offset}; the file may have changed on disk`);
+		return bytes;
+	}
+	/**
+	* Reading is what fails, with a `NotReadableError`, when a picked file has changed or gone on
+	* disk; slicing only clamps its arguments.
+	*/
+	async bytesOf(slice) {
+		try {
+			return new Uint8Array(await slice.arrayBuffer());
+		} catch (error) {
+			throw new GyroViewError("source-unreadable", "the blob could not be read", { cause: error });
+		}
+	}
+};
+//#endregion
+export { BlobRandomAccessSource };

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

@@ -0,0 +1,2 @@
+import { BlobRandomAccessSource } from "./BlobRandomAccessSource.js";
+export { BlobRandomAccessSource };

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

@@ -0,0 +1,194 @@
+import { GyroViewError, hasErrorCode, isAbortError } from "../../../core/src/shared/errors/GyroViewError.js";
+import "../../../core/src/index.js";
+import { EXPOSED_HEADERS_ADVICE, FIRST_BYTE_RANGE, discardBody, httpRequest, plainHttpRequest, withAbortSignal } from "./httpRequest.js";
+//#region ../../packages/adapters/fetch/src/HttpRangeSource.ts
+var HTTP_OK = 200;
+var HTTP_PARTIAL_CONTENT = 206;
+var HTTP_SERVER_ERROR = 500;
+var DEFAULT_RETRY_DELAYS_MS = [250, 1e3];
+/**
+* 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;
+}
+var CONTENT_RANGE_TOTAL = /\/(\d+)$/u;
+/**
+* RandomAccessSource over HTTP. 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 HttpRangeSource = class {
+	url;
+	options;
+	retryDelaysMs;
+	sizePromise;
+	/**
+	* A range has come through: CORS is proven for this source, 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;
+	/**
+	* `signal` ends every request the source makes, 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 source once it succeeded; a failed lookup is retried on the next call.
+	*/
+	size() {
+		this.sizePromise ??= this.rememberSize();
+		return this.sizePromise;
+	}
+	async read(range) {
+		await this.ensureFits(range);
+		return range.length === 0 ? /* @__PURE__ */ new Uint8Array() : this.readAskingAgain(range);
+	}
+	/**
+	* A range that failed on the way is asked for again after a short wait, a few times: 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 readAskingAgain(range) {
+		for (const delayMs of this.retryDelaysMs) {
+			try {
+				return await this.readOnce(range);
+			} catch (error) {
+				if (!(error instanceof GyroViewError && passingFailures.has(error))) throw error;
+			}
+			await wait(delayMs, this.options.requestInit?.signal);
+		}
+		return this.readOnce(range);
+	}
+	async readOnce(range) {
+		const response = await this.requestRange(range);
+		if (response.status !== HTTP_PARTIAL_CONTENT) {
+			discardBody(response);
+			throw this.refusalOf(response.status);
+		}
+		this.hasReadRange = true;
+		const bytes = await this.bodyOf(response, range);
+		if (bytes.byteLength !== range.length) throw new GyroViewError("source-truncated", `${this.url} returned ${bytes.byteLength} bytes for a ${range.length}-byte range at ${range.offset}`);
+		return bytes;
+	}
+	/**
+	* 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) {
+		const headers = { Range: `bytes=${range.offset}-${range.end - 1}` };
+		try {
+			return this.hasReadRange ? await plainHttpRequest(this.url, {
+				method: "GET",
+				headers
+			}, this.options) : await this.request("GET", headers);
+		} 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);
+	}
+	/**
+	* The bytes of a range, which a dropped connection can break 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.
+	*/
+	async bodyOf(response, range) {
+		try {
+			return new Uint8Array(await response.arrayBuffer());
+		} catch (error) {
+			if (isAbortError(error)) throw error;
+			throw passing(new GyroViewError("source-unreadable", `${this.url} broke off the ${range.length}-byte range at ${range.offset}`, { cause: error }));
+		}
+	}
+	/**
+	* Servers clamp out-of-range requests instead of failing them; the port contract wants a
+	* typed error, so the range is checked against the (cached) size first.
+	*/
+	async ensureFits(range) {
+		range.ensureWithin(await this.size(), `resource ${this.url}`);
+	}
+	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();
+		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;
+		const contentRange = response.headers.get("content-range");
+		if (contentRange === null && response.type === "cors") throw this.hiddenContentRange();
+		const total = CONTENT_RANGE_TOTAL.exec(contentRange ?? "")?.[1];
+		if (total === void 0) throw new GyroViewError("source-unreadable", `${this.url} reports neither Content-Length nor Content-Range; cannot determine the file size`);
+		return Number(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 source'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 passingIfUnreachable(error) {
+	return hasErrorCode(error, "source-unreadable") && error instanceof Error ? passing(new GyroViewError("source-unreadable", error.message, { cause: error.cause })) : error;
+}
+function abortErrorOf(signal) {
+	const reason = signal?.reason;
+	return reason instanceof Error ? reason : new DOMException("the read was aborted", "AbortError");
+}
+//#endregion
+export { HttpRangeSource };

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

@@ -0,0 +1,35 @@
+import { FIRST_BYTE_RANGE, discardBody, plainHttpRequest } from "./httpRequest.js";
+//#region ../../packages/adapters/fetch/src/HttpResourceLocator.ts
+/**
+* How a server refuses HEAD: a 405, or a 403 from a URL signed for GET alone. The first byte
+* then answers what HEAD would.
+*/
+var REFUSED_HEAD = /* @__PURE__ */ new Set([405, 403]);
+/**
+* ResourceLocator over HTTP: one HEAD request, or a one-byte GET when the server refuses HEAD.
+* Every failure, including a missing CORS header, means "not available"; the file looked for is
+* optional, so nothing here throws, and no request is spent explaining a failure.
+*/
+var HttpResourceLocator = class {
+	options;
+	constructor(options = {}) {
+		this.options = options;
+	}
+	async exists(url) {
+		try {
+			const head = await plainHttpRequest(url, { method: "HEAD" }, this.options);
+			discardBody(head);
+			if (!REFUSED_HEAD.has(head.status)) return head.ok;
+			const firstByte = await plainHttpRequest(url, {
+				method: "GET",
+				headers: { Range: FIRST_BYTE_RANGE }
+			}, this.options);
+			discardBody(firstByte);
+			return firstByte.ok;
+		} catch {
+			return false;
+		}
+	}
+};
+//#endregion
+export { HttpResourceLocator };

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

@@ -0,0 +1,126 @@
+import { GyroViewError, isAbortError } from "../../../core/src/shared/errors/GyroViewError.js";
+import "../../../core/src/index.js";
+//#region ../../packages/adapters/fetch/src/httpRequest.ts
+/**
+* The Range header value that asks for the first byte only: enough to learn whether a resource
+* is there, or its total size from Content-Range.
+*/
+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.
+*/
+var EXPOSED_HEADERS_ADVICE = "Access-Control-Expose-Headers: Content-Range, Content-Length, Accept-Ranges";
+/**
+* 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.
+*/
+var CACHE_MODE = "no-store";
+/**
+* One request with the shared settings merged in, failures explained: a request that fails
+* outright is told apart from one the browser blocked for want of CORS headers (the latter is
+* `cors`, the former `source-unreadable`). A caller's abort is passed on as it is.
+*/
+async function httpRequest(url, request, options) {
+	try {
+		return await plainHttpRequest(url, request, options);
+	} catch (error) {
+		if (isAbortError(error)) throw error;
+		throw await diagnoseFailure(url, options, error);
+	}
+}
+/**
+* One request with the shared settings merged in and its failure left as the platform reported
+* it, for callers to whom any failure means the same.
+*/
+function plainHttpRequest(url, request, options) {
+	return (options.fetch ?? fetch)(url, {
+		cache: CACHE_MODE,
+		...options.requestInit,
+		method: request.method,
+		headers: {
+			...headersOf(options.requestInit),
+			...request.headers
+		}
+	});
+}
+/**
+* The options with `signal` ending their requests too, beside any signal the host gave: made once
+* per source, so the listeners it adds do not pile up per request.
+*/
+function withAbortSignal(options, signal) {
+	const hostSignal = options.requestInit?.signal ?? void 0;
+	const either = hostSignal ? eitherSignal(hostSignal, signal) : signal;
+	return {
+		...options,
+		requestInit: {
+			...options.requestInit,
+			signal: either
+		}
+	};
+}
+/**
+* Fires when either does. `AbortSignal.any` would do, but iOS Safari has it only from 17.4.
+* Whichever fires takes both listeners along, so a long-lived host signal keeps none.
+*/
+function eitherSignal(first, second) {
+	const controller = new AbortController();
+	for (const signal of [first, second]) {
+		if (signal.aborted) controller.abort(signal.reason);
+		signal.addEventListener("abort", () => {
+			controller.abort(signal.reason);
+		}, {
+			once: true,
+			signal: controller.signal
+		});
+	}
+	return controller.signal;
+}
+/**
+* Browsers report a CORS refusal and a network failure alike, as a rejected fetch. A request
+* that asks for no CORS answer at all (an opaque response) still succeeds when the server is
+* reachable, so its outcome tells the two apart.
+*/
+async function diagnoseFailure(url, options, cause) {
+	return await isReachableWithoutCors(url, options) ? new GyroViewError("cors", `${url} answered, but its server does not allow this page's origin to read it; add CORS headers (Access-Control-Allow-Origin, ${EXPOSED_HEADERS_ADVICE})`, { cause }) : new GyroViewError("source-unreadable", `${url} could not be fetched; check the URL and the network`, { cause });
+}
+/**
+* The probe ends with the request it diagnoses: an abort of the load ends it too.
+*/
+async function isReachableWithoutCors(url, options) {
+	const doFetch = options.fetch ?? fetch;
+	const signal = options.requestInit?.signal ?? null;
+	try {
+		discardBody(await doFetch(url, {
+			method: "HEAD",
+			mode: "no-cors",
+			signal
+		}));
+		return true;
+	} catch (error) {
+		if (isAbortError(error)) throw error;
+		return false;
+	}
+}
+/**
+* Lets the browser stop streaming a body that will not be read, for example a whole file
+* answered to a byte range.
+*/
+function discardBody(response) {
+	cancelBody(response);
+}
+/**
+* A body the request's abort already ended refuses the cancel with that abort: there is nothing
+* left to stop, and the abort reaches the caller through the request itself.
+*/
+async function cancelBody(response) {
+	try {
+		await response.body?.cancel();
+	} catch {}
+}
+function headersOf(init) {
+	return Object.fromEntries(new Headers(init?.headers).entries());
+}
+//#endregion
+export { EXPOSED_HEADERS_ADVICE, FIRST_BYTE_RANGE, discardBody, httpRequest, plainHttpRequest, withAbortSignal };

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

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

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

@@ -0,0 +1,133 @@
+import { GyroViewError } from "../../../core/src/shared/errors/GyroViewError.js";
+import { seconds } from "../../../core/src/shared/units/time.js";
+import "../../../core/src/index.js";
+import { SegmentChannel } from "./SegmentChannel.js";
+import { EncodedAudioPacketSource, EncodedPacketSink, Mp4OutputFormat, NullTarget, Output } from "mediabunny";
+//#region ../../packages/adapters/mediabunny/src/MediabunnyAudioSegments.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;
+/**
+* An audio track's packets re-packaged, unchanged, into fragmented MP4 with mediabunny.
+* 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 a run started mid-track lands at its true time.
+*/
+var MediabunnyAudioSegments = class MediabunnyAudioSegments {
+	parts;
+	duration;
+	constructor(parts, duration) {
+		this.parts = parts;
+		this.duration = duration;
+	}
+	/**
+	* Rejects with `codec-unsupported`, naming the track, when mediabunny cannot re-package it: the
+	* picture then plays without sound rather than not at all.
+	*/
+	static async open(track, trackIndex) {
+		const [codec, decoderConfig, duration] = await Promise.all([
+			track.getCodec(),
+			track.getDecoderConfig(),
+			track.computeDuration()
+		]);
+		if (codec === null || decoderConfig === null) {
+			const named = await track.getCodecParameterString() ?? "an unknown codec";
+			throw new GyroViewError("codec-unsupported", `audio track ${trackIndex} (${named}) cannot be re-packaged for playback`);
+		}
+		return new MediabunnyAudioSegments({
+			track,
+			codec,
+			decoderConfig
+		}, seconds(duration));
+	}
+	get mimeType() {
+		return `audio/mp4; codecs="${this.parts.decoderConfig.codec}"`;
+	}
+	segmentsFrom(from) {
+		return remux(this.parts, from);
+	}
+};
+async 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 production = produce({
+		parts,
+		from,
+		output,
+		source,
+		channel
+	});
+	try {
+		yield* channel.segments();
+	} finally {
+		channel.close();
+		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 packet read still in flight.
+*/
+async function releaseAfter(production, output) {
+	await production;
+	if (output.state === "finalized") return;
+	try {
+		await output.cancel();
+	} catch {}
+}
+/**
+* Feeds packets 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: run.parts.decoderConfig };
+		for await (const packet of packetsFrom(run.parts.track, run.from)) {
+			await run.channel.waitForRoom();
+			if (run.channel.isClosed) return;
+			await run.source.add(packet, meta);
+			meta = void 0;
+		}
+		await run.output.finalize();
+		run.channel.close();
+	} catch (error) {
+		run.channel.fail(error);
+	}
+}
+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
+	});
+}
+/**
+* Packets in decode order from the one playing at `time` (or the first one after it) to the end.
+*/
+async function* packetsFrom(track, time) {
+	const sink = new EncodedPacketSink(track);
+	const start = await sink.getPacket(time) ?? await sink.getFirstPacket();
+	if (start === null) return;
+	yield* sink.packets(start);
+}
+//#endregion
+export { MediabunnyAudioSegments };

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

@@ -0,0 +1,63 @@
+import { GyroViewError, isAbortError } from "../../../core/src/shared/errors/GyroViewError.js";
+import { seconds } from "../../../core/src/shared/units/time.js";
+import { ByteRange } from "../../../core/src/shared/binary/ByteRange.js";
+import "../../../core/src/index.js";
+import { MediabunnyAudioSegments } from "./MediabunnyAudioSegments.js";
+import { MediabunnyVideoTrackReader } from "./MediabunnyVideoTrackReader.js";
+import { ALL_FORMATS, CustomSource, Input } from "mediabunny";
+//#region ../../packages/adapters/mediabunny/src/MediabunnyDemuxer.ts
+/**
+* Demuxer over mediabunny. Bytes flow through the core's RandomAccessSource port (one HTTP
+* client, one cache), presented to mediabunny as a CustomSource with network prefetching.
+*/
+var MediabunnyDemuxer = class {
+	async open(source, name) {
+		const input = new Input({
+			formats: ALL_FORMATS,
+			source: new CustomSource({
+				getSize: () => source.size(),
+				read: (start, end) => source.read(ByteRange.of(start, end - start)),
+				prefetchProfile: "network",
+				handleUnhandledError: ignoreFailedPrefetch
+			})
+		});
+		try {
+			return await describeInput(input, name);
+		} catch (error) {
+			input.dispose();
+			throw failureOf(error, name);
+		}
+	}
+};
+/**
+* The source's own failures and a caller's abort pass as they are; anything else the demuxer
+* throws means the bytes are no media file it can read.
+*/
+function failureOf(error, name) {
+	const isPassedOn = isAbortError(error) || error instanceof GyroViewError;
+	const message = `${name ?? "the input"} is not a readable media file`;
+	return isPassedOn ? error : new GyroViewError("unsupported-container", message, { cause: error });
+}
+/**
+* A read ahead that fails while no read waits for it: left unhandled it would reach the host
+* page's error reporting. The read that needs those bytes asks again and fails through the port.
+*/
+function ignoreFailedPrefetch() {}
+async function describeInput(input, name) {
+	const [videoTracks, audioTracks, duration] = await Promise.all([
+		input.getVideoTracks(),
+		input.getAudioTracks(),
+		input.computeDuration()
+	]);
+	return {
+		name,
+		duration: seconds(duration),
+		videoTracks: await Promise.all(videoTracks.map((track, trackIndex) => MediabunnyVideoTrackReader.open(track, trackIndex))),
+		audioTracks: audioTracks.map((track, trackIndex) => ({ openSegments: () => MediabunnyAudioSegments.open(track, trackIndex) })),
+		dispose: () => {
+			input.dispose();
+		}
+	};
+}
+//#endregion
+export { MediabunnyDemuxer };