@woosh/meep-engine 3.64.0 → 3.64.1

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.64.0",
+  "version": "3.64.1",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/engine/graphics/texture/sampler/exr_to_sampler2d.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Decode an OpenEXR file into an RGBA sampler.
+ *
+ * R, G, B and A come from the file's channels of those names, and a luminance image — Y, with A if it
+ * has one — reads as grey. A channel the file lacks reads as 0, or as 1 for alpha; channels of other
+ * names are left out.
+ *
+ * The sampler's storage holds every sample it reads exactly: half float when every one of those channels
+ * is HALF, 32-bit unsigned integer when every one is UINT, and float when HALF and FLOAT are mixed.
+ * Unsigned integers mixed with either float type are refused, since no storage holds both exactly.
+ * Samples are copied as numbers, so every value comes through unchanged but a NaN may come back with
+ * another payload.
+ *
+ * {@link sampler2d_to_exr} names channels the way this reads them, so a four-channel sampler makes the
+ * round trip unchanged and one of fewer channels comes back as the RGBA it stands for.
+ *
+ * @param {ArrayBuffer} bytes the whole file; keep unchanged until the promise settles
+ * @returns {Promise<Sampler2D>} four channels
+ * @throws {Error} when the file has none of R, G, B and Y, or mixes unsigned integers with floats among
+ * the channels read, and wherever {@link exr_read} throws
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function exr_to_sampler2d(bytes: ArrayBuffer): Promise<Sampler2D>;
+import { Sampler2D } from "./Sampler2D.js";
+//# sourceMappingURL=exr_to_sampler2d.d.ts.map

package/src/engine/graphics/texture/sampler/exr_to_sampler2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exr_to_sampler2d.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/exr_to_sampler2d.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wCARW,WAAW,GACT,QAAQ,SAAS,CAAC,CA4D9B;0BAzFyB,gBAAgB"}

package/src/engine/graphics/texture/sampler/exr_to_sampler2d.js

