@bubo-squared/gyroview 0.1.0

package/dist/packages/core/src/domain/format/calibration/layouts/LegacyCalibrationLayout.js

@@ -0,0 +1,44 @@
+import { V1Token, V1Trailing } from "../offsetTokens.js";
+import { eulerDegrees } from "./CalibrationStringLayout.js";
+import { LEGACY_RADIUS_ANGLE } from "../../../optics/opticsConstants.js";
+import { EquidistantModel } from "../../../optics/EquidistantModel.js";
+import { CalibrationVersion } from "../CalibrationVersion.js";
+//#region ../../packages/core/src/domain/format/calibration/layouts/LegacyCalibrationLayout.ts
+/**
+* The original `offset` string: `r cx cy yaw pitch roll` per lens, then canvas width and height,
+* then a word whose low bits hold the lens type. The word's upper bits differ between cameras
+* (1 on the X5, 3 on the ONE R), so they are not treated as a version.
+*/
+var LEGACY_CALIBRATION_LAYOUT = {
+	version: CalibrationVersion.Legacy,
+	lensTokens: 6,
+	trailingTokens: 3,
+	parseLens(block, lensIndex) {
+		return {
+			lensIndex,
+			model: new EquidistantModel({
+				edgeRadius: block(V1Token.EdgeRadius),
+				radiusAngle: LEGACY_RADIUS_ANGLE,
+				principalPoint: {
+					x: block(V1Token.CenterX),
+					y: block(V1Token.CenterY)
+				}
+			}),
+			orientation: eulerDegrees(block(V1Token.Yaw), block(V1Token.Pitch), block(V1Token.Roll)),
+			translation: [
+				0,
+				0,
+				0
+			]
+		};
+	},
+	canvasOf(numbers) {
+		const trailingStart = 1 + (numbers[0] ?? 0) * 6;
+		return {
+			width: numbers[trailingStart + V1Trailing.CanvasWidth] ?? 0,
+			height: numbers[trailingStart + V1Trailing.CanvasHeight] ?? 0
+		};
+	}
+};
+//#endregion
+export { LEGACY_CALIBRATION_LAYOUT };

package/dist/packages/core/src/domain/format/calibration/layouts/MeiCalibrationLayout.js

@@ -0,0 +1,45 @@
+import { V3Token } from "../offsetTokens.js";
+import { canvasOfFirstBlock, eulerDegrees, versionWordMismatch } from "./CalibrationStringLayout.js";
+import { CalibrationVersion } from "../CalibrationVersion.js";
+import { MeiModel } from "../../../optics/MeiModel.js";
+//#region ../../packages/core/src/domain/format/calibration/layouts/MeiCalibrationLayout.ts
+/**
+* `offset_v3`: `xi fx fy cx cy yaw pitch roll tx ty tz k1 k2 k3 p1 p2 width height type` per
+* lens, then a version word with 3 in its high 16 bits.
+*/
+var MEI_CALIBRATION_LAYOUT = {
+	version: CalibrationVersion.Mei,
+	lensTokens: 19,
+	trailingTokens: 1,
+	versionWordProblem: (versionWord) => versionWordMismatch(versionWord, CalibrationVersion.Mei),
+	parseLens(block, lensIndex) {
+		return {
+			lensIndex,
+			model: new MeiModel({
+				xi: block(V3Token.Xi),
+				focal: [block(V3Token.FocalX), block(V3Token.FocalY)],
+				principalPoint: {
+					x: block(V3Token.CenterX),
+					y: block(V3Token.CenterY)
+				},
+				radial: [
+					block(V3Token.K1),
+					block(V3Token.K2),
+					block(V3Token.K3)
+				],
+				tangential: [block(V3Token.P1), block(V3Token.P2)]
+			}),
+			orientation: eulerDegrees(block(V3Token.Yaw), block(V3Token.Pitch), block(V3Token.Roll)),
+			translation: [
+				block(V3Token.TranslationX),
+				block(V3Token.TranslationY),
+				block(V3Token.TranslationZ)
+			]
+		};
+	},
+	canvasOf(_numbers, blocks) {
+		return canvasOfFirstBlock(blocks, V3Token.CanvasWidth, V3Token.CanvasHeight);
+	}
+};
+//#endregion
+export { MEI_CALIBRATION_LAYOUT };

