@bubo-squared/gyroview 0.4.1 → 0.5.0

package/CHANGELOG.md

@@ -3,6 +3,53 @@
 What changed for a page using the package, newest first. Until 1.0, a minor version may change
 the API.
 
+## 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:
+
+- Dragging, pinching or turning the wheel over a playing recording draws the picture once per
+  animation frame: in Safari, a fast mouse no longer slows the recording down. A change of the
+  view, the view mode, the quality or the exposure matching shows at the next animation frame
+  rather than at the call (ADR 0035).
+- Opening a recording keeps the page busy for less time: its gyro is read and integrated in two
+  thirds of the time.
+- Playing takes less of the page's main thread: the download plans what to fetch every few
+  mebibytes rather than at every frame (ADR 0036).
+- A bundle that includes the package is smaller: mediabunny's demuxers for formats other than
+  MP4 and QuickTime are left out. The standalone module is about 40 KB smaller compressed.
+
 ## 0.4.1 (2026-10-01)
 
 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.
@@ -40,15 +40,15 @@ times a second while playing, as a media element's does; `frame` comes with ever
 drawn.
 
 A page without a bundler loads the standalone file, which has Three.js and mediabunny inside
-(about 280 KB compressed) and registers the element; it exports what the package does:
+(about 260 KB compressed) and registers the element; it exports what the package does:
 
 ```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.5/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.5/dist/standalone.js';
 </script>
 ```
 

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

@@ -1,10 +1,16 @@
 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 { ALL_FORMATS, BufferSource, Input } from "mediabunny";