@@ -0,0 +1,91 @@
+import { exr_read } from "../../../../format/image/exr/exr_read.js";
+import { Sampler2D } from "./Sampler2D.js";
+import { sampler2d_copy_channel_data } from "./sampler2d_copy_channel_data.js";
+
+/**
+ * What each RGBA channel reads as when the file lacks it: no colour, full alpha. OpenEXR's own RGBA
+ * interface fills missing channels the same way.
+ *
+ * @readonly
+ * @type {number[]}
+ */
+const MISSING_CHANNEL_VALUE = [0, 0, 0, 1];
+
+/**
+ * Decode an OpenEXR file into an RGBA sampler.
+ *
+ * R, G, B and A come from the file's channels of those names, and a luminance image — Y, with A if it
+ * has one — reads as grey. A channel the file lacks reads as 0, or as 1 for alpha; channels of other
+ * names are left out.
+ *
+ * The sampler's storage holds every sample it reads exactly: half float when every one of those channels
+ * is HALF, 32-bit unsigned integer when every one is UINT, and float when HALF and FLOAT are mixed.
+ * Unsigned integers mixed with either float type are refused, since no storage holds both exactly.
+ * Samples are copied as numbers, so every value comes through unchanged but a NaN may come back with
+ * another payload.
+ *
+ * {@link sampler2d_to_exr} names channels the way this reads them, so a four-channel sampler makes the
+ * round trip unchanged and one of fewer channels comes back as the RGBA it stands for.
+ *
+ * @param {ArrayBuffer} bytes the whole file; keep unchanged until the promise settles
+ * @returns {Promise<Sampler2D>} four channels
+ * @throws {Error} when the file has none of R, G, B and Y, or mixes unsigned integers with floats among
+ * the channels read, and wherever {@link exr_read} throws
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export async function exr_to_sampler2d(bytes) {
+    const { width, height, channels } = await exr_read(bytes);
+
+    const find = (name) => channels.find(channel => channel.name === name);
+
+    const alpha = find("A");
+
+    let sources = [find("R"), find("G"), find("B"), alpha];
+
+    if (sources[0] === undefined && sources[1] === undefined && sources[2] === undefined) {
+        const luminance = find("Y");
+
+        if (luminance === undefined) {
+            throw new Error(
+                `EXR: no R, G, B or Y channel to read as colour; the file has`
+                + ` ${channels.map(channel => channel.name).join(", ")}`
+            );
+        }
+
+        sources = [luminance, luminance, luminance, alpha];
+    }
+
+    const read = sources.filter(source => source !== undefined);
+
+    let result;
+
+    if (read.every(source => source.data instanceof Float16Array)) {
+        result = Sampler2D.float16(4, width, height);
+    } else if (read.every(source => source.data instanceof Uint32Array)) {
+        result = Sampler2D.uint32(4, width, height);
+    } else if (read.some(source => source.data instanceof Uint32Array)) {
+        const types = [...new Set(read)]
+            .map(source => `${source.name} (${source.data instanceof Uint32Array ? "UINT" : source.data instanceof Float16Array ? "HALF" : "FLOAT"})`);
+
+        throw new Error(
+            `EXR: the channels read as colour, ${types.join(", ")}, mix unsigned integers with floats,`
+            + ` which no sampler storage holds both of exactly`
+        );
+    } else {
+        result = Sampler2D.float32(4, width, height);
+    }
+
+    for (let c = 0; c < 4; c++) {
+        const source = sources[c];
+
+        if (source === undefined) {
+            result.channelFill(c, MISSING_CHANNEL_VALUE[c]);
+        } else {
+            sampler2d_copy_channel_data(new Sampler2D(source.data, 1, width, height), 0, result, c);
+        }
+    }
+
+    return result;
+}

package/src/engine/graphics/texture/sampler/sampler2d_to_exr.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Encode a sampler as an OpenEXR file.
+ *
+ * Channels are named the way OpenEXR names them: one channel is a luminance image, Y; two are Y and A;
+ * three are R, G and B; four are R, G, B and A. {@link exr_to_sampler2d} reads each of those back as RGBA.
+ *
+ * The sampler's storage is the pixel type: a `Float16Array` is written as HALF, a `Float32Array` as FLOAT,
+ * a `Uint32Array` as UINT. Other storage is refused rather than converted, because what its numbers mean
+ * — normalised, sRGB-encoded — is not this function's to guess; convert first, for instance with
+ * `sampler2d_srgb_u8_to_linear_f16` or `sampler2d_to_f16`. Samples are copied as numbers, so every value
+ * is written unchanged but a NaN may be written with another payload.
+ *
+ * @param {Sampler2D} sampler 1 to 4 channels
+ * @param {ExrCompression} compression see {@link exr_write}
+ * @returns {Promise<ArrayBuffer>} the whole file
+ * @throws {Error} for any other channel count, and wherever {@link exr_write} throws
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sampler2d_to_exr(sampler: Sampler2D, compression: ExrCompression): Promise<ArrayBuffer>;
+import { Sampler2D } from "./Sampler2D.js";
+//# sourceMappingURL=sampler2d_to_exr.d.ts.map

package/src/engine/graphics/texture/sampler/sampler2d_to_exr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampler2d_to_exr.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/sampler2d_to_exr.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,0CARW,SAAS,gCAEP,QAAQ,WAAW,CAAC,CA8BhC;0BA9DyB,gBAAgB"}

package/src/engine/graphics/texture/sampler/sampler2d_to_exr.js

@@ -0,0 +1,64 @@
+import { exr_write } from "../../../../format/image/exr/exr_write.js";
+import { Sampler2D } from "./Sampler2D.js";
+import { sampler2d_copy_channel_data } from "./sampler2d_copy_channel_data.js";
+
+/**
+ * Channel names by item size, the way OpenEXR names them: luminance, luminance and alpha, colour, colour
+ * and alpha.
+ *
+ * @readonly
+ * @type {(string[]|undefined)[]}
+ */
+const CHANNEL_NAMES = [
+    undefined,
+    ["Y"],
+    ["Y", "A"],
+    ["R", "G", "B"],
+    ["R", "G", "B", "A"],
+];
+
+/**
+ * Encode a sampler as an OpenEXR file.
+ *
+ * Channels are named the way OpenEXR names them: one channel is a luminance image, Y; two are Y and A;
+ * three are R, G and B; four are R, G, B and A. {@link exr_to_sampler2d} reads each of those back as RGBA.
+ *
+ * The sampler's storage is the pixel type: a `Float16Array` is written as HALF, a `Float32Array` as FLOAT,
+ * a `Uint32Array` as UINT. Other storage is refused rather than converted, because what its numbers mean
+ * — normalised, sRGB-encoded — is not this function's to guess; convert first, for instance with
+ * `sampler2d_srgb_u8_to_linear_f16` or `sampler2d_to_f16`. Samples are copied as numbers, so every value
+ * is written unchanged but a NaN may be written with another payload.
+ *
+ * @param {Sampler2D} sampler 1 to 4 channels
+ * @param {ExrCompression} compression see {@link exr_write}
+ * @returns {Promise<ArrayBuffer>} the whole file
+ * @throws {Error} for any other channel count, and wherever {@link exr_write} throws
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export async function sampler2d_to_exr(sampler, compression) {
+    const width = sampler.width;
+    const height = sampler.height;
+    const item_size = sampler.itemSize;
+
+    const names = CHANNEL_NAMES[item_size];
+
+    if (names === undefined) {
+        throw new Error(`EXR: a sampler of ${item_size} channels has no OpenEXR naming; 1 to 4 channels do`);
+    }
+
+    const storage = sampler.data.constructor;
+
+    const channels = new Array(item_size);
+
+    for (let c = 0; c < item_size; c++) {
+        const plane = new Sampler2D(new storage(width * height), 1, width, height);
+
+        sampler2d_copy_channel_data(sampler, c, plane, 0);
+
+        channels[c] = { name: names[c], data: plane.data };
+    }
+
+    return exr_write({ width, height, channels }, compression);
+}

package/src/format/image/exr/ExrCompression.d.ts

@@ -0,0 +1,22 @@
+/**
+ * How the pixel data of an OpenEXR file is compressed, by the value its `compression` attribute holds.
+ *
+ * {@link exr_read } and {@link exr_write } handle {@link None }, {@link ZIPS } and {@link ZIP }. The other
+ * methods are listed so that a refusal can name the one a file uses.
+ */
+export type ExrCompression = number;
+export namespace ExrCompression {
+    let None: number;
+    let RLE: number;
+    let ZIPS: number;
+    let ZIP: number;
+    let PIZ: number;
+    let PXR24: number;
+    let B44: number;
+    let B44A: number;
+    let DWAA: number;
+    let DWAB: number;
+    let HTJ2K256: number;
+    let HTJ2K32: number;
+}
+//# sourceMappingURL=ExrCompression.d.ts.map