package/dist/packages/core/src/domain/format/calibration/layouts/PolynomialCalibrationLayout.js

@@ -0,0 +1,44 @@
+import { V2Token } from "../offsetTokens.js";
+import { canvasOfFirstBlock, eulerDegrees, versionWordMismatch } from "./CalibrationStringLayout.js";
+import { CalibrationVersion } from "../CalibrationVersion.js";
+import { PolynomialModel } from "../../../optics/PolynomialModel.js";
+//#region ../../packages/core/src/domain/format/calibration/layouts/PolynomialCalibrationLayout.ts
+/**
+* `offset_v2`: `r cx cy yaw pitch roll tx ty tz c1 c2 c3 c4 width height type` per lens, then
+* a version word with 2 in its high 16 bits.
+*/
+var POLYNOMIAL_CALIBRATION_LAYOUT = {
+	version: CalibrationVersion.Polynomial,
+	lensTokens: 16,
+	trailingTokens: 1,
+	versionWordProblem: (versionWord) => versionWordMismatch(versionWord, CalibrationVersion.Polynomial),
+	parseLens(block, lensIndex) {
+		return {
+			lensIndex,
+			model: new PolynomialModel({
+				edgeRadius: block(V2Token.EdgeRadius),
+				principalPoint: {
+					x: block(V2Token.CenterX),
+					y: block(V2Token.CenterY)
+				},
+				coefficients: [
+					block(V2Token.C1),
+					block(V2Token.C2),
+					block(V2Token.C3),
+					block(V2Token.C4)
+				]
+			}),
+			orientation: eulerDegrees(block(V2Token.Yaw), block(V2Token.Pitch), block(V2Token.Roll)),
+			translation: [
+				block(V2Token.TranslationX),
+				block(V2Token.TranslationY),
+				block(V2Token.TranslationZ)
+			]
+		};
+	},
+	canvasOf(_numbers, blocks) {
+		return canvasOfFirstBlock(blocks, V2Token.CanvasWidth, V2Token.CanvasHeight);
+	}
+};
+//#endregion
+export { POLYNOMIAL_CALIBRATION_LAYOUT };

package/dist/packages/core/src/domain/format/calibration/offsetTokens.js

@@ -0,0 +1,65 @@
+//#region ../../packages/core/src/domain/format/calibration/offsetTokens.ts
+/**
+* Token positions inside one lens block of each calibration string version, relative to the
+* block start. Sources: telemetry-parser (v3 order), insta360-rs docs (v2 order), and the X5
+* recordings where the same `cx cy yaw pitch roll` values appear in all three strings, which
+* pins the v1 order to `r cx cy yaw pitch roll`.
+*/
+var V1Token = {
+	EdgeRadius: 0,
+	CenterX: 1,
+	CenterY: 2,
+	Yaw: 3,
+	Pitch: 4,
+	Roll: 5
+};
+var V2Token = {
+	EdgeRadius: 0,
+	CenterX: 1,
+	CenterY: 2,
+	Yaw: 3,
+	Pitch: 4,
+	Roll: 5,
+	TranslationX: 6,
+	TranslationY: 7,
+	TranslationZ: 8,
+	C1: 9,
+	C2: 10,
+	C3: 11,
+	C4: 12,
+	CanvasWidth: 13,
+	CanvasHeight: 14,
+	LensType: 15
+};
+var V3Token = {
+	Xi: 0,
+	FocalX: 1,
+	FocalY: 2,
+	CenterX: 3,
+	CenterY: 4,
+	Yaw: 5,
+	Pitch: 6,
+	Roll: 7,
+	TranslationX: 8,
+	TranslationY: 9,
+	TranslationZ: 10,
+	K1: 11,
+	K2: 12,
+	K3: 13,
+	P1: 14,
+	P2: 15,
+	CanvasWidth: 16,
+	CanvasHeight: 17,
+	LensType: 18
+};
+/**
+* Tokens after the lens blocks. v1 ends with canvas width, canvas height and a version word;
+* v2 and v3 end with the version word only.
+*/
+var V1Trailing = {
+	CanvasWidth: 0,
+	CanvasHeight: 1,
+	VersionWord: 2
+};
+//#endregion
+export { V1Token, V1Trailing, V2Token, V3Token };

package/dist/packages/core/src/domain/format/calibration/parseOffsetString.js

