@bubo-squared/gyroview 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -3,6 +3,55 @@
 What changed for a page using the package, newest first. Until 1.0, a minor version may change
 the API.
 
+## 0.4.0 (2026-10-01)
+
+New:
+
+- Insta360 X6 recordings play. Their only calibration is a v6 string, now read as the Mei model
+  with more terms (ADR 0032); the X6's IMU frame and the radial scale its lenses want are
+  measured (ADR 0009, ADR 0023); and its 10-bit HLG video is shown as SDR, as Insta360 Studio
+  shows it (ADR 0033).
+- Each of the `ready` event's `tracks` has a `colour`: its primaries, transfer, matrix and range
+  as the track's bitstream says (`TrackColour`, with the types `ColourPrimaries`,
+  `TransferCharacteristics`, `MatrixCoefficients` and `ColourRange`).
+- `inspectRecording`'s calibration strings include `offsetV6`, and `calibrationVersion` may be
+  6, the v6 string's.
+
+What a page may notice:
+
+- A recording whose only calibration is a v6 string plays where it failed with
+  `no-calibration`.
+- Stabilization samples the gyro half way through each frame's shutter, no longer half a
+  readout later. An X5's stabilized picture shifts by that half readout (4 ms at 5.7K60, 10.6 ms
+  at 8K30), and a swinging camera's world holds stiller (ADR 0034).
+- A track whose colour the player cannot show as it should is drawn with a
+  `recording-degraded` warning: a PQ or linear-light transfer is drawn as recorded, SDR of wider
+  primaries than BT.709's is shown as BT.709, HLG of primaries other than BT.709's or BT.2020's
+  keeps its gamut.
+- The decoder is told the track's whole colour, not only its range (the range alone where the
+  browser's WebCodecs does not know one of its values).
+- Where a browser's decoder converts a track's colour through another matrix than the track's
+  own, as Safari's does with the X6's BT.2020, the picture is brought back to the track's.
+- Seeking again and again, or dragging the seek bar, no longer stops playback now and then with
+  `decode` ("the audio element failed (media error 3)"): the sound is handed to the browser in
+  whole segments, so a seek can no longer cut one in half.
+
+## 0.3.1 (2026-09-30)
+
+New:
+
+- Every error has a `category`, derived from its code, that says whose side the failure is on:
+  `browser`, `recording`, `source`, `usage` or `internal`; `GYRO_VIEW_ERROR_CATEGORIES` and the
+  type `GyroViewErrorCategory` list them. The README's "When a recording cannot play" gives the
+  codes of each, and what a `<video>` fallback can and cannot do (ADR 0030).
+- The `webcodecs-unavailable` error: the browser has no WebCodecs, on a page not served over
+  HTTPS or in an old browser.
+
+What a page may notice:
+
+- A page on plain HTTP, or a browser without WebCodecs, hears `webcodecs-unavailable` where it
+  heard `codec-unsupported`, whose message blamed the codec.
+
 ## 0.3.0 (2026-09-30)
 
 What a page may notice:

package/README.md

@@ -1,10 +1,13 @@
 # @bubo-squared/gyroview
 
-Play raw Insta360 `.insv` recordings (X3, X4, X5) in the browser. `<gyro-view>` reads the
+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.
 
+**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.
+
 ## Install
 
 ```sh
@@ -188,7 +191,8 @@ loads a recording only for the player in view, removing `src` from the others.
 
 ## Requirements
 
-- **A secure page.** WebCodecs exists only on `https://` pages, or `http://localhost`.
+- **A secure page.** WebCodecs exists only on `https://` pages, or `http://localhost`; elsewhere
+  the player fails with `webcodecs-unavailable`.
 - **Recordings served in byte ranges.** The server answers `Range` requests with `206`, and
   sends CORS headers when the recordings live on another origin than the page:
 
