open-ultrahdr-wasm 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "open-ultrahdr-wasm",
-	"version": "0.1.1",
+	"version": "0.1.2",
 	"description": "UltraHDR (ISO 21496-1) gain map WASM implementation",
 	"author": "Adam Silverstein",
 	"license": "GPL-2.0-or-later",
@@ -15,7 +15,7 @@
 	"homepage": "https://github.com/adamsilverstein/lib-open-ultrahdr",
 	"repository": {
 		"type": "git",
-		"url": "https://github.com/adamsilverstein/lib-open-ultrahdr.git",
+		"url": "git+https://github.com/adamsilverstein/lib-open-ultrahdr.git",
 		"directory": "wasm"
 	},
 	"bugs": {

package/pkg/open_ultrahdr.d.ts

@@ -180,6 +180,61 @@ export class UltraHdrEncodeOptions {
     targetHdrCapacity: number;
 }
 
+/**
+ * Result of probing an image to check if it's UltraHDR.
+ *
+ * This provides detailed information about what components were found
+ * without fully decoding the image. Useful for batch processing and filtering.
+ */
+export class UltraHdrProbeResult {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Creates a new probe result with default (invalid) values.
+     */
+    constructor();
+    /**
+     * Gain map height in pixels (0 if not found)
+     */
+    gainMapHeight: number;
+    /**
+     * Gain map width in pixels (0 if not found)
+     */
+    gainMapWidth: number;
+    /**
+     * Whether a gain map image was found
+     */
+    hasGainMap: boolean;
+    /**
+     * Whether gain map metadata (XMP) was found
+     */
+    hasMetadata: boolean;
+    /**
+     * Whether a primary JPEG image was found
+     */
+    hasPrimaryImage: boolean;
+    /**
+     * HDR capacity (max additional stops of dynamic range), 0 if not found
+     */
+    hdrCapacity: number;
+    /**
+     * Primary image height in pixels (0 if not found)
+     */
+    height: number;
+    /**
+     * Whether the image is a valid UltraHDR image (has all required components)
+     */
+    isValid: boolean;
+    /**
+     * Metadata version string (empty if not found)
+     */
+    metadataVersion: string;
+    /**
+     * Primary image width in pixels (0 if not found)
+     */
+    width: number;
+}
+
 /**
  * Creates default gain map metadata.
  *
@@ -361,6 +416,46 @@ export function isMeaningfulHdr(metadata: GainMapMetadata): boolean;
  */
 export function isUltraHdr(buffer: Uint8Array): boolean;
 
+/**
+ * Probes an image to check if it's UltraHDR and extracts component information.
+ *
+ * This function efficiently validates if an image is UltraHDR by checking for
+ * required components (primary image, gain map, metadata) without full decoding.
+ * Returns structured results useful for batch processing and filtering.
+ *
+ * Unlike `isUltraHdr`, this function provides detailed information about what
+ * was found, making it useful for diagnostics and filtering workflows.
+ *
+ * # Arguments
+ * * `buffer` - Image file contents as bytes
+ *
+ * # Returns
+ * `UltraHdrProbeResult` containing:
+ * - `isValid`: Whether the image is a valid UltraHDR image
+ * - `hasPrimaryImage`: Whether a primary JPEG was found
+ * - `hasGainMap`: Whether a gain map image was found
+ * - `hasMetadata`: Whether XMP metadata was found
+ * - `width`, `height`: Primary image dimensions (0 if not found)
+ * - `gainMapWidth`, `gainMapHeight`: Gain map dimensions (0 if not found)
+ * - `hdrCapacity`: HDR capacity in stops (0 if not found)
+ * - `metadataVersion`: Metadata version string (empty if not found)
+ *
+ * # Example (JavaScript)
+ * ```js
+ * const buffer = await file.arrayBuffer();
+ * const result = probeUltraHdr(new Uint8Array(buffer));
+ * if (result.isValid) {
+ *     console.log('UltraHDR image:', result.width, 'x', result.height);
+ *     console.log('HDR capacity:', result.hdrCapacity, 'stops');
+ * } else {
+ *     if (!result.hasPrimaryImage) console.log('Not a JPEG');
+ *     if (!result.hasGainMap) console.log('No gain map found');
+ *     if (!result.hasMetadata) console.log('No HDR metadata');
+ * }
+ * ```
+ */
+export function probeUltraHdr(buffer: Uint8Array): UltraHdrProbeResult;
+
 /**
  * Validates gain map metadata.
  *
@@ -399,6 +494,15 @@ export interface InitOutput {
     readonly __wbg_get_ultrahdrencodeoptions_includeIsoMetadata: (a: number) => number;
     readonly __wbg_get_ultrahdrencodeoptions_includeUltrahdrV1: (a: number) => number;
     readonly __wbg_get_ultrahdrencodeoptions_targetHdrCapacity: (a: number) => number;
+    readonly __wbg_get_ultrahdrproberesult_gainMapHeight: (a: number) => number;
+    readonly __wbg_get_ultrahdrproberesult_gainMapWidth: (a: number) => number;
+    readonly __wbg_get_ultrahdrproberesult_hasGainMap: (a: number) => number;
+    readonly __wbg_get_ultrahdrproberesult_hasMetadata: (a: number) => number;
+    readonly __wbg_get_ultrahdrproberesult_hasPrimaryImage: (a: number) => number;
+    readonly __wbg_get_ultrahdrproberesult_hdrCapacity: (a: number) => number;
+    readonly __wbg_get_ultrahdrproberesult_height: (a: number) => number;
+    readonly __wbg_get_ultrahdrproberesult_isValid: (a: number) => number;
+    readonly __wbg_get_ultrahdrproberesult_width: (a: number) => number;
     readonly __wbg_set_gainmapmetadata_baseRenditionIsHdr: (a: number, b: number) => void;
     readonly __wbg_set_gainmapmetadata_gainMapMax: (a: number, b: number, c: number) => void;
     readonly __wbg_set_gainmapmetadata_gainMapMin: (a: number, b: number, c: number) => void;
@@ -420,15 +524,28 @@ export interface InitOutput {
     readonly __wbg_set_ultrahdrencodeoptions_includeIsoMetadata: (a: number, b: number) => void;
     readonly __wbg_set_ultrahdrencodeoptions_includeUltrahdrV1: (a: number, b: number) => void;
     readonly __wbg_set_ultrahdrencodeoptions_targetHdrCapacity: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_gainMapHeight: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_gainMapWidth: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_hasGainMap: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_hasMetadata: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_hasPrimaryImage: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_hdrCapacity: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_height: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_isValid: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_width: (a: number, b: number) => void;
     readonly __wbg_ultrahdrdecoderesult_free: (a: number, b: number) => void;
     readonly __wbg_ultrahdrencodeoptions_free: (a: number, b: number) => void;
+    readonly __wbg_ultrahdrproberesult_free: (a: number, b: number) => void;
     readonly gainmapmetadata_forSdrBase: (a: number) => number;
     readonly gainmapmetadata_new: () => number;
     readonly ultrahdrdecoderesult_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
     readonly ultrahdrencodeoptions_highQuality: () => number;
     readonly ultrahdrencodeoptions_new: () => number;
     readonly ultrahdrencodeoptions_smallSize: () => number;
+    readonly ultrahdrproberesult_new: () => number;
+    readonly __wbg_get_ultrahdrproberesult_metadataVersion: (a: number) => [number, number];
     readonly __wbg_set_ultrahdrdecoderesult_sdrImage: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_metadataVersion: (a: number, b: number, c: number) => void;
     readonly createDefaultMetadata: () => number;
     readonly createDefaultOptions: () => number;
     readonly createHighQualityOptions: () => number;
@@ -438,10 +555,11 @@ export interface InitOutput {
     readonly estimateHdrHeadroom: (a: number) => number;
     readonly extractSdrBase: (a: number, b: number) => [number, number, number, number];
     readonly getMetadata: (a: number, b: number) => [number, number, number];
+    readonly init: () => void;
     readonly isMeaningfulHdr: (a: number) => number;
     readonly isUltraHdr: (a: number, b: number) => number;
+    readonly probeUltraHdr: (a: number, b: number) => number;
     readonly validateMetadata: (a: number) => number;
-    readonly init: () => void;
     readonly __wbindgen_externrefs: WebAssembly.Table;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __externref_table_dealloc: (a: number) => void;

package/pkg/open_ultrahdr.js

@@ -379,7 +379,7 @@ export class UltraHdrDecodeResult {
     set sdrImage(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_gainmapmetadata_version(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_ultrahdrdecoderesult_sdrImage(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * Image width in pixels
@@ -552,6 +552,202 @@ export class UltraHdrEncodeOptions {
 }
 if (Symbol.dispose) UltraHdrEncodeOptions.prototype[Symbol.dispose] = UltraHdrEncodeOptions.prototype.free;
 
+/**
+ * Result of probing an image to check if it's UltraHDR.
+ *
+ * This provides detailed information about what components were found
+ * without fully decoding the image. Useful for batch processing and filtering.
+ */
+export class UltraHdrProbeResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(UltraHdrProbeResult.prototype);
+        obj.__wbg_ptr = ptr;
+        UltraHdrProbeResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        UltraHdrProbeResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ultrahdrproberesult_free(ptr, 0);
+    }
+    /**
+     * Gain map height in pixels (0 if not found)
+     * @returns {number}
+     */
+    get gainMapHeight() {
+        const ret = wasm.__wbg_get_ultrahdrproberesult_gainMapHeight(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Gain map width in pixels (0 if not found)
+     * @returns {number}
+     */
+    get gainMapWidth() {
+        const ret = wasm.__wbg_get_ultrahdrproberesult_gainMapWidth(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Whether a gain map image was found
+     * @returns {boolean}
+     */
+    get hasGainMap() {
+        const ret = wasm.__wbg_get_ultrahdrproberesult_hasGainMap(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Whether gain map metadata (XMP) was found
+     * @returns {boolean}
+     */
+    get hasMetadata() {
+        const ret = wasm.__wbg_get_ultrahdrproberesult_hasMetadata(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Whether a primary JPEG image was found
+     * @returns {boolean}
+     */
+    get hasPrimaryImage() {
+        const ret = wasm.__wbg_get_ultrahdrproberesult_hasPrimaryImage(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * HDR capacity (max additional stops of dynamic range), 0 if not found
+     * @returns {number}
+     */
+    get hdrCapacity() {
+        const ret = wasm.__wbg_get_ultrahdrproberesult_hdrCapacity(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Primary image height in pixels (0 if not found)
+     * @returns {number}
+     */
+    get height() {
+        const ret = wasm.__wbg_get_ultrahdrproberesult_height(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Whether the image is a valid UltraHDR image (has all required components)
+     * @returns {boolean}
+     */
+    get isValid() {
+        const ret = wasm.__wbg_get_ultrahdrproberesult_isValid(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Metadata version string (empty if not found)
+     * @returns {string}
+     */
+    get metadataVersion() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_ultrahdrproberesult_metadataVersion(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Primary image width in pixels (0 if not found)
+     * @returns {number}
+     */
+    get width() {
+        const ret = wasm.__wbg_get_ultrahdrproberesult_width(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Gain map height in pixels (0 if not found)
+     * @param {number} arg0
+     */
+    set gainMapHeight(arg0) {
+        wasm.__wbg_set_ultrahdrproberesult_gainMapHeight(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Gain map width in pixels (0 if not found)
+     * @param {number} arg0
+     */
+    set gainMapWidth(arg0) {
+        wasm.__wbg_set_ultrahdrproberesult_gainMapWidth(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Whether a gain map image was found
+     * @param {boolean} arg0
+     */
+    set hasGainMap(arg0) {
+        wasm.__wbg_set_ultrahdrproberesult_hasGainMap(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Whether gain map metadata (XMP) was found
+     * @param {boolean} arg0
+     */
+    set hasMetadata(arg0) {
+        wasm.__wbg_set_ultrahdrproberesult_hasMetadata(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Whether a primary JPEG image was found
+     * @param {boolean} arg0
+     */
+    set hasPrimaryImage(arg0) {
+        wasm.__wbg_set_ultrahdrproberesult_hasPrimaryImage(this.__wbg_ptr, arg0);
+    }
+    /**
+     * HDR capacity (max additional stops of dynamic range), 0 if not found
+     * @param {number} arg0
+     */
+    set hdrCapacity(arg0) {
+        wasm.__wbg_set_ultrahdrproberesult_hdrCapacity(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Primary image height in pixels (0 if not found)
+     * @param {number} arg0
+     */
+    set height(arg0) {
+        wasm.__wbg_set_ultrahdrproberesult_height(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Whether the image is a valid UltraHDR image (has all required components)
+     * @param {boolean} arg0
+     */
+    set isValid(arg0) {
+        wasm.__wbg_set_ultrahdrproberesult_isValid(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Metadata version string (empty if not found)
+     * @param {string} arg0
+     */
+    set metadataVersion(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_ultrahdrproberesult_metadataVersion(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Primary image width in pixels (0 if not found)
+     * @param {number} arg0
+     */
+    set width(arg0) {
+        wasm.__wbg_set_ultrahdrproberesult_width(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Creates a new probe result with default (invalid) values.
+     */
+    constructor() {
+        const ret = wasm.ultrahdrproberesult_new();
+        this.__wbg_ptr = ret >>> 0;
+        UltraHdrProbeResultFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) UltraHdrProbeResult.prototype[Symbol.dispose] = UltraHdrProbeResult.prototype.free;
+
 /**
  * Creates default gain map metadata.
  *
@@ -819,6 +1015,53 @@ export function isUltraHdr(buffer) {
     return ret !== 0;
 }
 
+/**
+ * Probes an image to check if it's UltraHDR and extracts component information.
+ *
+ * This function efficiently validates if an image is UltraHDR by checking for
+ * required components (primary image, gain map, metadata) without full decoding.
+ * Returns structured results useful for batch processing and filtering.
+ *
+ * Unlike `isUltraHdr`, this function provides detailed information about what
+ * was found, making it useful for diagnostics and filtering workflows.
+ *
+ * # Arguments
+ * * `buffer` - Image file contents as bytes
+ *
+ * # Returns
+ * `UltraHdrProbeResult` containing:
+ * - `isValid`: Whether the image is a valid UltraHDR image
+ * - `hasPrimaryImage`: Whether a primary JPEG was found
+ * - `hasGainMap`: Whether a gain map image was found
+ * - `hasMetadata`: Whether XMP metadata was found
+ * - `width`, `height`: Primary image dimensions (0 if not found)
+ * - `gainMapWidth`, `gainMapHeight`: Gain map dimensions (0 if not found)
+ * - `hdrCapacity`: HDR capacity in stops (0 if not found)
+ * - `metadataVersion`: Metadata version string (empty if not found)
+ *
+ * # Example (JavaScript)
+ * ```js
+ * const buffer = await file.arrayBuffer();
+ * const result = probeUltraHdr(new Uint8Array(buffer));
+ * if (result.isValid) {
+ *     console.log('UltraHDR image:', result.width, 'x', result.height);
+ *     console.log('HDR capacity:', result.hdrCapacity, 'stops');
+ * } else {
+ *     if (!result.hasPrimaryImage) console.log('Not a JPEG');
+ *     if (!result.hasGainMap) console.log('No gain map found');
+ *     if (!result.hasMetadata) console.log('No HDR metadata');
+ * }
+ * ```
+ * @param {Uint8Array} buffer
+ * @returns {UltraHdrProbeResult}
+ */
+export function probeUltraHdr(buffer) {
+    const ptr0 = passArray8ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.probeUltraHdr(ptr0, len0);
+    return UltraHdrProbeResult.__wrap(ret);
+}
+
 /**
  * Validates gain map metadata.
  *
@@ -839,7 +1082,7 @@ export function validateMetadata(metadata) {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
+        __wbg___wbindgen_throw_6ddd609b62940d55: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
@@ -872,6 +1115,9 @@ const UltraHdrDecodeResultFinalization = (typeof FinalizationRegistry === 'undef
 const UltraHdrEncodeOptionsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ultrahdrencodeoptions_free(ptr >>> 0, 1));
+const UltraHdrProbeResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ultrahdrproberesult_free(ptr >>> 0, 1));
 
 function _assertClass(instance, klass) {
     if (!(instance instanceof klass)) {

package/pkg/open_ultrahdr_bg.wasm.d.ts

@@ -24,6 +24,15 @@ export const __wbg_get_ultrahdrencodeoptions_gainMapScale: (a: number) => number
 export const __wbg_get_ultrahdrencodeoptions_includeIsoMetadata: (a: number) => number;
 export const __wbg_get_ultrahdrencodeoptions_includeUltrahdrV1: (a: number) => number;
 export const __wbg_get_ultrahdrencodeoptions_targetHdrCapacity: (a: number) => number;
+export const __wbg_get_ultrahdrproberesult_gainMapHeight: (a: number) => number;
+export const __wbg_get_ultrahdrproberesult_gainMapWidth: (a: number) => number;
+export const __wbg_get_ultrahdrproberesult_hasGainMap: (a: number) => number;
+export const __wbg_get_ultrahdrproberesult_hasMetadata: (a: number) => number;
+export const __wbg_get_ultrahdrproberesult_hasPrimaryImage: (a: number) => number;
+export const __wbg_get_ultrahdrproberesult_hdrCapacity: (a: number) => number;
+export const __wbg_get_ultrahdrproberesult_height: (a: number) => number;
+export const __wbg_get_ultrahdrproberesult_isValid: (a: number) => number;
+export const __wbg_get_ultrahdrproberesult_width: (a: number) => number;
 export const __wbg_set_gainmapmetadata_baseRenditionIsHdr: (a: number, b: number) => void;
 export const __wbg_set_gainmapmetadata_gainMapMax: (a: number, b: number, c: number) => void;
 export const __wbg_set_gainmapmetadata_gainMapMin: (a: number, b: number, c: number) => void;
@@ -45,15 +54,28 @@ export const __wbg_set_ultrahdrencodeoptions_gainMapScale: (a: number, b: number
 export const __wbg_set_ultrahdrencodeoptions_includeIsoMetadata: (a: number, b: number) => void;
 export const __wbg_set_ultrahdrencodeoptions_includeUltrahdrV1: (a: number, b: number) => void;
 export const __wbg_set_ultrahdrencodeoptions_targetHdrCapacity: (a: number, b: number) => void;
+export const __wbg_set_ultrahdrproberesult_gainMapHeight: (a: number, b: number) => void;
+export const __wbg_set_ultrahdrproberesult_gainMapWidth: (a: number, b: number) => void;
+export const __wbg_set_ultrahdrproberesult_hasGainMap: (a: number, b: number) => void;
+export const __wbg_set_ultrahdrproberesult_hasMetadata: (a: number, b: number) => void;
+export const __wbg_set_ultrahdrproberesult_hasPrimaryImage: (a: number, b: number) => void;
+export const __wbg_set_ultrahdrproberesult_hdrCapacity: (a: number, b: number) => void;
+export const __wbg_set_ultrahdrproberesult_height: (a: number, b: number) => void;
+export const __wbg_set_ultrahdrproberesult_isValid: (a: number, b: number) => void;
+export const __wbg_set_ultrahdrproberesult_width: (a: number, b: number) => void;
 export const __wbg_ultrahdrdecoderesult_free: (a: number, b: number) => void;
 export const __wbg_ultrahdrencodeoptions_free: (a: number, b: number) => void;
+export const __wbg_ultrahdrproberesult_free: (a: number, b: number) => void;
 export const gainmapmetadata_forSdrBase: (a: number) => number;
 export const gainmapmetadata_new: () => number;
 export const ultrahdrdecoderesult_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
 export const ultrahdrencodeoptions_highQuality: () => number;
 export const ultrahdrencodeoptions_new: () => number;
 export const ultrahdrencodeoptions_smallSize: () => number;
+export const ultrahdrproberesult_new: () => number;
+export const __wbg_get_ultrahdrproberesult_metadataVersion: (a: number) => [number, number];
 export const __wbg_set_ultrahdrdecoderesult_sdrImage: (a: number, b: number, c: number) => void;
+export const __wbg_set_ultrahdrproberesult_metadataVersion: (a: number, b: number, c: number) => void;
 export const createDefaultMetadata: () => number;
 export const createDefaultOptions: () => number;
 export const createHighQualityOptions: () => number;
@@ -63,10 +85,11 @@ export const encodeUltraHdr: (a: number, b: number, c: number, d: number, e: num
 export const estimateHdrHeadroom: (a: number) => number;
 export const extractSdrBase: (a: number, b: number) => [number, number, number, number];
 export const getMetadata: (a: number, b: number) => [number, number, number];
+export const init: () => void;
 export const isMeaningfulHdr: (a: number) => number;
 export const isUltraHdr: (a: number, b: number) => number;
+export const probeUltraHdr: (a: number, b: number) => number;
 export const validateMetadata: (a: number) => number;
-export const init: () => void;
 export const __wbindgen_externrefs: WebAssembly.Table;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __externref_table_dealloc: (a: number) => void;