@@ -0,0 +1,52 @@
+import "./layouts/CalibrationStringLayout.js";
+import { LEGACY_CALIBRATION_LAYOUT } from "./layouts/LegacyCalibrationLayout.js";
+import { MEI_CALIBRATION_LAYOUT } from "./layouts/MeiCalibrationLayout.js";
+import { POLYNOMIAL_CALIBRATION_LAYOUT } from "./layouts/PolynomialCalibrationLayout.js";
+import { GyroViewError } from "../../../shared/errors/GyroViewError.js";
+//#region ../../packages/core/src/domain/format/calibration/parseOffsetString.ts
+var TOKEN_SEPARATOR = "_";
+var LAYOUTS = [
+	LEGACY_CALIBRATION_LAYOUT,
+	POLYNOMIAL_CALIBRATION_LAYOUT,
+	MEI_CALIBRATION_LAYOUT
+];
+/**
+* Parses `offset`, `offset_v2` and `offset_v3` strings into a calibration set with its version. The
+* layout is detected from the token count; the v6 layout (13 distortion coefficients per lens) is
+* recognised and rejected explicitly.
+*/
+function parseOffsetString(text) {
+	const numbers = text.split(TOKEN_SEPARATOR).map((token) => parseNumber(token, text));
+	const lensCount = numbers[0] ?? 0;
+	const layout = detectLayout(numbers.length, lensCount, text);
+	ensureVersionWordFits(layout, numbers.at(-1) ?? 0);
+	const blocks = Array.from({ length: lensCount }, (_unused, lensIndex) => lensBlock(numbers, 1 + lensIndex * layout.lensTokens));
+	return {
+		version: layout.version,
+		canvas: layout.canvasOf(numbers, blocks),
+		lenses: blocks.map((block, lensIndex) => layout.parseLens(block, lensIndex))
+	};
+}
+function tokenCountFor(lensCount, lensTokens, trailingTokens) {
+	return 1 + lensCount * lensTokens + trailingTokens;
+}
+function detectLayout(tokenCount, lensCount, text) {
+	const layout = LAYOUTS.find((candidate) => tokenCount === tokenCountFor(lensCount, candidate.lensTokens, candidate.trailingTokens));
+	if (layout) return layout;
+	if (tokenCount === tokenCountFor(lensCount, 27, 1)) throw new GyroViewError("unsupported-calibration", "calibration string uses the v6 layout (13 distortion coefficients), which is not supported yet");
+	throw new GyroViewError("invalid-calibration", `calibration string has ${tokenCount} tokens for ${lensCount} lenses, matching no known layout: ${text}`);
+}
+function ensureVersionWordFits(layout, versionWord) {
+	const problem = layout.versionWordProblem?.(versionWord);
+	if (problem !== void 0) throw new GyroViewError("invalid-calibration", `calibration string has the v${layout.version} layout but ${problem}`);
+}
+function lensBlock(numbers, start) {
+	return (token) => numbers[start + token] ?? NaN;
+}
+function parseNumber(token, text) {
+	const value = Number(token);
+	if (token.trim() === "" || !Number.isFinite(value)) throw new GyroViewError("invalid-calibration", `calibration token "${token}" is not a finite number in: ${text}`);
+	return value;
+}
+//#endregion
+export { parseOffsetString };

package/dist/packages/core/src/domain/format/calibration/selectCalibration.js

@@ -0,0 +1,46 @@
+import { GyroViewError } from "../../../shared/errors/GyroViewError.js";
+import { parseOffsetString } from "./parseOffsetString.js";
+//#region ../../packages/core/src/domain/format/calibration/selectCalibration.ts
+/**
+* Only these failures mean "this string is unusable, try the next one"; anything else is a bug
+* and propagates.
+*/
+var SKIPPABLE = /* @__PURE__ */ new Set(["invalid-calibration", "unsupported-calibration"]);
+/**
+* Picks the calibration a recording is stitched through: the legacy string first, whose
+* equidistant reading is the one Insta360's own stitch agrees with on the far field
+* (ADR 0023), then the Mei (v3) and polynomial (v2) strings for a recording without it. Strings
+* that cannot be used are reported, not silently dropped; having none is reported as absence,
+* not as a failure.
+*/
+function selectCalibration(strings) {
+	const candidates = [
+		["offset", strings.offset],
+		["offset_v3", strings.offsetV3],
+		["offset_v2", strings.offsetV2]
+	];
+	const warnings = [];
+	for (const [name, text] of candidates) {
+		if (text === void 0) continue;
+		const attempt = tryParse(name, text);
+		if ("calibration" in attempt) return {
+			calibration: attempt.calibration,
+			warnings
+		};
+		warnings.push(attempt.warning);
+	}
+	return {
+		calibration: void 0,
+		warnings
+	};
+}
+function tryParse(name, text) {
+	try {
+		return { calibration: parseOffsetString(text) };
+	} catch (error) {
+		if (error instanceof GyroViewError && SKIPPABLE.has(error.code)) return { warning: `${name} skipped: ${error.message}` };
+		throw error;
+	}
+}
+//#endregion
+export { selectCalibration };

