@bubo-squared/gyroview 0.4.2 → 0.6.0

package/CHANGELOG.md

@@ -3,6 +3,60 @@
 What changed for a page using the package, newest first. Until 1.0, a minor version may change
 the API.
 
+## 0.6.0 (2026-10-05)
+
+New:
+
+- Motion look: on a phone or tablet, a toggle in the normal view lets the device turn the view, the
+  screen a window into the recording with its horizon level with the real one (ADR 0040). The
+  element and the player have `motionLook` (`on`, `off` or `unavailable`), `startMotionLook()`,
+  which iOS honours only from a tap's handler, and `stopMotionLook()`; `motionlookchange` reports
+  it, and the warnings `motion-look-refused` and `motion-look-needs-gesture` say why it did not
+  start.
+
+What a page may notice:
+
+- `PlayerEvents`, `GyroViewElementEventMap` and `WarningCode` have the new event and codes; a
+  record keyed on every event or code needs them.
+- `view` and `viewchange` give a fresh object of `yaw`, `pitch` and `fieldOfView` each time.
+- The iframe the snippet creates allows `accelerometer; gyroscope; magnetometer`; a hand-written
+  iframe needs them for motion look. Without them, Chromium offers no toggle; iOS offers it and
+  refuses at the first press (`motion-look-refused`).
+- On the narrowest players with the motion look toggle shown, the Stabilization menu gives way
+  to it.
+
+## 0.5.0 (2026-10-03)
+
+New:
+
+- Antigravity A1 recordings play. The A1 leaves the profile, tier and level of its HEVC
+  configuration blank, so the codec string is read from the stream's SPS instead (ADR 0037), and
+  its IMU frame is measured (ADR 0009): the `ready` event's `imuFrame` is
+  `{ name: 'A1', isVerified: true }`.
+
+What a page may notice:
+
+- An HEVC recording's codec in the `ready` event's `tracks[].codec` begins with the track's
+  sample entry type, `hvc1` on every camera seen, where it began with `hev1`; its profile, tier
+  and level are unchanged (ADR 0037).
+- `off` and `follow` stand a recording upright as its camera stood, where its IMU frame is
+  measured (ADR 0038). An X3, X4 Air, X5 or X6 held upright on a stick or a tripod, its usual
+  pose, holds its body frame a quarter turn from upright, and these modes drew its recordings
+  turned a quarter turn; a camera upside down or with its lens axis vertical stands upright too.
+  Under `horizon`, such a camera's view keeps its heading while the camera pitches.
+- An Insta360 X3 recording is stabilized about the right axes: its IMU frame is measured
+  (ADR 0009). The `ready` event's `imuFrame` is `{ name: 'X3', isVerified: true }` where it was
+  the unverified aligned frame, the load no longer warns that it has not been verified, and an
+  X3 on a stick or a tripod stands upright in `off` and `follow` too.
+- An Insta360 ONE RS recording stands upright under `lock` and `horizon`, which turned it on its
+  side. Its IMU frame is assumed from one recording of a camera that never turned: `imuFrame` is
+  `{ name: 'ONE RS (unverified)', isVerified: false }`, and the load still warns.
+- The view opens where Insta360 Studio centres the recording, in every mode: a half turn from
+  lens 0, where it opened, for a camera whose lens axis lies level, and a quarter turn from lens 0
+  for one whose lens axis is vertical, as the A1's (ADR 0038, ADR 0039). `yaw` 0 looks there: a
+  page that set `yaw` to face a direction faces the opposite one on a level camera until it adds
+  180 degrees. The equirectangular panorama is centred as Studio's export is.
+
 ## 0.4.2 (2026-10-02)
 
 What a page may notice:

package/README.md

@@ -1,9 +1,9 @@
 # @bubo-squared/gyroview
 
