@bubo-squared/gyroview 0.1.0

package/dist/packages/core/src/shared/text/urlPath.js

@@ -0,0 +1,31 @@
+//#region ../../packages/core/src/shared/text/urlPath.ts
+var QUERY_OR_FRAGMENT = /[#?]/u;
+/**
+* A URL cut into its path and the query and fragment after it, read as text: relative URLs and
+* ones a URL parser would refuse split too.
+*/
+function splitUrl(url) {
+	const suffixStart = url.search(QUERY_OR_FRAGMENT);
+	return suffixStart === -1 ? {
+		path: url,
+		suffix: ""
+	} : {
+		path: url.slice(0, suffixStart),
+		suffix: url.slice(suffixStart)
+	};
+}
+/**
+* The file name a URL names: its last path segment, percent-decoded (kept as written when the
+* encoding is broken); the whole path when there is no slash.
+*/
+function fileNameOfUrl(url) {
+	const { path } = splitUrl(url);
+	const encoded = path.slice(path.lastIndexOf("/") + 1);
+	try {
+		return decodeURIComponent(encoded);
+	} catch {
+		return encoded;
+	}
+}
+//#endregion
+export { fileNameOfUrl, splitUrl };

package/dist/packages/core/src/shared/text/utf8.js

@@ -0,0 +1,12 @@
+import { lazy } from "../lazy.js";
+//#region ../../packages/core/src/shared/text/utf8.ts
+var decoder = lazy(() => new globalThis.TextDecoder("utf8"));
+/**
+* Text the camera wrote as UTF-8; malformed sequences, an encoded surrogate among them, become
+* U+FFFD, as the platform decodes them.
+*/
+function decodeUtf8(bytes) {
+	return decoder().decode(bytes);
+}
+//#endregion
+export { decodeUtf8 };

package/dist/packages/core/src/shared/units/angle.js

@@ -0,0 +1,22 @@
+//#region ../../packages/core/src/shared/units/angle.ts
+var degrees = (value) => value;
+var radians = (value) => value;
+var DEGREES_PER_QUARTER_TURN = 90;
+var DEGREES_PER_HALF_TURN = 180;
+var DEGREES_PER_TURN = 360;
+var QUARTER_TURN = degrees(DEGREES_PER_QUARTER_TURN);
+var HALF_TURN = degrees(DEGREES_PER_HALF_TURN);
+var FULL_TURN = degrees(DEGREES_PER_TURN);
+var degreesToRadians = (value) => radians(value * Math.PI / DEGREES_PER_HALF_TURN);
+var radiansToDegrees = (value) => degrees(value * DEGREES_PER_HALF_TURN / Math.PI);
+/**
+* The same direction as an angle in (-180, 180] degrees.
+*/
+function wrapHalfTurn(angle) {
+	let wrapped = angle % FULL_TURN;
+	if (wrapped > HALF_TURN) wrapped -= FULL_TURN;
+	if (wrapped <= -HALF_TURN) wrapped += FULL_TURN;
+	return degrees(wrapped);
+}
+//#endregion
+export { FULL_TURN, HALF_TURN, QUARTER_TURN, degrees, degreesToRadians, radians, radiansToDegrees, wrapHalfTurn };

package/dist/packages/core/src/shared/units/time.js

@@ -0,0 +1,13 @@
+//#region ../../packages/core/src/shared/units/time.ts
+var MICROSECONDS_PER_SECOND = 1e6;
+var MILLISECONDS_PER_SECOND = 1e3;
+var MICROSECONDS_PER_MILLISECOND = 1e3;
+var microseconds = (value) => value;
+var milliseconds = (value) => value;
+var seconds = (value) => value;
+var microsecondsToSeconds = (value) => seconds(value / MICROSECONDS_PER_SECOND);
+var millisecondsToMicroseconds = (value) => microseconds(value * MICROSECONDS_PER_MILLISECOND);
+var millisecondsToSeconds = (value) => seconds(value / MILLISECONDS_PER_SECOND);
+var secondsToMicroseconds = (value) => microseconds(value * MICROSECONDS_PER_SECOND);
+//#endregion
+export { microseconds, microsecondsToSeconds, milliseconds, millisecondsToMicroseconds, millisecondsToSeconds, seconds, secondsToMicroseconds };

package/dist/packages/player/src/PlayerSource.js

@@ -0,0 +1,15 @@
+import { fileNameOfUrl } from "../../core/src/shared/text/urlPath.js";
+import "../../core/src/index.js";
+//#region ../../packages/player/src/PlayerSource.ts
+function isUrlInput(input) {
+	return "url" in input;
+}
+/**
+* The file name the input goes by: the URL's last path segment or the blob's name. A hint for
+* layout detection and messages, never the truth about the file.
+*/
+function inputName(input) {
+	return isUrlInput(input) ? fileNameOfUrl(input.url) : input.name;
+}
+//#endregion
+export { inputName, isUrlInput };

package/dist/packages/player/src/browserPlayer.js

@@ -0,0 +1,18 @@
+import { browserPorts } from "./composition/browserPorts.js";
+import { buildPipeline } from "./composition/buildPipeline.js";
+import { Player } from "./player/Player.js";
+//#region ../../packages/player/src/browserPlayer.ts
+/**
+* A player composed for a browser: HTTP, blob and WebCodecs ports and the GPU pipeline, drawing
+* on the host's canvas and sounding through its audio element. What `<gyro-view>` plays with,
+* and where a page that wants the player without the element starts.
+*/
+function createBrowserPlayer(host, options) {
+	return new Player({
+		host,
+		ports: browserPorts(options),
+		pipelines: buildPipeline
+	});
+}
+//#endregion
+export { createBrowserPlayer };

package/dist/packages/player/src/choices.js

@@ -0,0 +1,25 @@
+import { STABILIZATION_MODES } from "../../core/src/domain/motion/stabilization/Stabilizer.js";
+import { PICTURE_QUALITIES } from "../../core/src/domain/view/PictureQuality.js";
+import { VIEW_MODES } from "../../core/src/domain/view/ViewMode.js";
+import "../../core/src/index.js";
+//#region ../../packages/player/src/choices.ts
+/**
+* The choice `value` names, matched without regard to case or surrounding space; undefined when
+* absent or unknown. Attributes, menus and property setters read their choices through it.
+*/
+function choiceOf(value, choices) {
+	if (value === null) return void 0;
+	const wanted = value.trim().toLowerCase();
+	return choices.find((choice) => choice === wanted);
+}
+function stabilizationModeOf(value) {
+	return choiceOf(value, STABILIZATION_MODES);
+}
+function viewModeOf(value) {
+	return choiceOf(value, VIEW_MODES);
+}
+function pictureQualityOf(value) {
+	return choiceOf(value, PICTURE_QUALITIES);
+}
+//#endregion
+export { choiceOf, pictureQualityOf, stabilizationModeOf, viewModeOf };

package/dist/packages/player/src/composition/Disposables.js

@@ -0,0 +1,31 @@
+//#region ../../packages/player/src/composition/Disposables.ts
+/**
+* Collects the resources one operation opens so a failure part way can release them in reverse
+* order, and so success can hand them over as a single disposer.
+*/
+var Disposables = class {
+	actions = [];
+	isDisposed = false;
+	add(dispose) {
+		if (this.isDisposed) {
+			dispose();
+			return;
+		}
+		this.actions.push(dispose);
+	}
+	disposeAll() {
+		if (this.isDisposed) return;
+		this.isDisposed = true;
+		for (const dispose of this.actions.splice(0).toReversed()) dispose();
+	}
+	/**
+	* The collected resources as one idempotent disposer, for the object that will own them.
+	*/
+	toDisposer() {
+		return () => {
+			this.disposeAll();
+		};
+	}
+};
+//#endregion
+export { Disposables };

package/dist/packages/player/src/composition/browserPorts.js

@@ -0,0 +1,46 @@
+import { Deferred } from "../../../core/src/shared/async/Deferred.js";
+import "../../../core/src/index.js";
+import { BlobRandomAccessSource } from "../../../adapters/blob/src/BlobRandomAccessSource.js";
+import "../../../adapters/blob/src/index.js";
+import { HttpRangeSource } from "../../../adapters/fetch/src/HttpRangeSource.js";
+import { HttpResourceLocator } from "../../../adapters/fetch/src/HttpResourceLocator.js";
+import "../../../adapters/fetch/src/index.js";
+import { MediabunnyDemuxer } from "../../../adapters/mediabunny/src/MediabunnyDemuxer.js";
+import "../../../adapters/mediabunny/src/index.js";
+import { WebCodecsVideoDecoderPort } from "../../../adapters/webcodecs/src/WebCodecsVideoDecoderPort.js";
+import "../../../adapters/webcodecs/src/index.js";
+import { isUrlInput } from "../PlayerSource.js";
+//#region ../../packages/player/src/composition/browserPorts.ts
+var DEFAULT_PROBE_TIMEOUT_MS = 15e3;
+/**
+* The real adapters behind the player in a browser.
+*/
+function browserPorts(options = {}) {
+	const http = options.http ?? {};
+	const probeTimeoutMs = options.probeTimeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
+	return {
+		sources: browserSources(http),
+		demuxer: new MediabunnyDemuxer(),
+		decoderPort: new WebCodecsVideoDecoderPort(),
+		locator: new HttpResourceLocator(http),
+		probeDeadline: () => deadlineIn(probeTimeoutMs)
+	};
+}
+/**
+* URLs are read with HTTP ranges, blobs by slicing.
+*/
+function browserSources(http) {
+	return { open: (input, signal) => isUrlInput(input) ? new HttpRangeSource(input.url, http, signal) : new BlobRandomAccessSource(input.blob) };
+}
+/**
+* A deadline that passes after `ms`: the core has no timers, so the host supplies deadlines.
+*/
+function deadlineIn(ms) {
+	const deadline = new Deferred();
+	setTimeout(() => {
+		deadline.resolve();
+	}, ms);
+	return deadline;
+}
+//#endregion
+export { browserPorts, browserSources };

package/dist/packages/player/src/composition/buildPipeline.js

@@ -0,0 +1,153 @@
+import { messageOf } from "../../../core/src/shared/errors/GyroViewError.js";
+import { milliseconds, seconds } from "../../../core/src/shared/units/time.js";
+import { stabilizerFor } from "../../../core/src/domain/motion/stabilization/stabilizers.js";
+import { buildStitchingSetup } from "../../../core/src/domain/stitching/StitchingSetup.js";
+import { StabilizingFrameSink } from "../../../core/src/application/stabilization/StabilizingFrameSink.js";
+import { GainMatchingFrameSink } from "../../../core/src/application/gainMatching/GainMatchingFrameSink.js";
+import { WallClock } from "../../../core/src/application/playback/WallClock.js";
+import { PlaybackSession } from "../../../core/src/application/playback/PlaybackSession.js";
+import "../../../core/src/index.js";
+import { MediaSourceAudioClock } from "../../../adapters/mse-audio/src/MediaSourceAudioClock.js";
+import "../../../adapters/mse-audio/src/index.js";
+import { ThreeFrameRenderer } from "../../../adapters/three/src/ThreeFrameRenderer.js";
+import "../../../adapters/three/src/index.js";
+import { Disposables } from "./Disposables.js";
+var DECODE_PIPELINE_OPTIONS = {
+	maxPendingPackets: 4,
+	pairTolerance: seconds(5e-4)
+};
+var NO_AUDIO_WARNING = "the recording has no audio track; playback follows a silent clock";
+var AUDIO_UNSUPPORTED_WARNING = "this browser cannot play the audio track through Media Source Extensions; playback follows a silent clock";
+var AUDIO_FAILED_WARNING = "the audio track could not be prepared for playback; playback follows a silent clock";
+/**
+* Assembles the playing parts for an opened recording: the clock the picture follows, the GPU
+* stitcher, the stabilizing and gain-matching sinks in front of it and the session driving them.
+* Nothing here decides anything about the file; every choice was made while opening it.
+*/
+async function buildPipeline(parts) {
+	const disposables = new Disposables();
+	try {
+		const clock = await clockFor(parts);
+		disposables.add(() => {
+			clock.clock.dispose();
+		});
+		parts.signal.throwIfAborted();
+		const drawing = drawingFor(parts, disposables);
+		const session = sessionFor(parts, clock.clock, drawing.gainMatching);
+		disposables.add(() => {
+			session.dispose();
+		});
+		return {
+			session,
+			renderer: drawing.renderer,
+			...pictureSettingsOf(drawing, session),
+			soundWarnings: clock.warnings,
+			dispose: disposables.toDisposer()
+		};
+	} catch (error) {
+		disposables.disposeAll();
+		throw error;
+	}
+}
+/**
+* The GPU stitcher on the host canvas, behind the stabilizing sink when there is a gyro, behind
+* gain matching, which measures what the stitcher drew.
+*/
+function drawingFor(parts, disposables) {
+	const renderer = ThreeFrameRenderer.create(parts.host.canvas, stitchingSetupOf(parts.opened));
+	disposables.add(() => {
+		renderer.dispose();
+	});
+	const { sink, stabilizing } = sinkOver(renderer, parts.opened);
+	const gainMatching = new GainMatchingFrameSink(sink, renderer);
+	disposables.add(() => {
+		gainMatching.dispose();
+	});
+	return {
+		renderer,
+		stabilizing,
+		gainMatching
+	};
+}
+/**
+* Each setting goes to the sink it concerns, and the frame standing on screen is drawn again, so
+* the change shows while paused.
+*/
+function pictureSettingsOf(drawing, session) {
+	return {
+		setStabilization: (mode) => {
+			drawing.stabilizing?.setStabilizer(stabilizerFor(mode));
+			session.redraw();
+		},
+		setQuality: (quality) => {
+			drawing.renderer.setQuality(quality);
+		},
+		setGainMatching: (isEnabled) => {
+			if (isEnabled) drawing.gainMatching.enable();
+			else drawing.gainMatching.disable();
+			session.redraw();
+		}
+	};
+}
+/**
+* The recording's own audio when there is a track this browser can feed to the element;
+* otherwise a wall clock, with a warning saying why there is no sound.
+*/
+async function clockFor(parts) {
+	const { audioTrack } = parts.opened;
+	if (!audioTrack) return wallClock(NO_AUDIO_WARNING);
+	try {
+		const segments = await audioTrack.openSegments();
+		if (!MediaSourceAudioClock.isSupported(segments)) return wallClock(AUDIO_UNSUPPORTED_WARNING);
+		parts.signal.throwIfAborted();
+		return {
+			clock: await MediaSourceAudioClock.open(parts.host.audio, segments),
+			warnings: []
+		};
+	} catch (error) {
+		return wallClock(`${AUDIO_FAILED_WARNING} (${messageOf(error)})`);
+	}
+}
+/**
+* A clock over the monotonic page time, which a change of the system clock does not move.
+*/
+function wallClock(warning) {
+	return {
+		clock: new WallClock(() => milliseconds(performance.now())),
+		warnings: [warning]
+	};
+}
+function stitchingSetupOf(opened) {
+	return buildStitchingSetup({
+		calibration: opened.calibration,
+		layout: opened.layout
+	});
+}
+function sinkOver(renderer, opened) {
+	if (!opened.motion) return {
+		sink: renderer,
+		stabilizing: void 0
+	};
+	const stabilizing = new StabilizingFrameSink({
+		sink: renderer,
+		orientations: opened.motion.orientations,
+		frameTimes: opened.frameTimes
+	});
+	return {
+		sink: stabilizing,
+		stabilizing
+	};
+}
+function sessionFor(parts, clock, sink) {
+	return new PlaybackSession({
+		frameSources: parts.opened.frameSources,
+		decoderPort: parts.decoderPort,
+		clock,
+		sink,
+		duration: parts.opened.duration,
+		pipeline: DECODE_PIPELINE_OPTIONS,
+		queueCapacity: 4
+	});
+}
+//#endregion
+export { DECODE_PIPELINE_OPTIONS, buildPipeline };

package/dist/packages/player/src/composition/ensureDecodable.js

@@ -0,0 +1,63 @@
+import { GyroViewError } from "../../../core/src/shared/errors/GyroViewError.js";
+import { probeDecoding } from "../../../core/src/application/playback/probeDecoding.js";
+import "../../../core/src/index.js";
+//#region ../../packages/player/src/composition/ensureDecodable.ts
+/**
+* Probes that this platform decodes every frame source, and refuses the recording with the
+* cause when it does not: the browser's, the file's or the network's.
+*/
+async function ensureDecodable(frameSources, attempt) {
+	const { ports, signal } = attempt;
+	const report = await probeDecoding(frameSources, ports.decoderPort, probeDeadlineOf(attempt));
+	signal.throwIfAborted();
+	if (!report.canDecode) throw probeFailure(report);
+}
+/**
+* The failures that are not the browser's, by the verdict every failed track shares: a file
+* without a key frame to start from, or a network too slow to bring one before the deadline.
+*/
+var FAILURES_NOT_OF_THE_BROWSER = {
+	"no-key-frame": {
+		code: "no-key-frame",
+		message: "the recording has no key frame to start decoding from"
+	},
+	"key-frame-late": {
+		code: "source-unreadable",
+		message: "the recording's first frames did not arrive in time"
+	}
+};
+var BROWSER_CANNOT_DECODE = {
+	code: "codec-unsupported",
+	message: "this browser cannot decode the recording"
+};
+function probeFailure(report) {
+	const cause = sharedCause(report);
+	const { code, message } = (cause === void 0 ? void 0 : FAILURES_NOT_OF_THE_BROWSER[cause]) ?? BROWSER_CANNOT_DECODE;
+	return new GyroViewError(code, `${message}: ${describeProbe(report)}`);
+}
+/**
+* The verdict every failed track shares, if one does. A decoder still busy at the deadline beside
+* a key frame that never came is taken for the same slow link's doing.
+*/
+function sharedCause(report) {
+	const verdicts = new Set(report.sources.filter((source) => source.verdict !== "decodes").map((source) => source.verdict));
+	if (verdicts.has("key-frame-late")) verdicts.delete("timed-out");
+	const [shared] = verdicts;
+	return verdicts.size === 1 ? shared : void 0;
+}
+/**
+* The probe's deadline, brought forward by an abort: a superseded load lets its probe decoders
+* go at once, which matters where decoders are few (iOS Safari).
+*/
+function probeDeadlineOf(attempt) {
+	const deadline = attempt.ports.probeDeadline();
+	attempt.signal.addEventListener("abort", () => {
+		deadline.resolve();
+	}, { once: true });
+	return deadline;
+}
+function describeProbe(report) {
+	return report.sources.filter((lens) => lens.verdict !== "decodes").map((lens) => `track ${lens.track.trackIndex} ${lens.verdict}${lens.detail ? ` (${lens.detail})` : ""}`).join("; ");
+}
+//#endregion
+export { ensureDecodable };

package/dist/packages/player/src/composition/openInputs.js

@@ -0,0 +1,179 @@
+import { GyroViewError, ensureInvariant, hasErrorCode } from "../../../core/src/shared/errors/GyroViewError.js";
+import { seconds } from "../../../core/src/shared/units/time.js";
+import { readRecording } from "../../../core/src/application/recording/readRecording.js";
+import { timeRecording } from "../../../core/src/application/recording/timeRecording.js";
+import { detectLensLayout } from "../../../core/src/domain/format/layout/detectLensLayout.js";
+import { lensFrameOrder } from "../../../core/src/domain/stitching/StitchingSetup.js";
+import "../../../core/src/index.js";
+import { inputName } from "../PlayerSource.js";
+import { Disposables } from "./Disposables.js";
+import { ensureDecodable } from "./ensureDecodable.js";
+//#region ../../packages/player/src/composition/openInputs.ts
+/**
+* Opens the given inputs as one recording, its metadata from the input that carries the
+* trailer. Everything opened is released again when any step fails or the attempt is aborted.
+*/
+async function openInputs(inputs, attempt) {
+	const disposables = new Disposables();
+	try {
+		const demuxed = await demuxInputs(inputs, attempt, disposables);
+		const layout = detectLensLayout(demuxed.inputs, demuxed.recording.info);
+		const frameSources = lensFrameOrder(layout).map((key) => trackAt(demuxed.inputs, key));
+		const calibration = calibrationOf(demuxed.recording);
+		await ensureDecodable(frameSources, attempt);
+		const timing = await timeRecording(demuxed.recording, frameSources[0]);
+		attempt.signal.throwIfAborted();
+		return assemble({
+			demuxed,
+			layout,
+			frameSources,
+			calibration,
+			timing
+		}, disposables);
+	} catch (error) {
+		disposables.disposeAll();
+		throw error;
+	}
+}
+async function demuxInputs(inputs, attempt, disposables) {
+	const { ports, signal } = attempt;
+	const given = inputs.map((input) => ({
+		input,
+		source: ports.sources.open(input, signal)
+	}));
+	const recording = await readRecordingOf(given, ports);
+	signal.throwIfAborted();
+	const openings = [...given, ...await declaredSecond(given, recording, attempt)];
+	const settled = await Promise.allSettled(openings.map(({ input, source }) => ports.demuxer.open(source, inputName(input))));
+	const opened = settled.flatMap((result) => result.status === "fulfilled" ? [result.value] : []);
+	for (const input of opened) disposables.add(() => {
+		input.dispose();
+	});
+	const failure = settled.find((result) => result.status === "rejected");
+	if (failure) throw failure.reason;
+	signal.throwIfAborted();
+	return {
+		recording,
+		inputs: opened
+	};
+}
+/**
+* The other lens file a lone file's info record says the recording is split into, when the
+* server has it: found before the lone file's tracks are read, which finding it only once they
+* fell short would read twice. A file that does not say so still gets its sibling looked for
+* once its tracks fall short (see openRecording).
+*/
+async function declaredSecond(given, recording, attempt) {
+	if (!(given.length === 1 && recording.info.fileLayout === "split-files") || !attempt.findSecondFile) return [];
+	const url = await attempt.findSecondFile();
+	attempt.signal.throwIfAborted();
+	if (url === void 0) return [];
+	const input = { url };
+	return [{
+		input,
+		source: attempt.ports.sources.open(input, attempt.signal)
+	}];
+}
+/**
+* The layout hints of a file without an info record: the tracks alone decide.
+*/
+var NO_HINTS = {
+	fileLayout: void 0,
+	trackOrder: void 0
+};
+async function readRecordingOf(openings, ports) {
+	try {
+		return await readTrailerCarrier(openings.map(({ source }) => source));
+	} catch (error) {
+		const [only] = openings;
+		if (openings.length === 1 && hasErrorCode(error, "invalid-trailer") && only) await refuseAsLoneHalf(only, ports);
+		throw error;
+	}
+}
+/**
+* A file without a trailer may be the _10_ half of an older camera's pair, which writes the
+* trailer to _00_ alone: its one square track tells, and the refusal asks for the other file
+* instead of calling it damaged. Anything else leaves the trailer's own refusal standing.
+*/
+async function refuseAsLoneHalf(opening, ports) {
+	let input;
+	try {
+		input = await ports.demuxer.open(opening.source, inputName(opening.input));
+	} catch {
+		return;
+	}
+	try {
+		detectLensLayout([input], NO_HINTS);
+	} catch (error) {
+		if (hasErrorCode(error, "missing-second-file")) throw error;
+	} finally {
+		input.dispose();
+	}
+}
+/**
+* The recording read from the input that carries the trailer: the first, or the second when the
+* first has none, as the _10_ file of an older camera's pair, which writes it to _00_ alone,
+* when the pair is given the other way round.
+*/
+async function readTrailerCarrier(sources) {
+	const [first, second] = sources;
+	ensureInvariant(first !== void 0, "a recording needs at least one input");
+	try {
+		return await readRecording(first);
+	} catch (error) {
+		if (second === void 0 || !hasErrorCode(error, "invalid-trailer")) throw error;
+		return readRecording(second);
+	}
+}
+function trackAt(inputs, key) {
+	const track = inputs[key.inputIndex]?.videoTracks[key.trackIndex];
+	ensureInvariant(track !== void 0, `the layout points at track ${key.trackIndex} of input ${key.inputIndex}, which does not exist`);
+	return track;
+}
+function calibrationOf(recording) {
+	const { calibration, warnings } = recording.calibration;
+	if (calibration) return calibration;
+	const detail = warnings.length > 0 ? ` (${warnings.join("; ")})` : "";
+	throw new GyroViewError("no-calibration", `the recording carries no usable lens calibration, so it cannot be stitched${detail}`);
+}
+function assemble(parts, disposables) {
+	const { demuxed, layout, frameSources, calibration, timing } = parts;
+	const duration = seconds(Math.min(...demuxed.inputs.map((input) => input.duration)));
+	const [audioTrack] = demuxed.inputs.flatMap((input) => input.audioTracks);
+	return {
+		recording: demuxed.recording,
+		layout,
+		frameSources,
+		calibration,
+		duration,
+		frameTimes: timing.frameTimes,
+		motion: timing.motion,
+		audioTrack,
+		metadata: metadataOf(parts, duration, audioTrack !== void 0),
+		warnings: timing.warnings,
+		dispose: disposables.toDisposer()
+	};
+}
+function metadataOf(parts, duration, hasAudio) {
+	const { info } = parts.demuxed.recording;
+	const { motion } = parts.timing;
+	return {
+		model: info.model,
+		firmware: info.firmware,
+		captureMode: info.captureMode,
+		layout: parts.layout.kind,
+		layoutEvidence: parts.layout.evidence,
+		tracks: parts.frameSources.map((track) => track.description),
+		calibrationVersion: parts.calibration.version,
+		frameTimeSource: parts.timing.frameTimeSource,
+		hasGyro: motion !== void 0,
+		imuFrame: motion && {
+			name: motion.imuFrame.name,
+			isVerified: motion.imuFrame.isVerified
+		},
+		hasAudio,
+		duration
+	};
+}
+//#endregion
+export { openInputs };

package/dist/packages/player/src/composition/openRecording.js

@@ -0,0 +1,42 @@
+import { hasErrorCode } from "../../../core/src/shared/errors/GyroViewError.js";
+import { lazy } from "../../../core/src/shared/lazy.js";
+import { locateOtherLensFile } from "../../../core/src/application/recording/locateOtherLensFile.js";
+import "../../../core/src/index.js";
+import { isUrlInput } from "../PlayerSource.js";
+import { openInputs } from "./openInputs.js";
+//#region ../../packages/player/src/composition/openRecording.ts
+/**
+* Use case at the composition root: opens what a source names, following the data. A lone file
+* of a split-file pair fetches its sibling when the server has it. Only the recording itself
+* ever plays (ADR 0017). Aborting releases everything opened so far.
+*/
+async function openRecording(source, ports, signal) {
+	const attempt = attemptFor(source, ports, signal);
+	const inputs = source.second ? [source.main, source.second] : [source.main];
+	try {
+		return await openInputs(inputs, attempt);
+	} catch (error) {
+		const { findSecondFile } = attempt;
+		if (!findSecondFile || !hasErrorCode(error, "missing-second-file")) throw error;
+		const second = await findSecondFile();
+		signal.throwIfAborted();
+		if (!second) throw error;
+		return openInputs([source.main, { url: second }], attempt);
+	}
+}
+/**
+* How the source is opened: a lone file named by URL may have its other lens file beside it.
+*/
+function attemptFor(source, ports, signal) {
+	const { main } = source;
+	return source.second === void 0 && isUrlInput(main) ? {
+		ports,
+		signal,
+		findSecondFile: lazy(() => locateOtherLensFile(main.url, ports.locator))
+	} : {
+		ports,
+		signal
+	};
+}
+//#endregion
+export { openRecording };