@bvdmitri/gyroview 0.0.0-stage → 0.9.0-cutaway.2

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

@@ -0,0 +1,23 @@
+import { GyroViewError, hasErrorCode } from "../../../core/src/shared/errors/GyroViewError.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,16 @@
+import { GyroViewError } from "../../../core/src/shared/errors/GyroViewError.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,162 @@
+import { GyroViewError, ensureInvariant } from "../../../core/src/shared/errors/GyroViewError.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;
+/**
+* Media segments that may wait for the consumer before re-packaging pauses.
+*/
+var SEGMENTS_AHEAD = 2;
+/**
+* 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 assembled from the muxer's box callbacks rather than taken from its byte stream:
+* that yields whole segments 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 }
+	};
+}
+/**
+* The muxer's boxes handed on as whole segments: the initialization segment (`ftyp` and `moov`)
+* and each media segment (`moof` and its `mdat`). A consumer that stops between two segments, as
+* a seek does, then never leaves a source buffer's parser inside one, where Chromium reads the
+* next segments' bytes as the samples of the `moof` it holds and fails to decode them.
+*/
+function fragmentedMp4Into(channel) {
+	const segment = new SegmentAssembly(channel);
+	return new Mp4OutputFormat({
+		fastStart: "fragmented",
+		minimumFragmentDuration: FRAGMENT_DURATION_SECONDS,
+		onFtyp: (data) => {
+			segment.begin(data);
+		},
+		onMoov: (data) => {
+			segment.end(data);
+		},
+		onMoof: (data) => {
+			segment.begin(data);
+		},
+		onMdat: (data) => {
+			segment.end(data);
+		}
+	});
+}
+/**
+* A segment's first box held until the box that ends it arrives, then both pushed as one.
+*/
+var SegmentAssembly = class {
+	channel;
+	opening;
+	constructor(channel) {
+		this.channel = channel;
+	}
+	begin(box) {
+		ensureInvariant(this.opening === void 0, "a segment began before the last one ended");
+		this.opening = new Uint8Array(box);
+	}
+	end(box) {
+		const { opening } = this;
+		ensureInvariant(opening !== void 0, "a segment ended that never began");
+		const whole = new Uint8Array(opening.byteLength + box.byteLength);
+		whole.set(opening);
+		whole.set(box, opening.byteLength);
+		this.opening = void 0;
+		this.channel.push(whole);
+	}
+};
+//#endregion
+export { MediabunnyAudioPackager };

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