package/src/format/image/exr/ExrCompression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExrCompression.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/exr/ExrCompression.js"],"names":[],"mappings":";;;;;;6BAQU,MAAM"}

package/src/format/image/exr/ExrCompression.js

@@ -0,0 +1,27 @@
+/**
+ * How the pixel data of an OpenEXR file is compressed, by the value its `compression` attribute holds.
+ *
+ * {@link exr_read} and {@link exr_write} handle {@link None}, {@link ZIPS} and {@link ZIP}. The other
+ * methods are listed so that a refusal can name the one a file uses.
+ *
+ * @see https://openexr.com/en/latest/OpenEXRFileLayout.html#compression-methods
+ * @readonly
+ * @enum {number}
+ */
+export const ExrCompression = {
+    /** the chunk bytes are the pixel bytes, one scanline per chunk */
+    None: 0,
+    RLE: 1,
+    /** zlib, one scanline per chunk */
+    ZIPS: 2,
+    /** zlib, sixteen scanlines per chunk */
+    ZIP: 3,
+    PIZ: 4,
+    PXR24: 5,
+    B44: 6,
+    B44A: 7,
+    DWAA: 8,
+    DWAB: 9,
+    HTJ2K256: 10,
+    HTJ2K32: 11,
+};

package/src/format/image/exr/ExrImage.d.ts