package/dist/packages/core/src/domain/format/captureOrigin.js

@@ -0,0 +1,20 @@
+import { microseconds } from "../../shared/units/time.js";
+//#region ../../packages/core/src/domain/format/captureOrigin.ts
+/**
+* A capture-clock stamp written outside the gyro record (the first frame's, the exposure
+* entries'), as a time: cameras write them in the gyro layout's unit (milliseconds for the
+* float layout, as telemetry-parser reads them), microseconds without a gyro layout.
+*/
+function captureTimeOfStamp(stamp, gyroLayout) {
+	return gyroLayout ? gyroLayout.captureTimeOf(stamp) : microseconds(stamp);
+}
+/**
+* The capture-clock time of the first encoded frame, the origin of video time; undefined when
+* the info record does not say.
+*/
+function firstFrameCaptureTime(info, gyroLayout) {
+	const stamp = info.firstFrameTimestamp;
+	return stamp === void 0 ? void 0 : captureTimeOfStamp(stamp, gyroLayout);
+}
+//#endregion
+export { captureTimeOfStamp, firstFrameCaptureTime };

package/dist/packages/core/src/domain/format/constants.js

@@ -0,0 +1,33 @@
+//#region ../../packages/core/src/domain/format/constants.ts
+/**
+* Byte-level constants of the Insta360 trailer. Sources: the two X5 recordings inspected on
+* 2026-09-18 (test/fixtures/x5/manifest.json), Gyroflow's telemetry-parser (src/insta360/mod.rs)
+* and ExifTool (QuickTimeStream.pl, ProcessInsta360). Every number here was confirmed against
+* the fixtures unless marked otherwise.
+*/
+/**
+* ASCII string that ends every Insta360 file carrying a trailer.
+*/
+var TRAILER_MAGIC = "8db42d694ccc418790edff439fe026bf";
+/**
+* Record type ids observed in X5 files and documented by telemetry-parser for older cameras.
+*/
+var RecordType = {
+	Index: 0,
+	Info: 1,
+	Thumbnail: 2,
+	Gyro: 3,
+	Exposure: 4,
+	ThumbnailExtended: 5,
+	FrameTimestamps: 6,
+	Gps: 7
+};
+/**
+* Record formats seen in the header's first byte for the info record.
+*/
+var InfoRecordFormat = {
+	Protobuf: 1,
+	Json: 2
+};
+//#endregion
+export { InfoRecordFormat, RecordType, TRAILER_MAGIC };

package/dist/packages/core/src/domain/format/info/infoFields.js