@@ -0,0 +1,93 @@
+import { GyroViewError, isAbortError } from "../../../core/src/shared/errors/GyroViewError.js";
+import { audioConfigurationOf, codecStringOf, videoConfigurationOf } from "./decoderConfigurations.js";
+import { trackColourOf } from "./trackColour.js";
+import { BufferSource, Input, MP4, QTFF } from "mediabunny";
+//#region ../../packages/adapters/mediabunny/src/MediabunnyCodecReader.ts
+/**
+* The movie bytes are an ISO BMFF file's type and movie boxes, whatever its brand: with only
+* these two formats named, a page's bundle leaves out mediabunny's other demuxers, a third of
+* its weight.
+*/
+var MOVIE_FORMATS = [MP4, QTFF];
+/**
+* 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 as the file's failing.
+*/
+var MediabunnyCodecReader = class {
+	async read(movieBytes) {
+		const input = new Input({
+			formats: MOVIE_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([
+		configurationOf(track, trackIndex),
+		track.getCodedWidth(),
+		track.getCodedHeight()
+	]);
+	const description = {
+		trackIndex,
+		codedWidth,
+		codedHeight,
+		codec: await codecStringOf(track, config),
+		colour: trackColourOf(config.colorSpace)
+	};
+	return {
+		trackId: track.id,
+		description,
+		configuration: videoConfigurationOf(config, description)
+	};
+}
+/**
+* The configuration of a codec that carries it in the movie box. A sample entry without one, or
+* with one mediabunny cannot read, fails as the file's: no browser could configure a decoder from
+* it, and the movie bytes hold no sample to find it in.
+*/
+async function configurationOf(track, trackIndex) {
+	let config;
+	try {
+		config = await track.getDecoderConfig();
+	} catch (error) {
+		throw noConfiguration(trackIndex, { cause: error });
+	}
+	if (config === null) throw noConfiguration(trackIndex);
+	return config;
+}
+function noConfiguration(trackIndex, options) {
+	return new GyroViewError("unsupported-container", `video track ${trackIndex} has no decoder configuration in its sample entry`, options);
+}
+/**
+* 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

@@ -0,0 +1,135 @@
+import { GyroViewError, ensureInvariant } from "../../../core/src/shared/errors/GyroViewError.js";
+import { ITERATION_END } from "../../../core/src/shared/async/iteration.js";
+//#region ../../packages/adapters/mediabunny/src/SegmentChannel.ts
+/**
+* Hands segments from the muxer's synchronous callbacks to one asynchronous consumer, with a
+* bound on how many may wait unconsumed so re-packaging never runs far ahead of playback.
+* Closing from either side ends the exchange; a producer failure reaches the consumer as a
+* thrown error once the segments before it are drained. A second concurrent consumer is a
+* programming error.
+*/
+var SegmentChannel = class {
+	capacity;
+	queue = [];
+	roomWaiters = [];
+	takeWaiter;
+	isClosedNow = false;
+	failure;
+	constructor(capacity) {
+		this.capacity = capacity;
+	}
+	get isClosed() {
+		return this.isClosedNow;
+	}
+	push(segment) {
+		if (this.isClosedNow) return;
+		this.queue.push(segment);
+		this.wakeTaker();
+	}
+	/**
+	* Resolves once fewer than `capacity` segments wait, or at once when the channel is closed.
+	*/
+	waitForRoom() {
+		return this.queue.length < this.capacity || this.isClosedNow ? Promise.resolve() : new Promise((resolve) => {
+			this.roomWaiters.push(resolve);
+		});
+	}
+	close() {
+		this.isClosedNow = true;
+		this.wakeTaker();
+		this.wakeRoomWaiters();
+	}
+	fail(error) {
+		this.failure ??= error instanceof Error ? error : new GyroViewError("decode", "audio re-packaging failed", { cause: error });
+		this.close();
+	}
+	/**
+	* 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.
+	*/
+	async take() {
+		while (this.queue.length === 0 && !this.isClosedNow) await this.nextPush();
+		const next = this.queue.shift();
+		if (next) {
+			this.wakeRoomWaiters();
+			return next;
+		}
+		if (this.failure) throw this.failure;
+	}
+	nextPush() {
+		ensureInvariant(this.takeWaiter === void 0, "a segment channel has one consumer");
+		return new Promise((resolve) => {
+			this.takeWaiter = resolve;
+		});
+	}
+	wakeTaker() {
+		const waiter = this.takeWaiter;
+		this.takeWaiter = void 0;
+		waiter?.();
+	}
+	wakeRoomWaiters() {
+		if (this.queue.length >= this.capacity && !this.isClosedNow) return;
+		const waiters = this.roomWaiters;
+		this.roomWaiters = [];
+		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/bufferSources.js

@@ -0,0 +1,12 @@
+//#region ../../packages/adapters/mediabunny/src/bufferSources.ts
+/**
+* A copy of a buffer source as a plain Uint8Array. Decoder descriptions are small; the copy keeps
+* them independent of mediabunny's own buffers and never on shared memory. SharedArrayBuffer is
+* not named, since browsers define it only under cross-origin isolation.
+*/
+function copyOfBytes(source) {
+	const view = ArrayBuffer.isView(source) ? new Uint8Array(source.buffer, source.byteOffset, source.byteLength) : new Uint8Array(source);
+	return Uint8Array.from(view);
+}
+//#endregion
+export { copyOfBytes };

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

@@ -0,0 +1,43 @@
+import { hevcCodecStringOf } from "../../../core/src/domain/format/mp4/hevcCodecString.js";
+import { copyOfBytes } from "./bufferSources.js";
+//#region ../../packages/adapters/mediabunny/src/decoderConfigurations.ts
+/**
+* The sample entry types an HEVC track's codec string begins with (ISO/IEC 14496-15 §8.4.1,
+* Annex E.3). An encrypted track's entry, `encv`, names its protection instead.
+*/
+var HEVC_SAMPLE_ENTRY_TYPES = /* @__PURE__ */ new Set(["hvc1", "hev1"]);
+/**
+* A video track's codec string: mediabunny's, but for an HEVC track, whose codec mediabunny
+* names from the configuration's header alone, the core's, which reads a blank header's SPS.
+*/
+async function codecStringOf(track, config) {
+	const [codec, sampleEntryType] = await Promise.all([track.getCodec(), track.getInternalCodecId()]);
+	return codec === "hevc" && typeof sampleEntryType === "string" && HEVC_SAMPLE_ENTRY_TYPES.has(sampleEntryType) && config.description !== void 0 ? hevcCodecStringOf(sampleEntryType, copyOfBytes(config.description)) : config.codec;
+}
+/**
+* A WebCodecs video decoder configuration in the core's terms; the codec string and the colour
+* come from the track's description, the coded size from the track where the configuration
+* leaves it out.
+*/
+function videoConfigurationOf(config, description) {
+	return {
+		codec: description.codec,
+		codedWidth: config.codedWidth ?? description.codedWidth,
+		codedHeight: config.codedHeight ?? description.codedHeight,
+		description: config.description === void 0 ? void 0 : copyOfBytes(config.description),
+		colour: description.colour
+	};
+}
+/**
+* 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, codecStringOf, videoConfigurationOf };

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

@@ -0,0 +1,20 @@
+import { COLOUR_PRIMARIES, MATRIX_COEFFICIENTS, TRANSFER_CHARACTERISTICS, namedOrUnspecified } from "../../../core/src/domain/colour/TrackColour.js";
+//#region ../../packages/adapters/mediabunny/src/trackColour.ts
+/**
+* A track's colour in the core's terms, from the colour space mediabunny reads off its sample
+* entry or, without a `colr` box, its SPS: a value the core does not name is unspecified.
+*/
+function trackColourOf(colorSpace) {
+	return {
+		primaries: namedOrUnspecified(COLOUR_PRIMARIES, colorSpace?.primaries),
+		transfer: namedOrUnspecified(TRANSFER_CHARACTERISTICS, colorSpace?.transfer),
+		matrix: namedOrUnspecified(MATRIX_COEFFICIENTS, colorSpace?.matrix),
+		range: rangeOf(colorSpace?.fullRange)
+	};
+}
+function rangeOf(fullRange) {
+	if (fullRange === true) return "full";
+	return fullRange === false ? "limited" : "unspecified";
+}
+//#endregion
+export { trackColourOf };

package/dist/packages/adapters/mse-audio/src/MediaSourceAudioClock.js

@@ -0,0 +1,138 @@
+import { GyroViewError, isAbortError, messageOf } from "../../../core/src/shared/errors/GyroViewError.js";
+import { seconds } from "../../../core/src/shared/units/time.js";
+import { attachMediaSource, isMediaSourceTypeSupported, mediaSourceConstructor } from "./mediaSourceSupport.js";
+import { SourceBufferFeeder } from "./SourceBufferFeeder.js";
+//#region ../../packages/adapters/mse-audio/src/MediaSourceAudioClock.ts
+/**
+* PlaybackClock over an audio element fed through Media Source Extensions with the recording's
+* own audio track, so the picture follows the sound and volume and mute are the element's.
+* The element is borrowed from the host; disposing detaches the media source from it.
+* See ADR 0007.
+*/
+var MediaSourceAudioClock = class MediaSourceAudioClock {
+	element;
+	feeder;
+	attached;
+	/**
+	* The end the clock stands at since a seek there, the element left where it was.
+	*/
+	standingEnd;
+	constructor(element, feeder, attached) {
+		this.element = element;
+		this.feeder = feeder;
+		this.attached = attached;
+	}
+	static isSupported(source) {
+		return isMediaSourceTypeSupported(source.mimeType);
+	}
+	/**
+	* Attaches a media source to the element and starts buffering from the beginning.
+	*/
+	static async open(element, source) {
+		const mediaSourceClass = mediaSourceConstructor();
+		if (!mediaSourceClass?.isTypeSupported(source.mimeType)) throw new GyroViewError("codec-unsupported", `${source.mimeType} cannot play through Media Source Extensions here`);
+		const attached = await attachMediaSource(element, mediaSourceClass);
+		try {
+			const sourceBuffer = attached.mediaSource.addSourceBuffer(source.mimeType);
+			attached.mediaSource.duration = source.duration;
+			const feeder = new SourceBufferFeeder({
+				element,
+				mediaSource: attached.mediaSource,
+				sourceBuffer,
+				source
+			});
+			feeder.restartFrom(seconds(0));
+			return new MediaSourceAudioClock(element, feeder, attached);
+		} catch (error) {
+			attached.detach();
+			throw asClockFailure(error);
+		}
+	}
+	get currentTime() {
+		return this.standingEnd ?? seconds(this.element.currentTime);
+	}
+	/**
+	* Whoever paused the element (the session, media keys, an audio interruption): `play()` clears
+	* `paused` at once, so a start in flight counts as running.
+	*/
+	get isRunning() {
+		return !this.element.paused;
+	}
+	/**
+	* Standing at the end since a seek there, or the element `ended`: it played to its end.
+	*/
+	get hasEnded() {
+		return this.standingEnd !== void 0 || this.element.ended;
+	}
+	/**
+	* What the feeder met, or the element's own error: sound that buffered but would not decode,
+	* which stalls the element without the feeder ever hearing of it.
+	*/
+	get failure() {
+		return this.feeder.failure ?? failureOfElement(this.element);
+	}
+	/**
+	* Resolves once playback has started. A `pause` that interrupts the start is not an error;
+	* the autoplay policy refusing to start is reported as `playback-blocked`. A clock at its end
+	* stays there: `play()` would play the element from the beginning, or from where a seek to the
+	* end left it, under the last picture.
+	*/
+	async start() {
+		if (this.hasEnded) return;
+		try {
+			await this.element.play();
+		} catch (error) {
+			if (isAbortError(error)) return;
+			const isBlocked = isNamed(error, "NotAllowedError");
+			throw new GyroViewError(isBlocked ? "playback-blocked" : "decode", isBlocked ? "the browser refused to start audio playback; a user gesture is needed" : "audio playback failed to start", { cause: error });
+		}
+	}
+	pause() {
+		this.element.pause();
+	}
+	/**
+	* A seek to the end stands the clock there and leaves the element paused where it was: an
+	* element at its end has nothing left to play, and engines differ right at the end. WebKit on
+	* Linux, under load, fails an element whose seek to the end of its sound is still pending when
+	* the stream ends there (media error 4); macOS WebKit loses a seek just short of the end.
+	*/
+	seek(time) {
+		const end = this.attached.mediaSource.duration;
+		if (time >= end) {
+			this.standAtEnd(seconds(end));
+			return;
+		}
+		this.standingEnd = void 0;
+		this.element.currentTime = time;
+		this.feeder.restartFrom(time);
+	}
+	dispose() {
+		this.feeder.dispose();
+		this.element.pause();
+		this.attached.detach();
+	}
+	standAtEnd(end) {
+		this.element.pause();
+		this.standingEnd = end;
+	}
+};
+function isNamed(error, name) {
+	return error instanceof Error && error.name === name;
+}
+function failureOfElement(element) {
+	const { error } = element;
+	if (error === null) return void 0;
+	const message = `the audio element failed (media error ${error.code})`;
+	return new GyroViewError("decode", message, { cause: error });
+}
+/**
+* The media source's own exceptions cross the port as typed failures: a type it will not buffer
+* is `codec-unsupported`, anything else `decode`.
+*/
+function asClockFailure(error) {
+	if (error instanceof GyroViewError) return error;
+	const isUnsupported = isNamed(error, "NotSupportedError");
+	return new GyroViewError(isUnsupported ? "codec-unsupported" : "decode", `the audio element refused the recording's sound: ${messageOf(error)}`, { cause: error });
+}
+//#endregion
+export { MediaSourceAudioClock };