@@ -0,0 +1,32 @@
+/**
+ * One channel of an {@link ExrImage }.
+ *
+ * The array's class is the channel's pixel type: `Float16Array` is HALF, `Float32Array` is FLOAT and
+ * `Uint32Array` is UINT, the three types OpenEXR has. It holds one sample per pixel, row by row, top row
+ * first.
+ */
+type ExrChannel = {
+    name: string;
+    /**
+     * `width * height` samples
+     */
+    data: Float16Array | Float32Array | Uint32Array;
+};
+/**
+ * The pixels of a scanline OpenEXR image, one plane per channel — what {@link exr_read } returns and
+ * {@link exr_write } takes.
+ *
+ * `width` and `height` are those of the file's data window. Where that window sits, and the display window
+ * around it, are not part of the record: {@link exr_read } drops them and {@link exr_write } puts both windows
+ * at the origin, exactly covering the pixels.
+ *
+ * {@link exr_read } returns channels in the order OpenEXR keeps them, sorted by the bytes of their names
+ * (see {@link exr_compare_names }), which is the order a file's pixel data holds them in whatever order its
+ * channel list names them. {@link exr_write } takes them in any order.
+ */
+type ExrImage = {
+    width: number;
+    height: number;
+    channels: ExrChannel[];
+};
+//# sourceMappingURL=ExrImage.d.ts.map

package/src/format/image/exr/ExrImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExrImage.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/exr/ExrImage.js"],"names":[],"mappings":";;;;;;;;UAQc,MAAM;;;;UACN,eAAa,YAAY,GAAC,WAAW;;;;;;;;;;;;;;;WAgBrC,MAAM;YACN,MAAM;cACN,UAAU,EAAE"}

package/src/format/image/exr/ExrImage.js

@@ -0,0 +1,32 @@
+/**
+ * One channel of an {@link ExrImage}.
+ *
+ * The array's class is the channel's pixel type: `Float16Array` is HALF, `Float32Array` is FLOAT and
+ * `Uint32Array` is UINT, the three types OpenEXR has. It holds one sample per pixel, row by row, top row
+ * first.
+ *
+ * @typedef {object} ExrChannel
+ * @property {string} name
+ * @property {Float16Array|Float32Array|Uint32Array} data `width * height` samples
+ */
+
+/**
+ * The pixels of a scanline OpenEXR image, one plane per channel — what {@link exr_read} returns and
+ * {@link exr_write} takes.
+ *
+ * `width` and `height` are those of the file's data window. Where that window sits, and the display window
+ * around it, are not part of the record: {@link exr_read} drops them and {@link exr_write} puts both windows
+ * at the origin, exactly covering the pixels.
+ *
+ * {@link exr_read} returns channels in the order OpenEXR keeps them, sorted by the bytes of their names
+ * (see {@link exr_compare_names}), which is the order a file's pixel data holds them in whatever order its
+ * channel list names them. {@link exr_write} takes them in any order.
+ *
+ * @typedef {object} ExrImage
+ * @property {number} width
+ * @property {number} height
+ * @property {ExrChannel[]} channels
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */

package/src/format/image/exr/ExrPixelType.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The type of a channel's samples, by the value an OpenEXR channel list stores.
+ *
+ * In an {@link ExrImage } the type is the class of the channel's array: `Uint32Array`, `Float16Array` or
+ * `Float32Array`.
+ */
+export type ExrPixelType = number;
+export namespace ExrPixelType {
+    let UINT: number;
+    let HALF: number;
+    let FLOAT: number;
+}
+//# sourceMappingURL=ExrPixelType.d.ts.map

package/src/format/image/exr/ExrPixelType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExrPixelType.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/exr/ExrPixelType.js"],"names":[],"mappings":";;;;;;2BAQU,MAAM"}

package/src/format/image/exr/ExrPixelType.js

@@ -0,0 +1,18 @@
+/**
+ * The type of a channel's samples, by the value an OpenEXR channel list stores.
+ *
+ * In an {@link ExrImage} the type is the class of the channel's array: `Uint32Array`, `Float16Array` or
+ * `Float32Array`.
+ *
+ * @see https://openexr.com/en/latest/OpenEXRFileLayout.html#channel-list
+ * @readonly
+ * @enum {number}
+ */
+export const ExrPixelType = {
+    /** 32-bit unsigned integer */
+    UINT: 0,
+    /** IEEE 754 binary16 */
+    HALF: 1,
+    /** IEEE 754 binary32 */
+    FLOAT: 2,
+};