@@ -0,0 +1,110 @@
+//#region ../../packages/core/src/domain/format/info/infoFields.ts
+/**
+* Field numbers of the info record's protobuf message (record id 1, format 1).
+* Sources: Gyroflow telemetry-parser `src/insta360/extra_info.rs` (names) and the two X5
+* recordings (values confirmed on 2026-09-18). Fields marked "observed" have no published
+* name; their meaning was inferred from the sample values and must be treated as provisional.
+*/
+var InfoField = {
+	SerialNumber: 1,
+	Model: 2,
+	Firmware: 3,
+	/**
+	Legacy calibration string: lens count, then `r cx cy yaw pitch roll` per lens.
+	*/
+	Offset: 5,
+	/**
+	Nested: 1 width, 2 height of one lens track.
+	*/
+	Dimension: 19,
+	FrameRate: 20,
+	/**
+	Observed: "standard" on X5.
+	*/
+	CaptureMode: 22,
+	/**
+	Capture-clock timestamp of the first encoded frame; unit follows the gyro record.
+	*/
+	FirstFrameTimestamp: 24,
+	RollingShutterTimeMs: 25,
+	/**
+	Nested: 1 type, 2 index, 3 identify, 4 total. Shared by segments of one recording.
+	*/
+	FileGroupInfo: 26,
+	/**
+	Nested: 1..6 sensor and crop dimensions. Observed 5376 5376 5312 5312 0 0 on X5.
+	*/
+	WindowCropInfo: 27,
+	GyroTimestampMs: 28,
+	HasGyroTimestamp: 29,
+	TotalFrames: 40,
+	IsFlowstateOnline: 42,
+	GyroType: 51,
+	/**
+	Polynomial calibration string (v2).
+	*/
+	OffsetV2: 53,
+	/**
+	Unified (MEI) camera model calibration string (v3, or v6 with more coefficients).
+	*/
+	OffsetV3: 54,
+	IsRawGyro: 62,
+	/**
+	1 = frame times from MP4 PTS, 2 = from the exposure record (`PtsType`).
+	*/
+	PtsType: 64,
+	/**
+	Nested: 1 accelerometer range in g, 2 gyroscope range in degrees per second.
+	*/
+	GyroConfig: 65,
+	/**
+	Observed (insta360-rs): 1 = split into `_00_`/`_10_` files, 2 = tracks in one file.
+	*/
+	FileLayout: 79,
+	/**
+	Observed (insta360-rs): 1 = track 0 is stream 10, 2 = track 0 is stream 00.
+	*/
+	TrackOrder: 80
+};
+var DimensionField = {
+	Width: 1,
+	Height: 2
+};
+var GyroConfigField = {
+	AccelerometerRangeG: 1,
+	GyroscopeRangeDps: 2
+};
+var WindowCropField = {
+	SensorWidth: 1,
+	SensorHeight: 2,
+	CropWidth: 3,
+	CropHeight: 4,
+	CropOffsetX: 5,
+	CropOffsetY: 6
+};
+/**
+* Values of the `pts_type` field: where the camera says frame times come from.
+*/
+var PtsType = {
+	TrackTimestamps: 1,
+	ExposureRecord: 2
+};
+/**
+* Values of the file-layout field, per insta360-rs. Provisional: observed as 2 on X5 multi-track
+* files, 1 is documented for `_00_`/`_10_` pairs.
+*/
+var FileLayoutValue = {
+	SplitFiles: 1,
+	MultiTrack: 2
+};
+/**
+* Values of the track-order field, per insta360-rs. Provisional: stream `00` is the back lens
+* (calibration lens 0), stream `10` the screen-side lens. The X5 files seen so far write 1, so
+* their first track is the screen-side lens.
+*/
+var TrackOrderValue = {
+	Stream10First: 1,
+	Stream00First: 2
+};
+//#endregion
+export { DimensionField, FileLayoutValue, GyroConfigField, InfoField, PtsType, TrackOrderValue, WindowCropField };

package/dist/packages/core/src/domain/format/info/parseInfoRecord.js