@@ -205,17 +209,20 @@ loads a recording only for the player in view, removing `src` from the others.
   `Access-Control-Allow-Credentials: true`.
 
 - **A hardware HEVC decoder.** 5.7K plays on recent laptops and phones; 8K needs a Level 6
-  decoder (Apple Silicon, recent NVIDIA and Intel). A recording the browser cannot decode fails
-  with the `codec-unsupported` error.
+  decoder (Apple Silicon, recent NVIDIA and Intel). On Linux, Chrome reaches the decoder only
+  through VA-API: an Intel or AMD GPU whose driver offers HEVC, not NVIDIA's own driver or a
+  virtual machine (`chrome://gpu` lists `Decode hevc main` under Video Acceleration
+  Information when it can). H.264 recordings do not need it. A recording the browser cannot
+  decode fails with the `codec-unsupported` error.
 
 The supported browsers, with the oldest versions that have what the player uses (WebCodecs,
 WebGL 2, container queries, and on iPhone `ManagedMediaSource` for the sound):
 
-| Browser               | From | Notes                                                    |
-| --------------------- | ---- | -------------------------------------------------------- |
-| Chrome, Edge desktop  | 107  | HEVC is decoded in hardware from this version on.        |
-| Safari on macOS       | 16.4 |                                                          |
-| Safari on iPhone/iPad | 17.1 | 16.4 to 17.0 play without sound, with a `warning` event. |
+| Browser               | From | Notes                                                             |
+| --------------------- | ---- | ----------------------------------------------------------------- |
+| Chrome, Edge desktop  | 107  | HEVC is decoded in hardware from this version on (Linux: VA-API). |
+| Safari on macOS       | 16.4 |                                                                   |
+| Safari on iPhone/iPad | 17.1 | 16.4 to 17.0 play without sound, with a `warning` event.          |
 
 Firefox and Chrome on Android are untested: they play what their decoders accept.
 
@@ -224,8 +231,10 @@ Until 1.0, a minor version may change the API; [CHANGELOG.md](./CHANGELOG.md) sa
 ## Reference
 
 Every attribute, method, event and keyboard shortcut is in the