package/src/format/image/exr/exr_compare_names.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Order two names the way OpenEXR orders channels: byte by byte, as `strcmp` compares them.
+ *
+ * A file's pixel data holds its channels in this order whatever order its channel list is in, so this is
+ * the order {@link exr_read} lays samples out in and {@link exr_write} writes them in. On UTF-8 bytes it is
+ * code point order, which JavaScript's own string comparison is not past U+FFFF.
+ *
+ * @param {Uint8Array} a a name's bytes, without its terminator
+ * @param {Uint8Array} b
+ * @returns {number} negative when `a` comes first, positive when `b` does, 0 for the same name
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function exr_compare_names(a: Uint8Array, b: Uint8Array): number;
+//# sourceMappingURL=exr_compare_names.d.ts.map

package/src/format/image/exr/exr_compare_names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exr_compare_names.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/exr/exr_compare_names.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,qCAPW,UAAU,KACV,UAAU,GACR,MAAM,CAelB"}

package/src/format/image/exr/exr_compare_names.js

@@ -0,0 +1,25 @@
+/**
+ * Order two names the way OpenEXR orders channels: byte by byte, as `strcmp` compares them.
+ *
+ * A file's pixel data holds its channels in this order whatever order its channel list is in, so this is
+ * the order {@link exr_read} lays samples out in and {@link exr_write} writes them in. On UTF-8 bytes it is
+ * code point order, which JavaScript's own string comparison is not past U+FFFF.
+ *
+ * @param {Uint8Array} a a name's bytes, without its terminator
+ * @param {Uint8Array} b
+ * @returns {number} negative when `a` comes first, positive when `b` does, 0 for the same name
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function exr_compare_names(a, b) {
+    const length = Math.min(a.length, b.length);
+
+    for (let i = 0; i < length; i++) {
+        if (a[i] !== b[i]) {
+            return a[i] - b[i];
+        }
+    }
+
+    return a.length - b.length;
+}

package/src/format/image/exr/exr_constants.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Numbers fixed by the OpenEXR file layout that both {@link exr_read} and {@link exr_write} need.
+ *
+ * @see https://openexr.com/en/latest/OpenEXRFileLayout.html
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * The first four bytes of every OpenEXR file, read as a little-endian integer.
+ * @type {number}
+ */
+export const EXR_MAGIC: number;
+/**
+ * The file format version, which is the low byte of the version field.
+ * @type {number}
+ */
+export const EXR_VERSION: number;
+/**
+ * Version field flag: the file holds a single tiled part.
+ * @type {number}
+ */
+export const EXR_FLAG_TILED: number;
+/**
+ * Version field flag: attribute names, attribute type names and channel names may be up to
+ * {@link EXR_LONG_NAME_BYTES} long rather than {@link EXR_SHORT_NAME_BYTES}.
+ * @type {number}
+ */
+export const EXR_FLAG_LONG_NAMES: number;
+/**
+ * Version field flag: the file holds deep data.
+ * @type {number}
+ */
+export const EXR_FLAG_NON_IMAGE: number;
+/**
+ * Version field flag: the file holds more than one part.
+ * @type {number}
+ */
+export const EXR_FLAG_MULTI_PART: number;
+/**
+ * Longest name, in bytes and without its terminator, a file without {@link EXR_FLAG_LONG_NAMES} may carry.
+ * @type {number}
+ */
+export const EXR_SHORT_NAME_BYTES: number;
+/**
+ * Longest name, in bytes and without its terminator, any file may carry.
+ * @type {number}
+ */
+export const EXR_LONG_NAME_BYTES: number;
+//# sourceMappingURL=exr_constants.d.ts.map

package/src/format/image/exr/exr_constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exr_constants.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/exr/exr_constants.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;GAGG;AACH,wBAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,0BAFU,MAAM,CAEa;AAE7B;;;GAGG;AACH,6BAFU,MAAM,CAEoB;AAEpC;;;;GAIG;AACH,kCAFU,MAAM,CAEyB;AAEzC;;;GAGG;AACH,iCAFU,MAAM,CAEwB;AAExC;;;GAGG;AACH,kCAFU,MAAM,CAE0B;AAE1C;;;GAGG;AACH,mCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,kCAFU,MAAM,CAEuB"}