@@ -0,0 +1,90 @@
+import { GyroViewError } from "../../../shared/errors/GyroViewError.js";
+import { DimensionField, FileLayoutValue, GyroConfigField, InfoField, PtsType, TrackOrderValue, WindowCropField } from "./infoFields.js";
+import { InfoRecordFormat } from "../constants.js";
+import { ProtobufMessage } from "../../../shared/protobuf/ProtobufMessage.js";
+import { milliseconds, millisecondsToSeconds } from "../../../shared/units/time.js";
+//#region ../../packages/core/src/domain/format/info/parseInfoRecord.ts
+/**
+* Turns the info record into a {@link RecordingInfo}. Only the protobuf encoding (format 1) is
+* understood; the JSON encoding documented for some firmware has never been observed.
+*/
+function parseInfoRecord(payload, format) {
+	if (format !== InfoRecordFormat.Protobuf) throw new GyroViewError("unsupported-info-format", `info record uses format ${format}; only protobuf (${InfoRecordFormat.Protobuf}) is supported`);
+	const message = ProtobufMessage.decode(payload);
+	return {
+		serialNumber: message.string(InfoField.SerialNumber),
+		model: message.string(InfoField.Model),
+		firmware: message.string(InfoField.Firmware),
+		calibration: calibrationStringsOf(message),
+		dimension: dimensionOf(message.message(InfoField.Dimension)),
+		frameRate: message.varint(InfoField.FrameRate),
+		captureMode: message.string(InfoField.CaptureMode),
+		firstFrameTimestamp: message.varint(InfoField.FirstFrameTimestamp),
+		readoutTime: secondsFromMilliseconds(message.double(InfoField.RollingShutterTimeMs)),
+		windowCrop: windowCropOf(message.message(InfoField.WindowCropInfo)),
+		gyroOffset: optionalMilliseconds(message.double(InfoField.GyroTimestampMs)),
+		gyroType: message.varint(InfoField.GyroType),
+		isRawGyro: message.boolean(InfoField.IsRawGyro),
+		preferredFrameTimeSource: frameTimeSourceOf(message.varint(InfoField.PtsType)),
+		sensorRanges: sensorRangesOf(message.message(InfoField.GyroConfig)),
+		fileLayout: fileLayoutOf(message.varint(InfoField.FileLayout)),
+		trackOrder: trackOrderOf(message.varint(InfoField.TrackOrder))
+	};
+}
+function secondsFromMilliseconds(value) {
+	return value === void 0 ? void 0 : millisecondsToSeconds(milliseconds(value));
+}
+function optionalMilliseconds(value) {
+	return value === void 0 ? void 0 : milliseconds(value);
+}
+/**
+* Other `pts_type` values have never been observed and say nothing to rely on.
+*/
+function frameTimeSourceOf(ptsType) {
+	if (ptsType === PtsType.TrackTimestamps) return "track-timestamps";
+	return ptsType === PtsType.ExposureRecord ? "exposure-record" : void 0;
+}
+/**
+* Other layout and track-order values have never been observed and say nothing to rely on.
+*/
+function fileLayoutOf(value) {
+	if (value === FileLayoutValue.SplitFiles) return "split-files";
+	return value === FileLayoutValue.MultiTrack ? "multi-track" : void 0;
+}
+function trackOrderOf(value) {
+	if (value === TrackOrderValue.Stream10First) return "stream-10-first";
+	return value === TrackOrderValue.Stream00First ? "stream-00-first" : void 0;
+}
+function calibrationStringsOf(message) {
+	return {
+		offset: message.string(InfoField.Offset),
+		offsetV2: message.string(InfoField.OffsetV2),
+		offsetV3: message.string(InfoField.OffsetV3)
+	};
+}
+function dimensionOf(message) {
+	const width = message?.varint(DimensionField.Width);
+	const height = message?.varint(DimensionField.Height);
+	return width === void 0 || height === void 0 ? void 0 : {
+		width,
+		height
+	};
+}
+function windowCropOf(message) {
+	return message === void 0 ? void 0 : {
+		sensorWidth: message.varint(WindowCropField.SensorWidth),
+		sensorHeight: message.varint(WindowCropField.SensorHeight),
+		cropWidth: message.varint(WindowCropField.CropWidth),
+		cropHeight: message.varint(WindowCropField.CropHeight),
+		cropOffsetX: message.varint(WindowCropField.CropOffsetX),
+		cropOffsetY: message.varint(WindowCropField.CropOffsetY)
+	};
+}
+function sensorRangesOf(message) {
+	return message === void 0 ? void 0 : {
+		accelerometerG: message.varint(GyroConfigField.AccelerometerRangeG),
+		gyroscopeDps: message.varint(GyroConfigField.GyroscopeRangeDps)
+	};
+}
+//#endregion
+export { parseInfoRecord };

package/dist/packages/core/src/domain/format/info/readInfoRecord.js

@@ -0,0 +1,14 @@
+import { GyroViewError } from "../../../shared/errors/GyroViewError.js";
+import { RecordType } from "../constants.js";
+import { parseInfoRecord } from "./parseInfoRecord.js";
+//#region ../../packages/core/src/domain/format/info/readInfoRecord.ts
+/**
+* The info record every camera recording carries, from where the trailer says it lies.
+*/
+async function readInfoRecord(source, trailer) {
+	const location = trailer.locationOf(RecordType.Info);
+	if (!location) throw new GyroViewError("no-info-record", "the trailer has no info record; the file is not a camera recording");
+	return parseInfoRecord(await source.read(location.payload), location.format);
+}
+//#endregion
+export { readInfoRecord };