cross-image 0.2.4 → 0.4.0

package/esm/src/utils/webp_decoder.d.ts

@@ -19,9 +19,11 @@
  * @see https://developers.google.com/speed/webp/docs/riff_container
  * @see https://developers.google.com/speed/webp/docs/webp_lossless_bitstream_specification
  */
+import type { ImageDecoderOptions } from "../types.js";
 export declare class WebPDecoder {
     private data;
-    constructor(data: Uint8Array);
+    private options;
+    constructor(data: Uint8Array, settings?: ImageDecoderOptions);
     decode(): {
         width: number;
         height: number;

package/esm/src/utils/webp_decoder.js

@@ -93,7 +93,6 @@ class HuffmanTable {
             const bit = reader.readBits(1);
             node = bit === 0 ? node.left : node.right;
             if (!node) {
-                // console.log("Invalid Huffman code - walked off tree");
                 throw new Error("Invalid Huffman code");
             }
         }
@@ -164,14 +163,24 @@ class BitReader {
     }
 }
 export class WebPDecoder {
-    constructor(data) {
+    constructor(data, settings = {}) {
         Object.defineProperty(this, "data", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.data = data;
+        this.options = {
+            tolerantDecoding: settings.tolerantDecoding ?? true,
+            onWarning: settings.onWarning,
+        };
     }
     decode() {
         // Verify WebP signature
@@ -278,66 +287,142 @@ export class WebPDecoder {
         const numPixels = width * height;
         // Color cache for repeated colors
         const colorCache = new Uint32Array(colorCacheSize);
-        for (let i = 0; i < numPixels;) {
-            // Read green channel (which determines the code type)
-            const green = huffmanTables.green.readSymbol(reader);
-            if (green < 256) {
-                // Literal pixel
-                const red = huffmanTables.red.readSymbol(reader);
-                const blue = huffmanTables.blue.readSymbol(reader);
-                const alpha = alphaUsed !== 0
-                    ? huffmanTables.alpha.readSymbol(reader)
-                    : 255;
-                pixelData[pixelIndex++] = red;
-                pixelData[pixelIndex++] = green;
-                pixelData[pixelIndex++] = blue;
-                pixelData[pixelIndex++] = alpha;
-                // Add to color cache if enabled
-                if (useColorCache) {
-                    const color = (alpha << 24) | (blue << 16) | (green << 8) | red;
-                    colorCache[i % colorCacheSize] = color;
+        if (this.options.tolerantDecoding) {
+            // Tolerant mode: continue decoding even if errors occur
+            try {
+                for (let i = 0; i < numPixels;) {
+                    // Read green channel (which determines the code type)
+                    const green = huffmanTables.green.readSymbol(reader);
+                    if (green < 256) {
+                        // Literal pixel
+                        const red = huffmanTables.red.readSymbol(reader);
+                        const blue = huffmanTables.blue.readSymbol(reader);
+                        const alpha = alphaUsed !== 0 ? huffmanTables.alpha.readSymbol(reader) : 255;
+                        pixelData[pixelIndex++] = red;
+                        pixelData[pixelIndex++] = green;
+                        pixelData[pixelIndex++] = blue;
+                        pixelData[pixelIndex++] = alpha;
+                        // Add to color cache if enabled
+                        if (useColorCache) {
+                            const color = (alpha << 24) | (blue << 16) | (green << 8) | red;
+                            colorCache[i % colorCacheSize] = color;
+                        }
+                        i++;
+                    }
+                    else if (green < 256 + 24) {
+                        // Backward reference (LZ77)
+                        const lengthSymbol = green - 256;
+                        const length = this.getLength(lengthSymbol, reader);
+                        const distancePrefix = huffmanTables.distance.readSymbol(reader);
+                        const distance = this.getDistance(distancePrefix, reader);
+                        // Copy pixels from earlier in the stream
+                        const srcIndex = pixelIndex - distance * 4;
+                        if (srcIndex < 0) {
+                            throw new Error("Invalid backward reference");
+                        }
+                        for (let j = 0; j < length; j++) {
+                            pixelData[pixelIndex++] = pixelData[srcIndex + j * 4];
+                            pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 1];
+                            pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 2];
+                            pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 3];
+                            // Add to color cache
+                            if (useColorCache) {
+                                const color = (pixelData[pixelIndex - 1] << 24) |
+                                    (pixelData[pixelIndex - 2] << 16) |
+                                    (pixelData[pixelIndex - 3] << 8) |
+                                    pixelData[pixelIndex - 4];
+                                colorCache[(i + j) % colorCacheSize] = color;
+                            }
+                        }
+                        i += length;
+                    }
+                    else {
+                        // Color cache reference
+                        const cacheIndex = green - 256 - 24;
+                        if (cacheIndex >= colorCacheSize) {
+                            throw new Error("Invalid color cache index");
+                        }
+                        const color = colorCache[cacheIndex];
+                        pixelData[pixelIndex++] = color & 0xff; // R
+                        pixelData[pixelIndex++] = (color >> 8) & 0xff; // G
+                        pixelData[pixelIndex++] = (color >> 16) & 0xff; // B
+                        pixelData[pixelIndex++] = (color >> 24) & 0xff; // A
+                        i++;
+                    }
                 }
-                i++;
             }
-            else if (green < 256 + 24) {
-                // Backward reference (LZ77)
-                const lengthSymbol = green - 256;
-                const length = this.getLength(lengthSymbol, reader);
-                const distancePrefix = huffmanTables.distance.readSymbol(reader);
-                const distance = this.getDistance(distancePrefix, reader);
-                // Copy pixels from earlier in the stream
-                const srcIndex = pixelIndex - distance * 4;
-                if (srcIndex < 0) {
-                    throw new Error("Invalid backward reference");
+            catch (e) {
+                // Tolerant decoding: fill remaining pixels with gray (128, 128, 128, 255)
+                this.options.onWarning?.(`WebP VP8L: Partial decode at pixel ${pixelIndex / 4}/${numPixels}`, e);
+                while (pixelIndex < pixelData.length) {
+                    pixelData[pixelIndex++] = 128; // R
+                    pixelData[pixelIndex++] = 128; // G
+                    pixelData[pixelIndex++] = 128; // B
+                    pixelData[pixelIndex++] = 255; // A
                 }
-                for (let j = 0; j < length; j++) {
-                    pixelData[pixelIndex++] = pixelData[srcIndex + j * 4];
-                    pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 1];
-                    pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 2];
-                    pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 3];
-                    // Add to color cache
+            }
+        }
+        else {
+            // Non-tolerant mode: throw on first error
+            for (let i = 0; i < numPixels;) {
+                // Read green channel (which determines the code type)
+                const green = huffmanTables.green.readSymbol(reader);
+                if (green < 256) {
+                    // Literal pixel
+                    const red = huffmanTables.red.readSymbol(reader);
+                    const blue = huffmanTables.blue.readSymbol(reader);
+                    const alpha = alphaUsed !== 0 ? huffmanTables.alpha.readSymbol(reader) : 255;
+                    pixelData[pixelIndex++] = red;
+                    pixelData[pixelIndex++] = green;
+                    pixelData[pixelIndex++] = blue;
+                    pixelData[pixelIndex++] = alpha;
+                    // Add to color cache if enabled
                     if (useColorCache) {
-                        const color = (pixelData[pixelIndex - 1] << 24) |
-                            (pixelData[pixelIndex - 2] << 16) |
-                            (pixelData[pixelIndex - 3] << 8) |
-                            pixelData[pixelIndex - 4];
-                        colorCache[(i + j) % colorCacheSize] = color;
+                        const color = (alpha << 24) | (blue << 16) | (green << 8) | red;
+                        colorCache[i % colorCacheSize] = color;
                     }
+                    i++;
                 }
-                i += length;
-            }
-            else {
-                // Color cache reference
-                const cacheIndex = green - 256 - 24;
-                if (cacheIndex >= colorCacheSize) {
-                    throw new Error("Invalid color cache index");
+                else if (green < 256 + 24) {
+                    // Backward reference (LZ77)
+                    const lengthSymbol = green - 256;
+                    const length = this.getLength(lengthSymbol, reader);
+                    const distancePrefix = huffmanTables.distance.readSymbol(reader);
+                    const distance = this.getDistance(distancePrefix, reader);
+                    // Copy pixels from earlier in the stream
+                    const srcIndex = pixelIndex - distance * 4;
+                    if (srcIndex < 0) {
+                        throw new Error("Invalid backward reference");
+                    }
+                    for (let j = 0; j < length; j++) {
+                        pixelData[pixelIndex++] = pixelData[srcIndex + j * 4];
+                        pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 1];
+                        pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 2];
+                        pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 3];
+                        // Add to color cache
+                        if (useColorCache) {
+                            const color = (pixelData[pixelIndex - 1] << 24) |
+                                (pixelData[pixelIndex - 2] << 16) |
+                                (pixelData[pixelIndex - 3] << 8) |
+                                pixelData[pixelIndex - 4];
+                            colorCache[(i + j) % colorCacheSize] = color;
+                        }
+                    }
+                    i += length;
+                }
+                else {
+                    // Color cache reference
+                    const cacheIndex = green - 256 - 24;
+                    if (cacheIndex >= colorCacheSize) {
+                        throw new Error("Invalid color cache index");
+                    }
+                    const color = colorCache[cacheIndex];
+                    pixelData[pixelIndex++] = color & 0xff; // R
+                    pixelData[pixelIndex++] = (color >> 8) & 0xff; // G
+                    pixelData[pixelIndex++] = (color >> 16) & 0xff; // B
+                    pixelData[pixelIndex++] = (color >> 24) & 0xff; // A
+                    i++;
                 }
-                const color = colorCache[cacheIndex];
-                pixelData[pixelIndex++] = color & 0xff; // R
-                pixelData[pixelIndex++] = (color >> 8) & 0xff; // G
-                pixelData[pixelIndex++] = (color >> 16) & 0xff; // B
-                pixelData[pixelIndex++] = (color >> 24) & 0xff; // A
-                i++;
             }
         }
         return pixelData;
@@ -378,9 +463,7 @@ export class WebPDecoder {
             const isFirstEightBits = reader.readBits(1);
             const symbols = [];
             for (let i = 0; i < numSymbols; i++) {
-                const symbolBits = isFirstEightBits
-                    ? reader.readBits(8)
-                    : reader.readBits(1);
+                const symbolBits = isFirstEightBits ? reader.readBits(8) : reader.readBits(1);
                 symbols.push(symbolBits);
             }
             // Build simple Huffman table
@@ -396,9 +479,7 @@ export class WebPDecoder {
         }
         else {
             // Complex code - read code lengths
-            const maxSymbol = isGreen
-                ? (256 + 24 + (useColorCache ? (1 << colorCacheBits) : 0))
-                : 256;
+            const maxSymbol = isGreen ? (256 + 24 + (useColorCache ? (1 << colorCacheBits) : 0)) : 256;
             const codeLengths = this.readCodeLengths(reader, maxSymbol);
             this.buildHuffmanTable(table, codeLengths);
         }
@@ -406,7 +487,7 @@ export class WebPDecoder {
     readCodeLengths(reader, maxSymbol) {
         // Read code length codes (used to encode the actual code lengths)
         const numCodeLengthCodes = reader.readBits(4) + 4;
-        const codeLengthCodeLengths = new Array(19).fill(0);
+        const codeLengthCodeLengths = new Uint8Array(19);
         // Code length code order
         const codeLengthCodeOrder = [
             17,
@@ -442,7 +523,7 @@ export class WebPDecoder {
         const codeLengthTable = new HuffmanTable();
         this.buildHuffmanTable(codeLengthTable, codeLengthCodeLengths);
         // Read actual code lengths
-        const codeLengths = new Array(maxSymbol).fill(0);
+        const codeLengths = new Uint8Array(maxSymbol);
         let i = 0;
         while (i < maxSymbol) {
             const code = codeLengthTable.readSymbol(reader);

package/esm/src/utils/webp_encoder.js

@@ -369,7 +369,7 @@ export class WebPEncoder {
      * Returns an array where index is the symbol and value is the code length
      */
     calculateCodeLengths(frequencies, maxSymbol, maxCodeLength = 15) {
-        const codeLengths = new Array(maxSymbol).fill(0);
+        const codeLengths = new Uint8Array(maxSymbol);
         // Get symbols with non-zero frequencies
         const symbols = Array.from(frequencies.keys()).sort((a, b) => a - b);
         if (symbols.length === 0)
@@ -377,7 +377,6 @@ export class WebPEncoder {
         // For a single symbol, use code length 1
         // (Canonical Huffman codes require length >= 1)
         if (symbols.length === 1) {
-            // console.log(`Single symbol ${symbols[0]}, forcing length 1`);
             codeLengths[symbols[0]] = 1;
             return codeLengths;
         }
@@ -424,7 +423,6 @@ export class WebPEncoder {
         // If tree is too deep, flatten frequencies and rebuild
         let attempts = 0;
         while (maxDepth > maxCodeLength && attempts < 5) {
-            // console.log(`Tree too deep (${maxDepth} > ${maxCodeLength}), flattening...`);
             attempts++;
             // Add bias to frequencies to flatten the tree
             // Increase bias with each attempt
@@ -439,11 +437,8 @@ export class WebPEncoder {
             maxDepth = 0;
             checkDepth(root, 0);
         }
-        if (maxDepth > maxCodeLength) {
-            console.warn(`Failed to reduce Huffman tree depth to ${maxCodeLength} (current: ${maxDepth})`);
-            // Force hard limit by sorting and assigning lengths?
-            // For now, let's just see if this is happening.
-        }
+        // If tree depth couldn't be reduced, encoding may fail but we'll try anyway
+        // This is an internal limitation that doesn't affect most images
         // Calculate code lengths by traversing tree (iterative to avoid deep recursion)
         const stack = [{
                 node: root,
@@ -485,7 +480,7 @@ export class WebPEncoder {
             }
         }
         // Count symbols at each length
-        const lengthCounts = new Array(maxLength + 1).fill(0);
+        const lengthCounts = new Uint32Array(maxLength + 1);
         for (let i = 0; i < codeLengths.length; i++) {
             if (codeLengths[i] > 0) {
                 lengthCounts[codeLengths[i]]++;
@@ -493,7 +488,7 @@ export class WebPEncoder {
         }
         // Generate first code for each length
         let code = 0;
-        const nextCode = new Array(maxLength + 1).fill(0);
+        const nextCode = new Uint32Array(maxLength + 1);
         for (let len = 1; len <= maxLength; len++) {
             code = (code + lengthCounts[len - 1]) << 1;
             nextCode[len] = code;
@@ -625,7 +620,6 @@ export class WebPEncoder {
         }
         numCodeLengthCodes = Math.max(4, numCodeLengthCodes);
         // Write number of code length codes
-        // console.log(`Complex Huffman: numCodeLengthCodes=${numCodeLengthCodes}, rleEncoded.length=${rleEncoded.length}`);
         writer.writeBits(numCodeLengthCodes - 4, 4);
         // Write code length code lengths
         for (let i = 0; i < numCodeLengthCodes; i++) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cross-image",
-  "version": "0.2.4",
+  "version": "0.4.0",
   "description": "A pure JavaScript, dependency-free, cross-runtime image processing library for Deno, Node.js, and Bun.",
   "keywords": [
     "image",

package/script/mod.d.ts

@@ -7,7 +7,7 @@
  *
  * @example
  * ```ts
- * import { Image } from "@cross/image";
+ * import { Image } from "jsr:@cross/image";
  *
  * // Decode an image
  * const data = await Deno.readFile("input.png");
@@ -26,7 +26,7 @@
  *
  * @example
  * ```ts
- * import { Image } from "@cross/image";
+ * import { Image } from "jsr:@cross/image";
  *
  * // Create a blank canvas
  * const canvas = Image.create(400, 300, 255, 255, 255);
@@ -43,13 +43,13 @@
  * ```
  */
 export { Image } from "./src/image.js";
-export type { ASCIIOptions, FrameMetadata, ImageData, ImageFormat, ImageFrame, ImageMetadata, MultiFrameImageData, ResizeOptions, WebPEncodeOptions, } from "./src/types.js";
+export type { ASCIIEncoderOptions, FrameMetadata, ImageData, ImageDecoderOptions, ImageFormat, ImageFrame, ImageMetadata, JPEGEncoderOptions, MultiFrameImageData, ResizeOptions, TIFFEncoderOptions, WebPEncoderOptions, } from "./src/types.js";
 export { PNGFormat } from "./src/formats/png.js";
 export { APNGFormat } from "./src/formats/apng.js";
 export { JPEGFormat } from "./src/formats/jpeg.js";
 export { WebPFormat } from "./src/formats/webp.js";
 export { GIFFormat } from "./src/formats/gif.js";
-export { type TIFFEncodeOptions, TIFFFormat } from "./src/formats/tiff.js";
+export { TIFFFormat } from "./src/formats/tiff.js";
 export { BMPFormat } from "./src/formats/bmp.js";
 export { ICOFormat } from "./src/formats/ico.js";
 export { DNGFormat } from "./src/formats/dng.js";

package/script/mod.js

@@ -8,7 +8,7 @@
  *
  * @example
  * ```ts
- * import { Image } from "@cross/image";
+ * import { Image } from "jsr:@cross/image";
  *
  * // Decode an image
  * const data = await Deno.readFile("input.png");
@@ -27,7 +27,7 @@
  *
  * @example
  * ```ts
- * import { Image } from "@cross/image";
+ * import { Image } from "jsr:@cross/image";
  *
  * // Create a blank canvas
  * const canvas = Image.create(400, 300, 255, 255, 255);

package/script/src/formats/apng.d.ts

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata, MultiFrameImageData } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, MultiFrameImageData } from "../types.js";
 import { PNGBase } from "./png_base.js";
 /**
  * APNG (Animated PNG) format handler
@@ -26,25 +26,25 @@ export declare class APNGFormat extends PNGBase implements ImageFormat {
      * @param data Raw APNG image data
      * @returns Decoded image data with RGBA pixels of first frame
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, settings?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Decode all frames from APNG image
      * @param data Raw APNG image data
      * @returns Decoded multi-frame image data
      */
-    decodeFrames(data: Uint8Array): Promise<MultiFrameImageData>;
+    decodeFrames(data: Uint8Array, _settings?: ImageDecoderOptions): Promise<MultiFrameImageData>;
     /**
      * Encode RGBA image data to APNG format (single frame)
      * @param imageData Image data to encode
      * @returns Encoded APNG image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Encode multi-frame image data to APNG format
      * @param imageData Multi-frame image data to encode
      * @returns Encoded APNG image bytes
      */
-    encodeFrames(imageData: MultiFrameImageData): Promise<Uint8Array>;
+    encodeFrames(imageData: MultiFrameImageData, _options?: unknown): Promise<Uint8Array>;
     private decodeFrameData;
     /**
      * Get the list of metadata fields supported by APNG format

package/script/src/formats/apng.js

@@ -70,8 +70,8 @@ class APNGFormat extends png_base_js_1.PNGBase {
      * @param data Raw APNG image data
      * @returns Decoded image data with RGBA pixels of first frame
      */
-    async decode(data) {
-        const frames = await this.decodeFrames(data);
+    async decode(data, settings) {
+        const frames = await this.decodeFrames(data, settings);
         const firstFrame = frames.frames[0];
         return {
             width: firstFrame.width,
@@ -85,7 +85,7 @@ class APNGFormat extends png_base_js_1.PNGBase {
      * @param data Raw APNG image data
      * @returns Decoded multi-frame image data
      */
-    async decodeFrames(data) {
+    async decodeFrames(data, _settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid APNG signature or missing acTL chunk");
         }
@@ -172,9 +172,7 @@ class APNGFormat extends png_base_js_1.PNGBase {
                 const delayDen = this.readUint16(chunk.data, 22);
                 const disposeOp = chunk.data[24];
                 const blendOp = chunk.data[25];
-                const delay = delayDen === 0
-                    ? delayNum * 10
-                    : Math.round((delayNum / delayDen) * 1000);
+                const delay = delayDen === 0 ? delayNum * 10 : Math.round((delayNum / delayDen) * 1000);
                 let disposal = "none";
                 if (disposeOp === 1)
                     disposal = "background";
@@ -257,7 +255,7 @@ class APNGFormat extends png_base_js_1.PNGBase {
      * @param imageData Image data to encode
      * @returns Encoded APNG image bytes
      */
-    encode(imageData) {
+    encode(imageData, _options) {
         // For single frame, create a multi-frame with one frame
         const multiFrame = {
             width: imageData.width,
@@ -270,14 +268,14 @@ class APNGFormat extends png_base_js_1.PNGBase {
                 }],
             metadata: imageData.metadata,
         };
-        return this.encodeFrames(multiFrame);
+        return this.encodeFrames(multiFrame, _options);
     }
     /**
      * Encode multi-frame image data to APNG format
      * @param imageData Multi-frame image data to encode
      * @returns Encoded APNG image bytes
      */
-    async encodeFrames(imageData) {
+    async encodeFrames(imageData, _options) {
         const { width, height, frames, metadata } = imageData;
         if (frames.length === 0) {
             throw new Error("No frames to encode");

package/script/src/formats/ascii.d.ts

@@ -1,4 +1,4 @@
-import type { ASCIIOptions, ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ASCIIEncoderOptions, ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * ASCII format handler
  * Converts images to ASCII art text representation
@@ -22,14 +22,14 @@ export declare class ASCIIFormat implements ImageFormat {
      * @param data Raw ASCII art data
      * @returns Decoded image data with grayscale RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, _options?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Encode RGBA image data to ASCII art
      * @param imageData Image data to encode
      * @param options Optional ASCII encoding options
      * @returns Encoded ASCII art as UTF-8 bytes
      */
-    encode(imageData: ImageData, options?: ASCIIOptions): Promise<Uint8Array>;
+    encode(imageData: ImageData, options?: ASCIIEncoderOptions): Promise<Uint8Array>;
     /**
      * Parse options from the options line
      */

package/script/src/formats/ascii.js

@@ -71,7 +71,7 @@ class ASCIIFormat {
      * @param data Raw ASCII art data
      * @returns Decoded image data with grayscale RGBA pixels
      */
-    decode(data) {
+    decode(data, _options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid ASCII art signature");
         }

package/script/src/formats/avif.d.ts

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * AVIF format handler
  * Supports AVIF images using runtime APIs (ImageDecoder/OffscreenCanvas)
@@ -21,7 +21,7 @@ export declare class AVIFFormat implements ImageFormat {
      * @param data Raw AVIF image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, settings?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Encode RGBA image data to AVIF format
      * Uses runtime APIs (OffscreenCanvas) for encoding
@@ -32,7 +32,7 @@ export declare class AVIFFormat implements ImageFormat {
      * @param imageData Image data to encode
      * @returns Encoded AVIF image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Decode using runtime APIs
      * @param data Raw AVIF data

package/script/src/formats/avif.js

@@ -52,10 +52,13 @@ class AVIFFormat {
      * @param data Raw AVIF image data
      * @returns Decoded image data with RGBA pixels
      */
-    async decode(data) {
+    async decode(data, settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid AVIF signature");
         }
+        if (settings?.runtimeDecoding === "never") {
+            throw new Error("AVIF decoding requires runtime APIs; set runtimeDecoding to 'prefer'");
+        }
         // Extract metadata before decoding pixels
         const metadata = await this.extractMetadata(data);
         // Use runtime decoder
@@ -79,8 +82,8 @@ class AVIFFormat {
      * @param imageData Image data to encode
      * @returns Encoded AVIF image bytes
      */
-    async encode(imageData) {
-        const { width, height, data, metadata } = imageData;
+    async encode(imageData, _options) {
+        const { width, height, data, metadata: _metadata } = imageData;
         // Try to use runtime encoding if available
         if (typeof OffscreenCanvas !== "undefined") {
             try {
@@ -101,10 +104,7 @@ class AVIFFormat {
                     // parsing and modifying the ISOBMFF container structure
                     // For now, we rely on the runtime encoder to preserve metadata
                     // if it was passed through the canvas
-                    if (metadata) {
-                        // Future enhancement: inject metadata into AVIF container
-                        console.warn("AVIF metadata injection not yet implemented, metadata may be lost");
-                    }
+                    // Future enhancement: inject metadata into AVIF container
                     return encoded;
                 }
             }

package/script/src/formats/bmp.d.ts

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * BMP format handler
  * Implements a pure JavaScript BMP decoder and encoder
@@ -19,13 +19,13 @@ export declare class BMPFormat implements ImageFormat {
      * @param data Raw BMP image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, _options?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Encode RGBA image data to BMP format
      * @param imageData Image data to encode
      * @returns Encoded BMP image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Get the list of metadata fields supported by BMP format
      */

package/script/src/formats/bmp.js

@@ -41,7 +41,7 @@ class BMPFormat {
      * @param data Raw BMP image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data) {
+    decode(data, _options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid BMP signature");
         }
@@ -118,7 +118,7 @@ class BMPFormat {
      * @param imageData Image data to encode
      * @returns Encoded BMP image bytes
      */
-    encode(imageData) {
+    encode(imageData, _options) {
         const { width, height, data, metadata } = imageData;
         // Calculate sizes
         const bytesPerPixel = 4; // We'll encode as 32-bit RGBA

package/script/src/formats/dng.d.ts

@@ -22,7 +22,7 @@ export declare class DNGFormat extends TIFFFormat {
      * @param imageData Image data to encode
      * @returns Encoded DNG image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Get the list of metadata fields supported by DNG format
      * DNG is based on TIFF, so it supports all TIFF metadata fields