-Play raw Insta360 `.insv` recordings (X3, X4, X5, X6) in the browser. `<gyro-view>` reads the
-camera's dual-fisheye file directly, over HTTP byte ranges or from a local file, decodes both
-lenses in hardware with WebCodecs, and stitches and gyro-stabilizes them on the GPU. No Insta360
-Studio export step.
+Play raw `.insv` recordings of Insta360 cameras (X3, X4, X5, X6, ONE RS) and the Antigravity A1
+in the browser. `<gyro-view>` reads the camera's dual-fisheye file directly, over HTTP byte
+ranges or from a local file, decodes both lenses in hardware with WebCodecs, and stitches and
+gyro-stabilizes them on the GPU. No Insta360 Studio export step.
 
 **Try it first:** [insv-player.com](https://insv-player.com/) plays `.insv` files with this
 package. Drop your own recording to check that your camera and browser work before you install.
@@ -45,10 +45,10 @@ A page without a bundler loads the standalone file, which has Three.js and media
 ```html
 <script
   type="module"
-  src="https://cdn.jsdelivr.net/npm/@bubo-squared/gyroview@0.4/dist/standalone.js"
+  src="https://cdn.jsdelivr.net/npm/@bubo-squared/gyroview@0.6/dist/standalone.js"
 ></script>
 <script type="module">
-  import { inspectRecording } from 'https://cdn.jsdelivr.net/npm/@bubo-squared/gyroview@0.4/dist/standalone.js';
+  import { inspectRecording } from 'https://cdn.jsdelivr.net/npm/@bubo-squared/gyroview@0.6/dist/standalone.js';
 </script>
 ```
 

package/dist/index.d.ts

@@ -418,8 +418,9 @@ export interface ViewAngles {
 	readonly fieldOfView: number;
 }
 /**
- * What concerns one load only. The settings (view, view mode, stabilization, gain matching,
- * sound, loop) belong to the player and carry over from load to load; set them on the player.
+ * What concerns one load only. The settings (view, view mode, motion look, stabilization, gain
+ * matching, sound, loop) belong to the player and carry over from load to load; set them on the
+ * player.
  */
 export interface LoadOptions {
 	/**
@@ -436,6 +437,11 @@ export interface LoadOptions {
  * The session's states plus the two only the player knows: nothing loaded, and loading.
  */
 export type PlayerStatus = "idle" | "loading" | PlayerState;
+/**
+ * Motion look as it stands: `unavailable` where the device reports no attitude or access was
+ * refused, `off`, or `on`, the device turning the normal view (ADR 0040).
+ */
+export type MotionLookState = "unavailable" | "off" | "on";
 /**
  * The sound as it is now: volume from 0 to 1, and whether it is muted.
  */
@@ -453,8 +459,12 @@ export interface SoundLevel {
  * - `playback-failed`: a start (a press, autoplay, the loop) or the seek bar's preview failed.
  * - `ignored-attribute`: an attribute's value names nothing the element knows; the setting stays.
  * - `refused-property`: a property set before the element was defined was refused.
+ * - `motion-look-refused`: the viewer, or an iframe's `allow`, refused access to the device's
+ *   attitude; motion look is unavailable.
+ * - `motion-look-needs-gesture`: motion look was started outside a user gesture, where iOS does
+ *   not ask; it stays off.
  */
-export type WarningCode = "recording-degraded" | "no-sound" | "autoplay-blocked" | "playback-failed" | "ignored-attribute" | "refused-property";
+export type WarningCode = "recording-degraded" | "no-sound" | "autoplay-blocked" | "playback-failed" | "ignored-attribute" | "refused-property" | "motion-look-refused" | "motion-look-needs-gesture";
 export interface PlayerWarning {
 	readonly code: WarningCode;
 	/**
@@ -488,6 +498,7 @@ export interface PlayerEvents {
 	readonly frame: number;
 	readonly viewchange: ViewAngles;
 	readonly viewmodechange: ViewMode;
+	readonly motionlookchange: MotionLookState;
 	readonly stabilizationchange: StabilizationMode;
 	/**
 	 * The picture quality changed, to the one named.
@@ -506,8 +517,8 @@ export interface PlayerEvents {
 /**
  * The player without the element, which `createBrowserPlayer` gives: it plays one recording at a
  * time on the canvas and audio element it was handed, reports in media-element events, and keeps
- * its settings (view, view mode, stabilization, gain matching, sound, loop) from load to load.
- * `<gyro-view>` is a facade over it.
+ * its settings (view, view mode, motion look, stabilization, gain matching, sound, loop) from
+ * load to load. `<gyro-view>` is a facade over it.
  */
 export declare class Player {
 	private readonly parts;
@@ -519,6 +530,7 @@ export declare class Player {
 	private readonly loop;
 	private phase;
 	private readonly viewing;
+	private readonly motion;
 	private readonly picture;
 	/**
 	 * A seek asked for before a recording was ready, where the next one starts.
@@ -526,7 +538,7 @@ export declare class Player {
 	private pendingStartTime;
 	private readonly sound;
 	private readonly relay;
-	private isLoopingValue;
+	private readonly starts;
 	/**
 	 * Past `dispose`: a listener of the idle it announces must not load again.
 	 */
@@ -549,6 +561,11 @@ export declare class Player {
 	 * Whether a drag moves the picture as it is framed now; the view mode decides.
 	 */
 	get canPan(): boolean;
+	/**
+	 * Whether turning the device turns the normal view: `unavailable` where the device reports no
+	 * attitude or access was refused.
+	 */
+	get motionLook(): MotionLookState;
 	get stabilization(): StabilizationMode;
 	get quality(): PictureQuality;
 	get isLooping(): boolean;
@@ -604,6 +621,17 @@ export declare class Player {
 	zoom(steps: number, focus?: ScreenPoint): void;
 	resetView(): void;
 	setViewMode(mode: ViewMode): void;
+	/**
+	 * Lets the device turn the normal view, as a window into the recording: its tilt and roll
+	 * hold the pitch and keep the horizon level, drags turn the heading alone. Call it from a tap's
+	 * handler: iOS asks the viewer for access there and refuses it anywhere else. Resolves with the
+	 * state it ends in; a refusal is a warning, never a rejection.
+	 */
+	startMotionLook(): Promise<MotionLookState>;
+	/**
+	 * Gives the view back to the pointer, level, looking where it looked.
+	 */
+	stopMotionLook(): void;
 	setStabilization(mode: StabilizationMode): void;
 	/**
 	 * How finely the lens images are read and how many device pixels are drawn; kept across loads.
@@ -626,12 +654,6 @@ export declare class Player {
 	private complete;
 	private startAtPendingTime;
 	private attach;
-	/**
-	 * A refused start leaves the recording loaded and paused: a warning, never a failed load.
-	 */
-	private autoplay;
-	private onEnded;
-	private replay;
 	/**
 	 * Lets go of whatever is loading or loaded, announcing nothing.
 	 */
@@ -664,6 +686,10 @@ export interface GyroViewLabels {
 	readonly mute: string;
 	readonly volume: string;
 	readonly resetView: string;
+	/**
+	 * The toggle that lets the device's own turns turn the normal view.
+	 */
+	readonly motionLook: string;
 	readonly stabilization: string;
 	readonly viewMode: string;
 	readonly fullscreen: string;
@@ -792,9 +818,9 @@ export interface BrowserPortsOptions {
 	readonly probeTimeoutMs?: number;
 }
 /**
- * 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.
+ * A player composed for a browser: HTTP, blob and WebCodecs ports, the GPU pipeline and the
+ * device's attitude, 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.
  */
 export declare function createBrowserPlayer(host: PipelineHost, options?: BrowserPortsOptions): Player;
 export interface InspectOptions extends Pick<BrowserPortsOptions, "http"> {
@@ -903,6 +929,11 @@ export declare class GyroViewElement extends TypedEventElement implements LiveSe
 	 * Where the normal view looks: yaw and pitch in degrees, and the horizontal field of view.
 	 */
 	get view(): ViewAngles;
+	/**
+	 * Whether turning the device turns the normal view: `on`, `off`, or `unavailable` where the
+	 * device reports no attitude or access was refused.
+	 */
+	get motionLook(): MotionLookState;
 	/**
 	 * Every word the element shows or says to assistive technology. Setting it replaces any of
 	 * them, table by table (`labels`, `stabilizationModes`, `viewModes`, `errors`); the others keep
@@ -949,6 +980,16 @@ export declare class GyroViewElement extends TypedEventElement implements LiveSe
 	 * when none is given.
 	 */
 	zoom(steps: number, focus?: ScreenPoint): void;
+	/**
+	 * Lets the device turn the normal view, as a window into the recording. Call it from a tap's
+	 * handler: iOS asks the viewer for access there and refuses it anywhere else. Resolves with the
+	 * state it ends in (`motionLook`); a refusal is a `warning`, never a rejection.
+	 */
+	startMotionLook(): Promise<MotionLookState>;
+	/**
+	 * Gives the view back to the pointer, level, looking where it looked.
+	 */
+	stopMotionLook(): void;
 	/**
 	 * Stabilizes the picture in `mode` (`off`, `lock`, `horizon`, `follow`); any other value,
 	 * an unset one included, is refused.

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

@@ -1,6 +1,6 @@
 import { GyroViewError, isAbortError } from "../../../core/src/shared/errors/GyroViewError.js";
 import "../../../core/src/index.js";
-import { audioConfigurationOf, videoConfigurationOf } from "./decoderConfigurations.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
@@ -46,7 +46,7 @@ async function videoCodecOf(track, trackIndex) {
 		trackIndex,
 		codedWidth,
 		codedHeight,
-		codec: config.codec,
+		codec: await codecStringOf(track, config),
 		colour: trackColourOf(config.colorSpace)
 	};
 	return {

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

@@ -1,12 +1,28 @@
+import { hevcCodecStringOf } from "../../../core/src/domain/format/mp4/hevcCodecString.js";
+import "../../../core/src/index.js";
 import { copyOfBytes } from "./bufferSources.js";
 //#region ../../packages/adapters/mediabunny/src/decoderConfigurations.ts
 /**
-* A WebCodecs video decoder configuration in the core's terms; the coded size comes from the
-* track where the configuration leaves it out, the colour from the track's description.
+* 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: config.codec,
+		codec: description.codec,
 		codedWidth: config.codedWidth ?? description.codedWidth,
 		codedHeight: config.codedHeight ?? description.codedHeight,
 		description: config.description === void 0 ? void 0 : copyOfBytes(config.description),
@@ -25,4 +41,4 @@ function audioConfigurationOf(config) {
 	};
 }
 //#endregion
-export { audioConfigurationOf, videoConfigurationOf };
+export { audioConfigurationOf, codecStringOf, videoConfigurationOf };

package/dist/packages/core/src/application/recording/motionOf.js

@@ -1,4 +1,5 @@
 import { imuFrameFor } from "../../domain/motion/imu/ImuFrame.js";
+import { mountingOf, uprightImuFrame } from "../../domain/motion/mounting/Mounting.js";
 import { OrientationTrack } from "../../domain/motion/orientation/OrientationTrack.js";
 //#region ../../packages/core/src/application/recording/motionOf.ts
 var NO_GYRO_WARNING = "the recording has no gyro record; stabilization is unavailable";
@@ -14,15 +15,18 @@ async function motionOf(recording, clock) {
 		warnings: [NO_GYRO_WARNING]
 	};
 	const imuFrame = imuFrameFor(recording.info);
+	const mounting = mountingOf(gyro.track, imuFrame);
+	const frame = uprightImuFrame(imuFrame, mounting);
 	const orientations = OrientationTrack.integrate({
 		gyro: gyro.track,
 		clock,
-		frame: imuFrame
+		frame
 	});
 	const warnings = [...unverifiedWarningsOf(imuFrame, recording), ...damageWarningsOf(gyro)];
 	return {
 		setup: {
 			orientations,
+			mounting,
 			imuFrame
 		},
 		warnings

package/dist/packages/core/src/application/stabilization/StabilizingFrameSink.js

@@ -1,3 +1,4 @@
+import { rotationIntoBody } from "../../domain/motion/mounting/Mounting.js";
 import { OffStabilization } from "../../domain/motion/stabilization/stabilizers.js";
 //#region ../../packages/core/src/application/stabilization/StabilizingFrameSink.ts
 /**
@@ -15,8 +16,9 @@ var StabilizingFrameSink = class {
 	}
 	present(presentation) {
 		const time = this.exposureTimeOf(presentation);
-		const orientation = this.parts.orientations.orientationAt(time);
-		this.parts.sink.setStabilization(this.stabilizer.nextRotation(orientation, time));
+		const { orientations, mounting } = this.parts.motion;
+		const rotation = this.stabilizer.nextRotation(orientations.orientationAt(time), time);
+		this.parts.sink.setStabilization(rotationIntoBody(mounting, rotation));
 		this.parts.sink.present(presentation);
 	}
 	/**

package/dist/packages/core/src/domain/format/mp4/hevcCodecString.js

@@ -0,0 +1,161 @@
+import { hasErrorCode } from "../../../shared/errors/GyroViewError.js";
+import { ByteReader } from "../../../shared/binary/ByteReader.js";
+//#region ../../packages/core/src/domain/format/mp4/hevcCodecString.ts
+/**
+* The general part of profile_tier_level (ITU-T H.265 §7.3.3), as an SPS carries it and an HEVC
+* configuration's header repeats it: two bits of profile space, the tier flag and five bits of
+* profile; 32 compatibility flags; 48 bits of constraint flags; the level.
+*/
+var PROFILE_SPACE_SHIFT = 6;
+var HIGH_TIER_FLAG = 32;
+var PROFILE_MASK = 31;
+var COMPATIBILITY_FLAGS_OFFSET = 1;
+var CONSTRAINT_FLAGS_OFFSET = 5;
+var CONSTRAINT_FLAGS_LENGTH = 6;
+var LEVEL_OFFSET = 11;
+var COMPATIBILITY_FLAG_COUNT = 32;
+/**
+* No profile has the number zero (ITU-T H.265 Annex A): a header naming it was left blank.
+*/
+var NO_PROFILE = 0;
+/**
+* An SPS (NAL unit type 33, ITU-T H.265 Table 7-1) opens with its two-byte NAL unit header and
+* a byte of parameter-set id, sub-layer count and nesting flag; its profile_tier_level follows
+* (§7.3.2.2.1).
+*/
+var SPS_NAL_UNIT_TYPE = 33;
+var SPS_PROFILE_TIER_LEVEL_OFFSET = 3;
+/**
+* Inside a NAL unit, the encoder writes an emulation_prevention_three_byte after two zero bytes
+* that a byte of 0 to 3 would follow, and the decoder drops it (ITU-T H.265 §7.4.2). The SPS's
+* flags are mostly zeros, so they hold such bytes, and are read with them dropped.
+*/
+var EMULATION_PREVENTION_BYTE = 3;
+var ZEROS_BEFORE_EMULATION_PREVENTION = 2;
+/**
+* ISO/IEC 14496-15 Annex E.3: the profile space as no letter or A to C, the tier as L or H, the
+* flags in hexadecimal.
+*/
+var PROFILE_SPACE_CODES = [
+	"",
+	"A",
+	"B",
+	"C"
+];
+var MAIN_TIER_CODE = "L";
+var HIGH_TIER_CODE = "H";
+var HEXADECIMAL = 16;
+/**
+* The WebCodecs codec string of an HEVC track (ISO/IEC 14496-15 Annex E.3), from its sample
+* entry type and its configuration (the `hvcC` box's payload). The configuration's header is
+* meant to repeat the profile, tier and level of the stream's SPS; where it names no profile, as
+* the Antigravity A1 leaves it, the SPS the configuration carries is read instead, since browsers
+* refuse a codec string without a profile although they decode the stream.
+*/
+function hevcCodecStringOf(sampleEntryType, configuration) {
+	return codecStringOf(sampleEntryType, declaredProfileTierLevelOf(configuration));
+}
+function declaredProfileTierLevelOf(configuration) {
+	const header = profileTierLevelAt(new ByteReader(configuration), 1);
+	return header.profile === NO_PROFILE ? spsProfileTierLevelIn(configuration) ?? header : header;
+}
+/**
+* The profile, tier and level of the first SPS the configuration carries; undefined where it
+* carries none, or where its parameter sets run past its end. The header's blank string then
+* stands, which browsers refuse as a codec they do not support.
+*/
+function spsProfileTierLevelIn(configuration) {
+	try {
+		const sps = spsIn(configuration);
+		return sps === void 0 ? void 0 : spsProfileTierLevelOf(sps);
+	} catch (error) {
+		if (hasErrorCode(error, "binary-out-of-bounds")) return void 0;
+		throw error;
+	}
+}
+function profileTierLevelAt(reader, offset) {
+	const first = reader.uint8At(offset);
+	return {
+		profileSpace: first >> PROFILE_SPACE_SHIFT,
+		isHighTier: (first & HIGH_TIER_FLAG) !== 0,
+		profile: first & PROFILE_MASK,
+		compatibilityFlags: reader.uint32BeAt(offset + COMPATIBILITY_FLAGS_OFFSET),
+		constraintFlags: [...reader.bytesAt(offset + CONSTRAINT_FLAGS_OFFSET, CONSTRAINT_FLAGS_LENGTH)],
+		level: reader.uint8At(offset + LEVEL_OFFSET)
+	};
+}
+function spsProfileTierLevelOf(sps) {
+	return profileTierLevelAt(new ByteReader(withoutEmulationPrevention(sps)), SPS_PROFILE_TIER_LEVEL_OFFSET);
+}
+/**
+* The first SPS among the configuration's parameter sets; undefined where it carries none, as an
+* `hev1` track may, keeping its parameter sets in the stream.
+*/
+function spsIn(configuration) {
+	const reader = new ByteReader(configuration);
+	let offset = 23;
+	for (let index = 0; index < reader.uint8At(22); index += 1) {
+		const array = parameterSetArrayAt(reader, offset);
+		const [sps] = array.nalUnitType === SPS_NAL_UNIT_TYPE ? array.nalUnits : [];
+		if (sps !== void 0) return sps;
+		offset = array.end;
+	}
+}
+function parameterSetArrayAt(reader, offset) {
+	const nalUnitType = reader.uint8At(offset) & 63;
+	const count = reader.uint16BeAt(offset + 1);
+	const nalUnits = [];
+	let unitOffset = offset + 3;
+	for (let index = 0; index < count; index += 1) {
+		const length = reader.uint16BeAt(unitOffset);
+		nalUnits.push(reader.bytesAt(unitOffset + 2, length));
+		unitOffset += 2 + length;
+	}
+	return {
+		nalUnitType,
+		nalUnits,
+		end: unitOffset
+	};
+}
+/**
+* A NAL unit as the decoder reads it, its emulation prevention bytes dropped.
+*/
+function withoutEmulationPrevention(nalUnit) {
+	const kept = [];
+	let zeros = 0;
+	for (const byte of nalUnit) {
+		if (!(zeros >= ZEROS_BEFORE_EMULATION_PREVENTION && byte === EMULATION_PREVENTION_BYTE)) kept.push(byte);
+		zeros = byte === 0 ? zeros + 1 : 0;
+	}
+	return Uint8Array.from(kept);
+}
+function codecStringOf(sampleEntryType, declared) {
+	const profile = `${PROFILE_SPACE_CODES[declared.profileSpace] ?? ""}${declared.profile}`;
+	const tier = declared.isHighTier ? HIGH_TIER_CODE : MAIN_TIER_CODE;
+	const constraints = withoutTrailingZeros(declared.constraintFlags).map((byte) => hexadecimalOf(byte));
+	return [
+		sampleEntryType,
+		profile,
+		hexadecimalOf(reversedBitsOf(declared.compatibilityFlags)),
+		`${tier}${declared.level}`,
+		...constraints
+	].join(".");
+}
+/**
+* The compatibility flags as Annex E.3 writes them: flag 0, the configuration's most significant
+* bit, becomes the least significant.
+*/
+function reversedBitsOf(flags) {
+	let reversed = 0;
+	for (let bit = 0; bit < COMPATIBILITY_FLAG_COUNT; bit += 1) reversed = reversed << 1 | flags >>> bit & 1;
+	return reversed >>> 0;
+}
+function withoutTrailingZeros(bytes) {
+	const lastSet = bytes.findLastIndex((byte) => byte !== 0);
+	return bytes.slice(0, lastSet + 1);
+}
+function hexadecimalOf(value) {
+	return value.toString(HEXADECIMAL).toUpperCase();
+}
+//#endregion
+export { hevcCodecStringOf };

package/dist/packages/core/src/domain/motion/imu/ImuFrame.js

@@ -107,6 +107,34 @@ var X6_IMU_FRAME = measuredImuFrame("X6", QUARTER_TURN_ABOUT_LATERAL);
 */
 var X4_AIR_IMU_FRAME = measuredImuFrame("X4 Air", QUARTER_TURN_ABOUT_LATERAL);
 /**
+* Measured on one Antigravity A1 recording (ADR 0009): the drone's lens axis is its vertical, the
+* IMU's y, lens 0 facing up; the ranking puts this quarter turn about that axis first, the X5's
+* arrangement fourth.
+*/
+var A1_IMU_FRAME = measuredImuFrame("A1", [
+	"-z",
+	"-x",
+	"y"
+]);
+/**
+* Measured on one X3 recording (ADR 0009): the X5's arrangement again. The camera stood still on
+* its side, so the levelling ranking decided it rather than the stillness ranking: it alone of
+* the four that put gravity on the body's axis stands the picture as level as Studio's.
+*/
+var X3_IMU_FRAME = measuredImuFrame("X3", QUARTER_TURN_ABOUT_LATERAL);
+/**
+* Assumed for the ONE RS until a recording that turns is ranked (ADR 0009). On one tripod
+* recording of the 1-inch 360 edition, standing upright, gravity lies along the IMU's x, so the
+* body's down is the IMU's x; of the four arrangements that agree, the levelling ranking puts
+* this quarter turn about the lens axis first in both browsers, by too little to decide it. The
+* model name covers the 360 lens module too, assumed alike.
+*/
+var ONE_RS_IMU_FRAME = assumedImuFrame("ONE RS (unverified)", [
+	"-y",
+	"x",
+	"z"
+]);
+/**
 * Until a recording proves otherwise, the IMU is assumed aligned with the body.
 */
 var ALIGNED_IMU_FRAME = assumedImuFrame("aligned (unverified)", [
@@ -116,12 +144,16 @@ var ALIGNED_IMU_FRAME = assumedImuFrame("aligned (unverified)", [
 ]);
 /**
 * Keyed by the whole model name: a name that extends a measured one ("X4 Air" of "X4", an "X5
-* Pro") is another camera, unmeasured until a recording of it is ranked.
+* Pro") is another camera, unmeasured until a recording of it is ranked. Every frame is measured
+* but the ONE RS's, assumed and reported as such.
 */
 var IMU_FRAMES_BY_MODEL = /* @__PURE__ */ new Map([
+	["Antigravity A1", A1_IMU_FRAME],
+	["Insta360 X3", X3_IMU_FRAME],
 	["Insta360 X4 Air", X4_AIR_IMU_FRAME],
 	["Insta360 X5", X5_IMU_FRAME],
-	["Insta360 X6", X6_IMU_FRAME]
+	["Insta360 X6", X6_IMU_FRAME],
+	["Insta360 OneRS", ONE_RS_IMU_FRAME]
 ]);
 /**
 * The IMU frame for a recording, chosen from the camera model the file names. A starting point
@@ -131,4 +163,4 @@ function imuFrameFor(hints) {
 	return IMU_FRAMES_BY_MODEL.get(hints.model?.trim() ?? "") ?? ALIGNED_IMU_FRAME;
 }
 //#endregion
-export { ALIGNED_IMU_FRAME, X4_AIR_IMU_FRAME, X5_IMU_FRAME, X6_IMU_FRAME, assumedImuFrame, imuFrameFor, isProperRotation, toBodyFrame };
+export { A1_IMU_FRAME, ALIGNED_IMU_FRAME, ONE_RS_IMU_FRAME, X3_IMU_FRAME, X4_AIR_IMU_FRAME, X5_IMU_FRAME, X6_IMU_FRAME, assumedImuFrame, imuFrameFor, isProperRotation, toBodyFrame };