package/src/format/image/exr/exr_constants.js

@@ -0,0 +1,56 @@
+/**
+ * Numbers fixed by the OpenEXR file layout that both {@link exr_read} and {@link exr_write} need.
+ *
+ * @see https://openexr.com/en/latest/OpenEXRFileLayout.html
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * The first four bytes of every OpenEXR file, read as a little-endian integer.
+ * @type {number}
+ */
+export const EXR_MAGIC = 20000630;
+
+/**
+ * The file format version, which is the low byte of the version field.
+ * @type {number}
+ */
+export const EXR_VERSION = 2;
+
+/**
+ * Version field flag: the file holds a single tiled part.
+ * @type {number}
+ */
+export const EXR_FLAG_TILED = 0x200;
+
+/**
+ * Version field flag: attribute names, attribute type names and channel names may be up to
+ * {@link EXR_LONG_NAME_BYTES} long rather than {@link EXR_SHORT_NAME_BYTES}.
+ * @type {number}
+ */
+export const EXR_FLAG_LONG_NAMES = 0x400;
+
+/**
+ * Version field flag: the file holds deep data.
+ * @type {number}
+ */
+export const EXR_FLAG_NON_IMAGE = 0x800;
+
+/**
+ * Version field flag: the file holds more than one part.
+ * @type {number}
+ */
+export const EXR_FLAG_MULTI_PART = 0x1000;
+
+/**
+ * Longest name, in bytes and without its terminator, a file without {@link EXR_FLAG_LONG_NAMES} may carry.
+ * @type {number}
+ */
+export const EXR_SHORT_NAME_BYTES = 31;
+
+/**
+ * Longest name, in bytes and without its terminator, any file may carry.
+ * @type {number}
+ */
+export const EXR_LONG_NAME_BYTES = 255;

package/src/format/image/exr/exr_read.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Read a scanline OpenEXR file.
+ *
+ * **What it reads**: a single-part scanline image with full-resolution channels, compressed with
+ * {@link ExrCompression.None}, {@link ExrCompression.ZIPS} or {@link ExrCompression.ZIP}, in any of
+ * OpenEXR's three pixel types, mixed freely between channels. Samples come back as they are stored — a
+ * HALF channel is a `Float16Array` holding the file's exact bits — so reading converts nothing. Chunks are
+ * found through the offset table, so the file's line order does not matter.
+ *
+ * Of the header, only what decoding depends on is read: the channel list, the compression method and the
+ * data window. OpenEXR requires five more attributes — display window, line order, pixel aspect ratio,
+ * screen window centre and width — and its own reader fills in a default for any a file leaves out;
+ * nothing here would use them, so they are skipped like every other attribute.
+ *
+ * **What it refuses**, by name: tiled, multi-part and deep files; every other compression method;
+ * subsampled channels; a header without the channel list, compression or data window, or with one of
+ * them of the wrong type; and a file whose chunks do not add up — an offset outside the file, a chunk
+ * holding other scanlines than its place in the table says, a chunk whose stored or inflated size
+ * disagrees with the scanlines it holds. Every chunk is checked before anything is allocated for the
+ * pixels — against its place, its scanline, and what deflate could inflate its stored bytes to — so a file
+ * cannot claim more pixel data than its own chunks could hold.
+ *
+ * @param {ArrayBuffer} bytes the whole file; keep unchanged until the promise settles
+ * @returns {Promise<ExrImage>}
+ * @throws {Error} naming what is unsupported or malformed
+ *
+ * @see https://openexr.com/en/latest/OpenEXRFileLayout.html
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function exr_read(bytes: ArrayBuffer): Promise<ExrImage>;
+//# sourceMappingURL=exr_read.d.ts.map

package/src/format/image/exr/exr_read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exr_read.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/exr/exr_read.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,gCARW,WAAW,GACT,QAAQ,QAAQ,CAAC,CAqL7B"}