cross-image 0.2.4 → 0.4.0

package/esm/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/esm/mod.js

@@ -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);

package/esm/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/esm/src/formats/apng.js

@@ -67,8 +67,8 @@ export class APNGFormat extends 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,
@@ -82,7 +82,7 @@ export class APNGFormat extends 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");
         }
@@ -169,9 +169,7 @@ export class APNGFormat extends 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";
@@ -254,7 +252,7 @@ export class APNGFormat extends 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,
@@ -267,14 +265,14 @@ export class APNGFormat extends 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/esm/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/esm/src/formats/ascii.js

@@ -68,7 +68,7 @@ export 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/esm/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/esm/src/formats/avif.js

@@ -49,10 +49,13 @@ export 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
@@ -76,8 +79,8 @@ export 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 {
@@ -98,10 +101,7 @@ export 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/esm/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/esm/src/formats/bmp.js

@@ -38,7 +38,7 @@ export 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");
         }
@@ -115,7 +115,7 @@ export 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/esm/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

package/esm/src/formats/dng.js

@@ -74,7 +74,7 @@ export class DNGFormat extends TIFFFormat {
      * @param imageData Image data to encode
      * @returns Encoded DNG image bytes
      */
-    encode(imageData) {
+    encode(imageData, _options) {
         const { width, height, data } = imageData;
         // We'll create a Linear DNG (demosaiced RGB)
         // This is very similar to a standard TIFF but with specific tags.

package/esm/src/formats/gif.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";
 /**
  * GIF format handler
  * Now includes pure-JS implementation with custom LZW compression/decompression
@@ -32,18 +32,18 @@ export declare class GIFFormat implements ImageFormat {
      * @param data Raw GIF image data
      * @returns Decoded image data with RGBA pixels of first frame
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, settings?: ImageDecoderOptions): Promise<ImageData>;
     private extractGIFMetadata;
     /**
      * Encode RGBA image data to GIF format (single frame)
      * @param imageData Image data to encode
      * @returns Encoded GIF image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Decode all frames from an animated GIF
      */
-    decodeFrames(data: Uint8Array): Promise<MultiFrameImageData>;
+    decodeFrames(data: Uint8Array, settings?: ImageDecoderOptions): Promise<MultiFrameImageData>;
     /**
      * Encode multi-frame image data to animated GIF
      */

package/esm/src/formats/gif.js

@@ -56,13 +56,16 @@ export class GIFFormat {
      * @param data Raw GIF image data
      * @returns Decoded image data with RGBA pixels of first frame
      */
-    async decode(data) {
+    async decode(data, settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid GIF signature");
         }
-        // Try pure-JS decoder first
+        // Try pure-JS decoder first with tolerant decoding enabled by default
         try {
-            const decoder = new GIFDecoder(data);
+            const decoder = new GIFDecoder(data, {
+                tolerantDecoding: settings?.tolerantDecoding ?? true,
+                onWarning: settings?.onWarning,
+            });
             const result = decoder.decode();
             // Validate dimensions for security (prevent integer overflow and heap exhaustion)
             validateImageDimensions(result.width, result.height);
@@ -75,9 +78,8 @@ export class GIFFormat {
                 metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
             };
         }
-        catch (error) {
+        catch (_error) {
             // Fall back to runtime decoder if pure-JS fails
-            console.warn("Pure-JS GIF decoder failed, falling back to runtime:", error);
             let pos = 6; // Skip "GIF89a" or "GIF87a"
             const width = readUint16LE(data, pos);
             pos += 2;
@@ -151,7 +153,7 @@ export class GIFFormat {
      * @param imageData Image data to encode
      * @returns Encoded GIF image bytes
      */
-    async encode(imageData) {
+    async encode(imageData, _options) {
         const { width, height, data, metadata } = imageData;
         // Try pure-JS encoder first
         try {
@@ -164,9 +166,8 @@ export class GIFFormat {
             }
             return encoded;
         }
-        catch (error) {
+        catch (_error) {
             // Fall back to runtime encoding if pure-JS fails
-            console.warn("Pure-JS GIF encoder failed, falling back to runtime:", error);
             if (typeof OffscreenCanvas !== "undefined") {
                 try {
                     const canvas = new OffscreenCanvas(width, height);
@@ -199,12 +200,15 @@ export class GIFFormat {
     /**
      * Decode all frames from an animated GIF
      */
-    decodeFrames(data) {
+    decodeFrames(data, settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid GIF signature");
         }
         try {
-            const decoder = new GIFDecoder(data);
+            const decoder = new GIFDecoder(data, {
+                tolerantDecoding: settings?.tolerantDecoding ?? true,
+                onWarning: settings?.onWarning,
+            });
             const result = decoder.decodeAllFrames();
             // Extract metadata from comment extensions
             const metadata = this.extractGIFMetadata(data);

package/esm/src/formats/heic.d.ts

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * HEIC format handler
  * Supports HEIC/HEIF images using runtime APIs (ImageDecoder/OffscreenCanvas)
@@ -21,7 +21,7 @@ export declare class HEICFormat implements ImageFormat {
      * @param data Raw HEIC 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 HEIC format
      * Uses runtime APIs (OffscreenCanvas) for encoding
@@ -32,7 +32,7 @@ export declare class HEICFormat implements ImageFormat {
      * @param imageData Image data to encode
      * @returns Encoded HEIC image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Decode using runtime APIs
      * @param data Raw HEIC data

package/esm/src/formats/heic.js

@@ -50,10 +50,13 @@ export class HEICFormat {
      * @param data Raw HEIC image data
      * @returns Decoded image data with RGBA pixels
      */
-    async decode(data) {
+    async decode(data, settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid HEIC signature");
         }
+        if (settings?.runtimeDecoding === "never") {
+            throw new Error("HEIC decoding requires runtime APIs; set runtimeDecoding to 'prefer'");
+        }
         // Extract metadata before decoding pixels
         const metadata = await this.extractMetadata(data);
         // Use runtime decoder
@@ -77,8 +80,8 @@ export class HEICFormat {
      * @param imageData Image data to encode
      * @returns Encoded HEIC 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 {
@@ -99,10 +102,7 @@ export class HEICFormat {
                     // 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 HEIC container
-                        console.warn("HEIC metadata injection not yet implemented, metadata may be lost");
-                    }
+                    // Future enhancement: inject metadata into HEIC container
                     return encoded;
                 }
             }

package/esm/src/formats/ico.d.ts

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * ICO format handler
  * Implements a pure JavaScript ICO (Windows Icon) decoder and encoder
@@ -24,7 +24,7 @@ export declare class ICOFormat implements ImageFormat {
      * @param data Raw ICO image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, options?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Decode a DIB (Device Independent Bitmap) format
      * This is a BMP without the 14-byte file header
@@ -36,7 +36,7 @@ export declare class ICOFormat implements ImageFormat {
      * @param imageData Image data to encode
      * @returns Encoded ICO image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Get the list of metadata fields supported by ICO format
      */

package/esm/src/formats/ico.js

@@ -49,7 +49,7 @@ export class ICOFormat {
      * @param data Raw ICO image data
      * @returns Decoded image data with RGBA pixels
      */
-    async decode(data) {
+    async decode(data, options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid ICO signature");
         }
@@ -100,7 +100,7 @@ export class ICOFormat {
             imageData[2] === 0x4e &&
             imageData[3] === 0x47) {
             // It's a PNG, decode it
-            return await this.pngFormat.decode(imageData);
+            return await this.pngFormat.decode(imageData, options);
         }
         // Otherwise, it's a BMP without the file header (DIB format)
         return this.decodeDIB(imageData);
@@ -182,10 +182,10 @@ export class ICOFormat {
      * @param imageData Image data to encode
      * @returns Encoded ICO image bytes
      */
-    async encode(imageData) {
+    async encode(imageData, _options) {
         const { width, height } = imageData;
         // Encode the image as PNG
-        const pngData = await this.pngFormat.encode(imageData);
+        const pngData = await this.pngFormat.encode(imageData, undefined);
         // Create ICO file structure
         // ICONDIR (6 bytes) + ICONDIRENTRY (16 bytes) + PNG data
         const icoSize = 6 + 16 + pngData.length;

package/esm/src/formats/jpeg.d.ts

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, JPEGEncoderOptions } from "../types.js";
 /**
  * JPEG format handler
  * Implements a basic JPEG decoder and encoder
@@ -19,13 +19,13 @@ export declare class JPEGFormat implements ImageFormat {
      * @param data Raw JPEG 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 JPEG format
      * @param imageData Image data to encode
      * @returns Encoded JPEG image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, options?: JPEGEncoderOptions): Promise<Uint8Array>;
     private injectMetadata;
     private decodeUsingRuntime;
     private parseJFIF;

package/esm/src/formats/jpeg.js

@@ -37,7 +37,7 @@ export class JPEGFormat {
      * @param data Raw JPEG image data
      * @returns Decoded image data with RGBA pixels
      */
-    async decode(data) {
+    async decode(data, settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid JPEG signature");
         }
@@ -95,7 +95,7 @@ export class JPEGFormat {
         validateImageDimensions(width, height);
         // For a pure JS implementation, we'd need to implement full JPEG decoding
         // which is very complex. Instead, we'll use the browser/runtime's decoder.
-        const rgba = await this.decodeUsingRuntime(data, width, height);
+        const rgba = await this.decodeUsingRuntime(data, width, height, settings);
         return {
             width,
             height,
@@ -108,10 +108,13 @@ export class JPEGFormat {
      * @param imageData Image data to encode
      * @returns Encoded JPEG image bytes
      */
-    async encode(imageData) {
+    async encode(imageData, options) {
         const { width, height, data, metadata } = imageData;
+        const requestedQuality = options?.quality;
+        const requestedProgressive = options?.progressive;
         // Try to use runtime encoding if available (better quality)
-        if (typeof OffscreenCanvas !== "undefined") {
+        // Note: progressive output is only supported by the pure-JS encoder.
+        if (!requestedProgressive && typeof OffscreenCanvas !== "undefined") {
             try {
                 const canvas = new OffscreenCanvas(width, height);
                 const ctx = canvas.getContext("2d");
@@ -120,9 +123,12 @@ export class JPEGFormat {
                     const imgDataData = new Uint8ClampedArray(data);
                     imgData.data.set(imgDataData);
                     ctx.putImageData(imgData, 0, 0);
+                    const quality = requestedQuality === undefined
+                        ? 0.9
+                        : Math.max(1, Math.min(100, requestedQuality)) / 100;
                     const blob = await canvas.convertToBlob({
                         type: "image/jpeg",
-                        quality: 0.9,
+                        quality,
                     });
                     const arrayBuffer = await blob.arrayBuffer();
                     const encoded = new Uint8Array(arrayBuffer);
@@ -141,7 +147,10 @@ export class JPEGFormat {
         const { JPEGEncoder } = await import("../utils/jpeg_encoder.js");
         const dpiX = metadata?.dpiX ?? 72;
         const dpiY = metadata?.dpiY ?? 72;
-        const encoder = new JPEGEncoder(85); // Quality 85
+        const encoder = new JPEGEncoder({
+            quality: requestedQuality,
+            progressive: requestedProgressive,
+        });
         const encoded = encoder.encode(width, height, data, dpiX, dpiY);
         // Add EXIF metadata if present
         if (metadata && Object.keys(metadata).length > 0) {
@@ -185,9 +194,10 @@ export class JPEGFormat {
         result.set(encoded.slice(pos), pos + app1.length);
         return result;
     }
-    async decodeUsingRuntime(data, _width, _height) {
+    async decodeUsingRuntime(data, _width, _height, settings) {
         // Try to use ImageDecoder API if available (Deno, modern browsers)
-        if (typeof ImageDecoder !== "undefined") {
+        if (settings?.runtimeDecoding !== "never" &&
+            typeof ImageDecoder !== "undefined") {
             try {
                 const decoder = new ImageDecoder({ data, type: "image/jpeg" });
                 const result = await decoder.decode();
@@ -202,15 +212,17 @@ export class JPEGFormat {
                 bitmap.close();
                 return new Uint8Array(imageData.data.buffer);
             }
-            catch (error) {
+            catch (_error) {
                 // ImageDecoder API failed, fall through to pure JS decoder
-                console.warn("JPEG decoding with ImageDecoder failed, using pure JS decoder:", error);
             }
         }
         // Fallback to pure JavaScript decoder
         try {
             const { JPEGDecoder } = await import("../utils/jpeg_decoder.js");
-            const decoder = new JPEGDecoder(data);
+            const decoder = new JPEGDecoder(data, {
+                tolerantDecoding: settings?.tolerantDecoding ?? true,
+                onWarning: settings?.onWarning,
+            });
             return decoder.decode();
         }
         catch (error) {

package/esm/src/formats/pam.d.ts

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * PAM format handler
  * Implements the Netpbm PAM (Portable Arbitrary Map) format.
@@ -32,13 +32,13 @@ export declare class PAMFormat implements ImageFormat {
      * @param data Raw PAM 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 PAM format
      * @param imageData Image data to encode
      * @returns Encoded PAM image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Get the list of metadata fields supported by PAM format
      */