+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
@@ -13,7 +19,7 @@ import { ALL_FORMATS, BufferSource, Input } from "mediabunny";
 var MediabunnyCodecReader = class {
 	async read(movieBytes) {
 		const input = new Input({
-			formats: ALL_FORMATS,
+			formats: MOVIE_FORMATS,
 			source: new BufferSource(movieBytes)
 		});
 		try {
@@ -40,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/adapters/three/src/ThreeFrameRenderer.js

@@ -5,6 +5,7 @@ import { aspectOf } from "../../../core/src/domain/view/screenLayout.js";
 import { DEFAULT_FRAMING } from "../../../core/src/domain/view/Framing.js";
 import { viewModeRulesFor } from "../../../core/src/domain/view/viewModes.js";
 import "../../../core/src/index.js";
+import { DRAW_AT_ONCE } from "./drawSchedules.js";
 import { MatrixCorrections } from "./matrixCorrections.js";
 import { SAMPLING_STRATEGIES } from "./samplingStrategies.js";
 import { applyLensGain, applyPicture, applyShaderSampling, applyStabilization, createRendererUniforms } from "./rendererUniforms.js";
@@ -58,7 +59,10 @@ var ThreeFrameRenderer = class {
 		ensureDrawable(setup);
 		const renderer = createRenderer(canvas, opening.options);
 		try {
-			return assembleParts(renderer, setup, opening.pictures);
+			return {
+				...assembleParts(renderer, setup, opening.pictures),
+				drawSchedule: opening.options.drawSchedule ?? DRAW_AT_ONCE
+			};
 		} catch (error) {
 			renderer.dispose();
 			throw error;
@@ -71,17 +75,17 @@ var ThreeFrameRenderer = class {
 		this.ensureLive();
 		this.framing = framing;
 		this.applyFraming();
-		this.render();
+		this.redraw();
 	}
 	setViewMode(mode) {
 		this.ensureLive();
 		this.viewMode = mode;
 		this.applyFraming();
-		this.render();
+		this.redraw();
 	}
 	/**
-	* The frames standing on screen are uploaded again with the new filters and mip chain, so the
-	* change shows at once, even while paused.
+	* The frames standing on screen are uploaded again with the new filters and mip chain at the
+	* next draw, so the change shows even while paused.
 	*/
 	setQuality(quality) {
 		this.ensureLive();
@@ -91,12 +95,12 @@ var ThreeFrameRenderer = class {
 			if (this.hasFrames) texture.needsUpdate = true;
 		}
 		applyShaderSampling(this.parts.uniforms, strategy);
-		this.render();
+		this.redraw();
 	}
 	setLensGains(gains) {
 		this.ensureLive();
 		for (const [lensIndex, gain] of gains.entries()) applyLensGain(this.parts.uniforms, lensIndex, gain);
-		this.render();
+		this.redraw();
 	}
 	/**
 	* The meter leaves this renderer's list when disposed; the renderer disposes those still live
@@ -130,7 +134,7 @@ var ThreeFrameRenderer = class {
 		}
 		this.parts.matrixCorrections.follow(frames.map((frame) => frame.handle));
 		this.hasFrames = true;
-		this.render();
+		this.drawNow();
 	}
 	/**
 	* Matches the drawing buffer to a new element size, in device pixels.
@@ -139,11 +143,12 @@ var ThreeFrameRenderer = class {
 		this.ensureLive();
 		this.parts.renderer.setSize(size.width, size.height, false);
 		this.applyFraming();
-		this.render();
+		this.drawNow();
 	}
 	dispose() {
 		if (this.isDisposed) return;
 		this.isDisposed = true;
+		this.parts.drawSchedule.cancel();
 		this.canvas.removeEventListener("webglcontextrestored", this.onContextRestored);
 		for (const meter of this.meters) meter.dispose();
 		this.parts.seamProof.dispose();
@@ -176,9 +181,11 @@ var ThreeFrameRenderer = class {
 		this.meters.add(kept);
 		return kept;
 	}
-	render() {
-		if (!this.hasFrames) return;
-		this.parts.renderer.render(this.parts.scene, this.parts.camera);
+	/**
+	* Draws the picture again for a changed setting, when the draw schedule says.
+	*/
+	redraw() {
+		this.parts.drawSchedule.request(this.draw);
 	}
 	ensureLive() {
 		ensureInvariant(!this.isDisposed, "the renderer has been disposed");
@@ -189,7 +196,19 @@ var ThreeFrameRenderer = class {
 	* uploads the frames on screen again.
 	*/
 	onContextRestored = () => {
-		this.render();
+		this.redraw();
+	};
+	/**
+	* Draws now what a draw asked for of the schedule would have drawn, which then has nothing left
+	* to draw.
+	*/
+	drawNow() {
+		this.parts.drawSchedule.cancel();
+		this.draw();
+	}
+	draw = () => {
+		if (!this.hasFrames) return;
+		this.parts.renderer.render(this.parts.scene, this.parts.camera);
 	};
 	/**
 	* Asks the view mode what to draw for the framing on this canvas, and switches to that

package/dist/packages/adapters/three/src/drawSchedules.js

@@ -0,0 +1,13 @@
+//#region ../../packages/adapters/three/src/drawSchedules.ts
+/**
+* Draws every change at once, for whoever reads the canvas right after a change, as the tests
+* and the measurements do.
+*/
+var DRAW_AT_ONCE = {
+	request: (draw) => {
+		draw();
+	},
+	cancel: () => {}
+};
+//#endregion
+export { DRAW_AT_ONCE };

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

@@ -1,2 +1,3 @@
+import "./drawSchedules.js";
 import { ThreeFrameRenderer } from "./ThreeFrameRenderer.js";
 export { ThreeFrameRenderer };

package/dist/packages/core/src/application/download/FileDownload.js

@@ -10,10 +10,12 @@ import { planDownloads } from "../../domain/download/planDownloads.js";
 var EVERY_BYTE = ByteRange.of(0, Number.MAX_SAFE_INTEGER);
 /**
 * One file of a recording downloaded while it plays (ADR 0029): the only reader of its bytes.
-* Its cursors say where the readers of its tracks stand; whenever that changes, or a range comes
-* whole, it plans anew, once per turn, what to ask for, give up and let go of, and hands each
-* waiting cursor its sample once the bytes have come. A range that failed is not asked for again
-* until a cursor opens, a seek or a replay, lest a failing server be asked without end.
+* Its cursors say where the readers of its tracks stand. It plans anew, once per turn, what to
+* ask for, give up and let go of when a cursor opens, closes or waits for bytes no transfer
+* brings, once the cursors have moved on by the policy's replan bytes (ADR 0036), when a range
+* comes whole or fails, and when reading ahead starts; it hands each waiting cursor its sample
+* once the bytes have come. A range that failed is not asked for again until a cursor opens, a
+* seek or a replay, lest a failing server be asked without end.
 */
 var FileDownload = class {
 	parts;
@@ -26,6 +28,10 @@ var FileDownload = class {
 	anchor;
 	isReadingAhead = false;
 	isPlanDue = false;
+	/**
+	* What the readers have taken since the last plan.
+	*/
+	takenSincePlan = 0;
 	isDisposed = false;
 	constructor(parts) {
 		this.parts = parts;
@@ -101,8 +107,12 @@ var FileDownload = class {
 		return {
 			bytesOf: (range) => this.store.bytesOf(range),
 			failureOf: (range) => this.failures.find((failed) => failed.range.overlaps(range))?.error,
-			changed: () => {
-				this.schedulePlan();
+			movedOn: (length) => {
+				this.takenSincePlan += length;
+				if (this.takenSincePlan >= this.parts.policy.replanBytes) this.schedulePlan();
+			},
+			waiting: (range) => {
+				if (!this.transfers.isBringing(range)) this.schedulePlan();
 			},
 			closed: (cursor) => {
 				this.cursors.delete(cursor);
@@ -141,6 +151,7 @@ var FileDownload = class {
 		for (const cursor of this.cursors) cursor.fail(EVERY_BYTE, error);
 	}
 	plan() {
+		this.takenSincePlan = 0;
 		const decisions = planDownloads({
 			cursors: this.positions(),
 			held: this.store.held,

package/dist/packages/core/src/application/download/SampleCursor.js

@@ -37,7 +37,7 @@ var SampleCursor = class {
 		const bytes = this.host.bytesOf(range);
 		if (bytes) return Promise.resolve(this.take(bytes));
 		const failure = this.host.failureOf(range);
-		return failure === void 0 ? this.waitForBytes() : Promise.reject(failure);
+		return failure === void 0 ? this.waitForBytes(range) : Promise.reject(failure);
 	}
 	/**
 	* Bytes came: hands the awaited sample on if they were its.
@@ -65,19 +65,19 @@ var SampleCursor = class {
 		this.waiter = void 0;
 		this.host.closed(this);
 	}
-	waitForBytes() {
+	waitForBytes(range) {
 		return new Promise((resolve, reject) => {
 			this.waiter = {
 				resolve,
 				reject
 			};
-			this.host.changed();
+			this.host.waiting(range);
 		});
 	}
 	take(bytes) {
 		const sample = this.next;
 		this.next += 1;
-		this.host.changed();
+		this.host.movedOn(bytes.byteLength);
 		return {
 			sample,
 			bytes

package/dist/packages/core/src/application/download/Transfers.js

@@ -17,6 +17,13 @@ var Transfers = class {
 			remaining: remainingOf(transfer)
 		}));
 	}
+	/**
+	* Whether every byte of `range` has come or is coming in one range still streaming.
+	*/
+	isBringing(range) {
+		for (const transfer of this.running.values()) if (transfer.block.range.contains(range)) return true;
+		return false;
+	}
 	start(range) {
 		const transfer = {
 			id: this.nextId,

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/download/DownloadPolicy.js

@@ -15,6 +15,13 @@ var REQUESTS_IN_FLIGHT = 2;
 var BRIDGED_GAP_MEBIBYTES = 1;
 var REFILL_FRACTION = .25;
 /**
+* Planning walks every sample in the window, a few thousand on a fast recording; made for each
+* sample read, it took more of the main thread than drawing the frames (ADR 0036). Sixteen plans
+* a refill keep a top-up within a sixteenth of a refill of falling due, and make about a dozen
+* plans a second on the X5's recordings where there were 170.
+*/
+var REPLANS_PER_REFILL = 16;
+/**
 * Long enough that a link slower than the recording plays in stretches rather than frame by
 * frame, short enough that the wait does not feel like a stop.
 */
@@ -25,6 +32,7 @@ var RESUME_SECONDS = 4;
 function downloadPolicyFor(file, fileCount) {
 	const bytesPerSecond = file.size / file.duration;
 	const aheadBytes = Math.min(Math.round(AHEAD_SECONDS * bytesPerSecond), MOST_AHEAD_MEBIBYTES * MEBIBYTE / fileCount);
+	const refillBytes = Math.round(aheadBytes * REFILL_FRACTION);
 	return {
 		aheadSeconds: seconds(AHEAD_SECONDS),
 		aheadBytes,
@@ -33,7 +41,8 @@ function downloadPolicyFor(file, fileCount) {
 		requestSize: REQUEST_MEBIBYTES * MEBIBYTE,
 		requestsInFlight: REQUESTS_IN_FLIGHT,
 		bridgedGap: BRIDGED_GAP_MEBIBYTES * MEBIBYTE,
-		refillBytes: Math.round(aheadBytes * REFILL_FRACTION),
+		refillBytes,
+		replanBytes: Math.round(refillBytes / REPLANS_PER_REFILL),
 		resumeSeconds: seconds(RESUME_SECONDS)
 	};
 }

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/format/records/gyro/SampleColumns.js

@@ -19,10 +19,17 @@ var SampleColumns = class {
 		this.accelerations = new Float32Array(capacity * 3);
 		this.angularVelocities = new Float32Array(capacity * 3);
 	}
+	/**
+	* Component by component: `set` from an array of three takes a generic path several times
+	* slower, once per sample of an hour-long record.
+	*/
 	push(sample) {
+		const base = this.length * 3;
 		this.recordedTimes[this.length] = sample.captureTime;
-		this.accelerations.set(sample.acceleration, this.length * 3);
-		this.angularVelocities.set(sample.angularVelocity, this.length * 3);
+		for (let axis = 0; axis < 3; axis += 1) {
+			this.accelerations[base + axis] = sample.acceleration[axis] ?? NaN;
+			this.angularVelocities[base + axis] = sample.angularVelocity[axis] ?? NaN;
+		}
 		this.length += 1;
 	}
 	/**