-[project README](https://github.com/bubo-squared/GyroView#using-the-player); hosting and the
-error codes are in [docs/DEPLOYMENT.md](https://github.com/bubo-squared/GyroView/blob/main/docs/DEPLOYMENT.md).
+[project README](https://github.com/bubo-squared/GyroView#using-the-player), and what a failure
+tells a page, with what a `<video>` fallback can do, under
+[When a recording cannot play](https://github.com/bubo-squared/GyroView#when-a-recording-cannot-play);
+hosting and the error codes are in [docs/DEPLOYMENT.md](https://github.com/bubo-squared/GyroView/blob/main/docs/DEPLOYMENT.md).
 
 ## License
 

package/dist/index.d.ts

@@ -42,6 +42,7 @@ declare const CalibrationVersion: {
 	readonly Legacy: 1;
 	readonly Polynomial: 2;
 	readonly Mei: 3;
+	readonly ExtendedMei: 6;
 };
 type CalibrationVersion = (typeof CalibrationVersion)[keyof typeof CalibrationVersion];
 type Milliseconds = Brand<number, "Milliseconds">;
@@ -67,6 +68,7 @@ interface CalibrationStrings {
 	readonly offset: string | undefined;
 	readonly offsetV2: string | undefined;
 	readonly offsetV3: string | undefined;
+	readonly offsetV6: string | undefined;
 }
 /**
  * Everything the player learns from the info record. Absent fields are `undefined`; nothing here
@@ -225,6 +227,39 @@ export interface RecordingInspection {
 	readonly gyro: GyroSummary | UnreadableGyro | undefined;
 	readonly exposure: ExposureReport | undefined;
 }
+declare const COLOUR_PRIMARIES: readonly [
+	"bt709",
+	"bt470bg",
+	"smpte170m",
+	"bt2020",
+	"smpte432"
+];
+declare const TRANSFER_CHARACTERISTICS: readonly [
+	"bt709",
+	"smpte170m",
+	"iec61966-2-1",
+	"linear",
+	"pq",
+	"hlg"
+];
+declare const MATRIX_COEFFICIENTS: readonly [
+	"rgb",
+	"bt709",
+	"bt470bg",
+	"smpte170m",
+	"bt2020-ncl"
+];
+type Unspecified = "unspecified";
+export type ColourPrimaries = (typeof COLOUR_PRIMARIES)[number] | Unspecified;
+export type TransferCharacteristics = (typeof TRANSFER_CHARACTERISTICS)[number] | Unspecified;
+export type MatrixCoefficients = (typeof MATRIX_COEFFICIENTS)[number] | Unspecified;
+export type ColourRange = "full" | "limited" | Unspecified;
+export interface TrackColour {
+	readonly primaries: ColourPrimaries;
+	readonly transfer: TransferCharacteristics;
+	readonly matrix: MatrixCoefficients;
+	readonly range: ColourRange;
+}
 interface VideoTrackDescription {
 	readonly trackIndex: number;
 	readonly codedWidth: number;
@@ -233,6 +268,7 @@ interface VideoTrackDescription {
 	 * WebCodecs codec string, for example `hvc1.1.6.L153.B0` or `avc1.640033`.
 	 */
 	readonly codec: string;
+	readonly colour: TrackColour;
 }
 export type StabilizationMode = "off" | "lock" | "horizon" | "follow";
 export declare const STABILIZATION_MODES: readonly StabilizationMode[];
@@ -261,7 +297,7 @@ interface DragDelta {
 export type ViewMode = "raw-lenses" | "equirectangular" | "normal";
 export declare const VIEW_MODES: readonly ViewMode[];
 /**
- * Stable machine-readable failure categories. Embedders switch on these; messages are for humans.
+ * Stable machine-readable failure codes. Embedders switch on these; messages are for humans.
  */
 export declare const GYRO_VIEW_ERROR_CODES: readonly [
 	"binary-out-of-bounds",
@@ -291,12 +327,30 @@ export declare const GYRO_VIEW_ERROR_CODES: readonly [
 	"unsupported-container",
 	"unsupported-gyro-record",
 	"unsupported-info-format",
-	"unsupported-layout"
+	"unsupported-layout",
+	"webcodecs-unavailable"
 ];
 export type GyroViewErrorCode = (typeof GYRO_VIEW_ERROR_CODES)[number];
+/**
+ * Whose side a failure is on, for embedders that handle failures by kind: the browser cannot
+ * decode or draw the recording, the file is not one the player can play, its bytes could not be
+ * read, the page misused the API, or the player failed in a way it did not expect.
+ */
+export declare const GYRO_VIEW_ERROR_CATEGORIES: readonly [
+	"browser",
+	"recording",
+	"source",
+	"usage",
+	"internal"
+];
+export type GyroViewErrorCategory = (typeof GYRO_VIEW_ERROR_CATEGORIES)[number];
 export declare function isGyroViewErrorCode(value: unknown): value is GyroViewErrorCode;
 export declare class GyroViewError extends Error {
 	readonly code: GyroViewErrorCode;
+	/**
+	 * Its own property rather than a getter, so a serialized or logged copy of the error keeps it.
+	 */
+	readonly category: GyroViewErrorCategory;
 	constructor(code: GyroViewErrorCode, message: string, options?: ErrorOptions);
 }
 export declare function hasErrorCode(error: unknown, code: GyroViewErrorCode): boolean;

package/dist/index.js

@@ -1,4 +1,4 @@
-import { GYRO_VIEW_ERROR_CODES, GyroViewError, hasErrorCode, isGyroViewErrorCode } from "./packages/core/src/shared/errors/GyroViewError.js";
+import { GYRO_VIEW_ERROR_CATEGORIES, GYRO_VIEW_ERROR_CODES, GyroViewError, hasErrorCode, isGyroViewErrorCode } from "./packages/core/src/shared/errors/GyroViewError.js";
 import { STABILIZATION_MODES } from "./packages/core/src/domain/motion/stabilization/Stabilizer.js";
 import { PICTURE_QUALITIES } from "./packages/core/src/domain/view/PictureQuality.js";
 import { VIEW_MODES } from "./packages/core/src/domain/view/ViewMode.js";
@@ -10,4 +10,4 @@ import { inspectRecording } from "./packages/player/src/inspectRecording.js";
 import { GyroViewElement } from "./packages/player/src/element/GyroViewElement.js";
 import { GYRO_VIEW_TAG, defineGyroView } from "./packages/player/src/element/defineGyroView.js";
 import "./packages/player/src/index.js";
-export { GYRO_VIEW_ERROR_CODES, GYRO_VIEW_TAG, GyroViewElement, GyroViewError, PICTURE_QUALITIES, Player, STABILIZATION_MODES, VIEW_MODES, attachKeyboard, attachViewGestures, createBrowserPlayer, defineGyroView, hasErrorCode, inspectRecording, isGyroViewErrorCode };
+export { GYRO_VIEW_ERROR_CATEGORIES, GYRO_VIEW_ERROR_CODES, GYRO_VIEW_TAG, GyroViewElement, GyroViewError, PICTURE_QUALITIES, Player, STABILIZATION_MODES, VIEW_MODES, attachKeyboard, attachViewGestures, createBrowserPlayer, defineGyroView, hasErrorCode, inspectRecording, isGyroViewErrorCode };

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

@@ -1,4 +1,4 @@
-import { GyroViewError } from "../../../core/src/shared/errors/GyroViewError.js";
+import { GyroViewError, ensureInvariant } from "../../../core/src/shared/errors/GyroViewError.js";
 import "../../../core/src/index.js";
 import { SegmentChannel } from "./SegmentChannel.js";
 import { EncodedAudioPacketSource, EncodedPacket, Mp4OutputFormat, NullTarget, Output } from "mediabunny";
@@ -9,10 +9,9 @@ import { EncodedAudioPacketSource, EncodedPacket, Mp4OutputFormat, NullTarget, O
 */
 var FRAGMENT_DURATION_SECONDS = 1;
 /**
-* Segments (each fragment is two: `moof` and `mdat`) that may wait for the consumer before
-* re-packaging pauses.
+* Media segments that may wait for the consumer before re-packaging pauses.
 */
-var SEGMENTS_AHEAD = 4;
+var SEGMENTS_AHEAD = 2;
 /**
 * The codec strings of the audio the cameras record, AAC (`mp4a.40.2` for AAC-LC), and mediabunny's
 * name for it. Other codecs are not re-packaged: the picture then plays on a silent clock.
@@ -21,10 +20,10 @@ var AAC_CODEC_STRING_PREFIX = "mp4a.40.";
 var AAC = "aac";
 /**
 * AudioPackager over mediabunny: the samples re-packaged, unchanged, into fragmented MP4.
-* Segments are taken from the muxer's box callbacks rather than from its byte stream: that
-* yields whole `ftyp`/`moov`/`moof`/`mdat` boxes and leaves out the `mfra` index the muxer
-* appends at the end, which Media Source Extensions do not accept. Fragmented output keeps the
-* track's own timestamps, so segments started mid-track land at their true time.
+* Segments are assembled from the muxer's box callbacks rather than taken from its byte stream:
+* that yields whole segments and leaves out the `mfra` index the muxer appends at the end, which
+* Media Source Extensions do not accept. Fragmented output keeps the track's own timestamps, so
+* segments started mid-track land at their true time.
 */
 var MediabunnyAudioPackager = class {
 	segmentsOf(samples, configuration) {
@@ -112,18 +111,53 @@ function decoderConfigOf(configuration) {
 		...configuration.description && { description: configuration.description }
 	};
 }
+/**
+* The muxer's boxes handed on as whole segments: the initialization segment (`ftyp` and `moov`)
+* and each media segment (`moof` and its `mdat`). A consumer that stops between two segments, as
+* a seek does, then never leaves a source buffer's parser inside one, where Chromium reads the
+* next segments' bytes as the samples of the `moof` it holds and fails to decode them.
+*/
 function fragmentedMp4Into(channel) {
-	const forward = (data) => {
-		channel.push(new Uint8Array(data));
-	};
+	const segment = new SegmentAssembly(channel);
 	return new Mp4OutputFormat({
 		fastStart: "fragmented",
 		minimumFragmentDuration: FRAGMENT_DURATION_SECONDS,
-		onFtyp: forward,
-		onMoov: forward,
-		onMoof: forward,
-		onMdat: forward
+		onFtyp: (data) => {
+			segment.begin(data);
+		},
+		onMoov: (data) => {
+			segment.end(data);
+		},
+		onMoof: (data) => {
+			segment.begin(data);
+		},
+		onMdat: (data) => {
+			segment.end(data);
+		}
 	});
 }
+/**
+* A segment's first box held until the box that ends it arrives, then both pushed as one.
+*/
+var SegmentAssembly = class {
+	channel;
+	opening;
+	constructor(channel) {
+		this.channel = channel;
+	}
+	begin(box) {
+		ensureInvariant(this.opening === void 0, "a segment began before the last one ended");
+		this.opening = new Uint8Array(box);
+	}
+	end(box) {
+		const { opening } = this;
+		ensureInvariant(opening !== void 0, "a segment ended that never began");
+		const whole = new Uint8Array(opening.byteLength + box.byteLength);
+		whole.set(opening);
+		whole.set(box, opening.byteLength);
+		this.opening = void 0;
+		this.channel.push(whole);
+	}
+};
 //#endregion
 export { MediabunnyAudioPackager };

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

@@ -1,6 +1,7 @@
 import { GyroViewError, isAbortError } from "../../../core/src/shared/errors/GyroViewError.js";
 import "../../../core/src/index.js";
 import { audioConfigurationOf, videoConfigurationOf } from "./decoderConfigurations.js";
+import { trackColourOf } from "./trackColour.js";
 import { ALL_FORMATS, BufferSource, Input } from "mediabunny";
 //#region ../../packages/adapters/mediabunny/src/MediabunnyCodecReader.ts
 /**
@@ -39,7 +40,8 @@ async function videoCodecOf(track, trackIndex) {
 		trackIndex,
 		codedWidth,
 		codedHeight,
-		codec: config.codec
+		codec: config.codec,
+		colour: trackColourOf(config.colorSpace)
 	};
 	return {
 		trackId: track.id,

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

@@ -2,7 +2,7 @@ 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.
+* track where the configuration leaves it out, the colour from the track's description.
 */
 function videoConfigurationOf(config, description) {
 	return {
@@ -10,7 +10,7 @@ function videoConfigurationOf(config, description) {
 		codedWidth: config.codedWidth ?? description.codedWidth,
 		codedHeight: config.codedHeight ?? description.codedHeight,
 		description: config.description === void 0 ? void 0 : copyOfBytes(config.description),
-		isFullRange: config.colorSpace?.fullRange ?? void 0
+		colour: description.colour
 	};
 }
 /**

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

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

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

@@ -73,7 +73,7 @@ var SourceBufferFeeder = class {
 	async feed(from, stop) {
 		try {
 			await this.settlePendingAppend();
-			if (this.hasAllAudioFrom(from)) return;
+			if (stop.wasStopped || this.hasElementFailed() || this.hasAllAudioFrom(from)) return;
 			await this.feedFrom(this.startOf(from), stop);
 		} catch (error) {
 			this.failureValue ??= asGyroViewError(error, "decode", "feeding the audio buffer failed");
@@ -106,11 +106,15 @@ var SourceBufferFeeder = class {
 	}
 	/**
 	* Appends segments as the playhead needs them. True when the track ended, false when stopped.
+	* A run stops only between two whole segments (the port's promise) and never cancels an
+	* append, so the source buffer's parser is always at a segment's start when the next run
+	* appends its initialization segment.
 	*/
 	async pump(segments, stop) {
 		let next = await this.nextWhenNeeded(segments, stop);
 		while (next !== STOPPED) {
 			if (next.done === true) return true;
+			if (this.hasElementFailed()) return false;
 			this.evictBehind();
 			await this.append(next.value);
 			next = await this.nextWhenNeeded(segments, stop);
@@ -162,6 +166,13 @@ var SourceBufferFeeder = class {
 		}
 		if (await outcome === "error") throw new GyroViewError("decode", "the audio buffer could not parse a segment");
 	}
+	/**
+	* The element failed: every append now throws, and the element's own error says why, not the
+	* feeder's.
+	*/
+	hasElementFailed() {
+		return this.parts.element.error !== null;
+	}
 	async settlePendingAppend() {
 		if (this.parts.sourceBuffer.updating) await nextOfEvents(this.parts.sourceBuffer, ["updateend"]);
 	}

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 { MatrixCorrections } from "./matrixCorrections.js";
 import { SAMPLING_STRATEGIES } from "./samplingStrategies.js";
 import { applyLensGain, applyPicture, applyShaderSampling, applyStabilization, createRendererUniforms } from "./rendererUniforms.js";
 import { createFullscreenTriangle } from "./fullscreenPass.js";
@@ -127,6 +128,7 @@ var ThreeFrameRenderer = class {
 			const frame = frames[index];
 			if (frame) texture.setFrame(frame.handle);
 		}
+		this.parts.matrixCorrections.follow(frames.map((frame) => frame.handle));
 		this.hasFrames = true;
 		this.render();
 	}
@@ -250,6 +252,7 @@ function assembleParts(renderer, setup, pictures) {
 		materials,
 		textures,
 		uniforms,
+		matrixCorrections: new MatrixCorrections(setup.lenses, uniforms.uLensMatrixCorrection),
 		lensCount: setup.lenses.length,
 		seamProof
 	};

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

@@ -0,0 +1,61 @@
+import { IDENTITY_MATRIX3 } from "../../../core/src/shared/math/Matrix3.js";
+import { BT709_LUMINANCE, HLG_OETF } from "../../../core/src/domain/colour/DisplayConversion.js";
+import "../../../core/src/index.js";
+import { toThreeMatrix } from "./threeMatrix.js";
+import { glslFloat } from "./glslLiterals.js";
+import { Vector4 } from "three";
+//#region ../../packages/adapters/three/src/conversionUniforms.ts
+/**
+* The kinds of conversion as the shader tells them apart; it shows any kind but HLG's as
+* recorded.
+*/
+var CONVERSION_AS_RECORDED = 0;
+var CONVERSION_HLG_TO_SDR_BT709 = 1;
+/**
+* The constants `displayConversion.glsl` refers to: HLG's kind, BT.2100 HLG's constants and
+* BT.709's luminance, from the core.
+*/
+var CONVERSION_DEFINES = [
+	["CONVERSION_HLG_TO_SDR_BT709", CONVERSION_HLG_TO_SDR_BT709],
+	["HLG_A", glslFloat(HLG_OETF.a)],
+	["HLG_B", glslFloat(HLG_OETF.b)],
+	["HLG_C", glslFloat(HLG_OETF.c)],
+	["HLG_SEGMENT_JOIN", glslFloat(HLG_OETF.segmentJoin)],
+	["HLG_SQUARE_SEGMENT_DIVISOR", glslFloat(HLG_OETF.squareSegmentDivisor)],
+	["HLG_LOG_SEGMENT_DIVISOR", glslFloat(HLG_OETF.logSegmentDivisor)],
+	["BT709_LUMINANCE_RED", glslFloat(BT709_LUMINANCE[0])],
+	["BT709_LUMINANCE_GREEN", glslFloat(BT709_LUMINANCE[1])],
+	["BT709_LUMINANCE_BLUE", glslFloat(BT709_LUMINANCE[2])]
+];
+function conversionUniforms(lenses) {
+	const slots = lenses.map((lens) => conversionSlotOf(lens.displayConversion));
+	return {
+		uLensConversion: { value: slots.map((slot) => slot.kind) },
+		uLensMatrixCorrection: { value: lenses.map(() => toThreeMatrix(IDENTITY_MATRIX3)) },
+		uLensGamut: { value: slots.map((slot) => slot.gamut) },
+		uLensTone: { value: slots.map((slot) => slot.tone) }
+	};
+}
+/**
+* Exhaustive over the conversion kinds: a new kind does not compile until it is packed. What a
+* kind does not use stays neutral: the identity gamut, a tone of zeros.
+*/
+function conversionSlotOf(conversion) {
+	switch (conversion.kind) {
+		case "as-recorded": return {
+			kind: CONVERSION_AS_RECORDED,
+			gamut: toThreeMatrix(IDENTITY_MATRIX3),
+			tone: new Vector4()
+		};
+		case "hlg-to-sdr-bt709": {
+			const { exposure, kneeStart, ceiling, exponent } = conversion.tone;
+			return {
+				kind: CONVERSION_HLG_TO_SDR_BT709,
+				gamut: toThreeMatrix(conversion.gamut),
+				tone: new Vector4(exposure, kneeStart, ceiling, exponent)
+			};
+		}
+	}
+}
+//#endregion
+export { CONVERSION_DEFINES, conversionUniforms };

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

@@ -0,0 +1,10 @@
+//#region ../../packages/adapters/three/src/glslLiterals.ts
+/**
+* A number as a GLSL float literal, with its decimal point: three.js writes a define's number as
+* JavaScript prints it, so 3 would be an int, and GLSL ES 3.00 converts no int to a float.
+*/
+function glslFloat(value) {
+	return Number.isSafeInteger(value) ? value.toFixed(1) : String(value);
+}
+//#endregion
+export { glslFloat };

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

@@ -0,0 +1,35 @@
+import { MATRIX_COEFFICIENTS, namedOrUnspecified } from "../../../core/src/domain/colour/TrackColour.js";
+import { matrixCorrectionOf } from "../../../core/src/domain/colour/matrixCorrection.js";
+import "../../../core/src/index.js";
+import { toThreeMatrix } from "./threeMatrix.js";
+//#region ../../packages/adapters/three/src/matrixCorrections.ts
+/**
+* Follows the matrix each lens's frames name, and brings their texels back to the matrix the
+* track was recorded with where the two differ (ADR 0033): WebKit's decoders convert Y′CbCr with
+* BT.709 whatever a stream says, and name BT.709 on the frames they make.
+*/
+var MatrixCorrections = class {
+	lenses;
+	uniform;
+	named;
+	constructor(lenses, uniform) {
+		this.lenses = lenses;
+		this.uniform = uniform;
+		this.named = Array.from({ length: lenses.length });
+	}
+	/**
+	* Updates a lens's correction when its frames name another matrix than before.
+	*/
+	follow(frames) {
+		for (const [index, lens] of this.lenses.entries()) {
+			const frame = frames[lens.frameSlot];
+			if (!frame) continue;
+			const named = namedOrUnspecified(MATRIX_COEFFICIENTS, frame.colorSpace.matrix);
+			if (named === this.named[index]) continue;
+			this.named[index] = named;
+			this.uniform.value[index] = toThreeMatrix(matrixCorrectionOf(lens.displayConversion.matrix, named));
+		}
+	}
+};
+//#endregion
+export { MatrixCorrections };