@flighthq/image-codec 0.1.0

package/dist/decodeImage.d.ts

@@ -0,0 +1,4 @@
+import type { DecodedImage } from '@flighthq/types';
+export declare function decodeImage(bytes: Readonly<Uint8Array>, mimeType?: string): Promise<DecodedImage | null>;
+export declare function decodeImagePremultiplied(bytes: Readonly<Uint8Array>, mimeType?: string): Promise<DecodedImage | null>;
+//# sourceMappingURL=decodeImage.d.ts.map

package/dist/decodeImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decodeImage.d.ts","sourceRoot":"","sources":["../src/decodeImage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAgB,MAAM,iBAAiB,CAAC;AAQlE,wBAAsB,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAI9G;AAID,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC3B,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAI9B"}

package/dist/decodeImage.js

@@ -0,0 +1,26 @@
+import { detectImageMimeType } from './detectImageMimeType';
+import { getImageDecoder } from './imageDecoderRegistry';
+// Decodes encoded image bytes to straight (non-premultiplied) RGBA. Resolves the MIME type via
+// detectImageMimeType when mimeType is omitted, then dispatches to the registered decoder. Returns null
+// when the type cannot be determined or no decoder is registered for it.
+export async function decodeImage(bytes, mimeType) {
+    const decoder = resolveImageDecoder(bytes, mimeType);
+    if (decoder === null)
+        return null;
+    return decoder(bytes);
+}
+// As decodeImage, but requests premultiplied RGBA via the decoder's premultiplyAlpha option. A decoder
+// that can premultiply in one pass does so; the web/canvas decoder falls back to a JS premultiply pass.
+export async function decodeImagePremultiplied(bytes, mimeType) {
+    const decoder = resolveImageDecoder(bytes, mimeType);
+    if (decoder === null)
+        return null;
+    return decoder(bytes, { premultiplyAlpha: true });
+}
+function resolveImageDecoder(bytes, mimeType) {
+    const type = mimeType ?? detectImageMimeType(bytes);
+    if (type === null)
+        return null;
+    return getImageDecoder(type);
+}
+//# sourceMappingURL=decodeImage.js.map

package/dist/decodeImage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decodeImage.js","sourceRoot":"","sources":["../src/decodeImage.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,+FAA+F;AAC/F,wGAAwG;AACxG,yEAAyE;AACzE,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,KAA2B,EAAE,QAAiB;IAC9E,MAAM,OAAO,GAAG,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACrD,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAClC,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC;AACxB,CAAC;AAED,uGAAuG;AACvG,wGAAwG;AACxG,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,KAA2B,EAC3B,QAAiB;IAEjB,MAAM,OAAO,GAAG,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACrD,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAClC,OAAO,OAAO,CAAC,KAAK,EAAE,EAAE,gBAAgB,EAAE,IAAI,EAAE,CAAC,CAAC;AACpD,CAAC;AAED,SAAS,mBAAmB,CAAC,KAA2B,EAAE,QAAiB;IACzE,MAAM,IAAI,GAAG,QAAQ,IAAI,mBAAmB,CAAC,KAAK,CAAC,CAAC;IACpD,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAC/B,OAAO,eAAe,CAAC,IAAI,CAAC,CAAC;AAC/B,CAAC"}

package/dist/detectImageMimeType.d.ts

@@ -0,0 +1,2 @@
+export declare function detectImageMimeType(data: Readonly<Uint8Array> | ArrayBuffer): string | null;
+//# sourceMappingURL=detectImageMimeType.d.ts.map

package/dist/detectImageMimeType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detectImageMimeType.d.ts","sourceRoot":"","sources":["../src/detectImageMimeType.ts"],"names":[],"mappings":"AAGA,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,WAAW,GAAG,MAAM,GAAG,IAAI,CA+B3F"}

package/dist/detectImageMimeType.js

@@ -0,0 +1,33 @@
+// Sniffs the MIME type of encoded image bytes from their magic-number header, or null when the header is
+// too short or unrecognized. The single point of image-format identification in the SDK, used by
+// decodeImage to auto-select a registered decoder and by @flighthq/image to type a Blob.
+export function detectImageMimeType(data) {
+    const b = data instanceof Uint8Array ? data : new Uint8Array(data);
+    if (b.byteLength < 4)
+        return null;
+    // PNG: 89 50 4E 47 0D 0A 1A 0A
+    if (b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47)
+        return 'image/png';
+    // JPEG: FF D8 FF
+    if (b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff)
+        return 'image/jpeg';
+    // GIF87a / GIF89a: 47 49 46 38
+    if (b[0] === 0x47 && b[1] === 0x49 && b[2] === 0x46 && b[3] === 0x38)
+        return 'image/gif';
+    // WebP: RIFF....WEBP (bytes 0-3 and 8-11)
+    if (b.byteLength >= 12 &&
+        b[0] === 0x52 &&
+        b[1] === 0x49 &&
+        b[2] === 0x46 &&
+        b[3] === 0x46 &&
+        b[8] === 0x57 &&
+        b[9] === 0x45 &&
+        b[10] === 0x42 &&
+        b[11] === 0x50)
+        return 'image/webp';
+    // BMP: 42 4D
+    if (b[0] === 0x42 && b[1] === 0x4d)
+        return 'image/bmp';
+    return null;
+}
+//# sourceMappingURL=detectImageMimeType.js.map

package/dist/detectImageMimeType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detectImageMimeType.js","sourceRoot":"","sources":["../src/detectImageMimeType.ts"],"names":[],"mappings":"AAAA,yGAAyG;AACzG,iGAAiG;AACjG,yFAAyF;AACzF,MAAM,UAAU,mBAAmB,CAAC,IAAwC;IAC1E,MAAM,CAAC,GAAG,IAAI,YAAY,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC;IACnE,IAAI,CAAC,CAAC,UAAU,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IAElC,+BAA+B;IAC/B,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;QAAE,OAAO,WAAW,CAAC;IAEzF,iBAAiB;IACjB,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;QAAE,OAAO,YAAY,CAAC;IAEzE,+BAA+B;IAC/B,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;QAAE,OAAO,WAAW,CAAC;IAEzF,0CAA0C;IAC1C,IACE,CAAC,CAAC,UAAU,IAAI,EAAE;QAClB,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;QACb,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;QACb,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;QACb,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;QACb,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;QACb,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;QACb,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI;QACd,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI;QAEd,OAAO,YAAY,CAAC;IAEtB,aAAa;IACb,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;QAAE,OAAO,WAAW,CAAC;IAEvD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/encodeImage.d.ts

@@ -0,0 +1,3 @@
+import type { DecodedImage, ImageEncodeOptions } from '@flighthq/types';
+export declare function encodeImage(image: Readonly<DecodedImage>, mimeType: string, options?: Readonly<ImageEncodeOptions>): Promise<Uint8Array | null>;
+//# sourceMappingURL=encodeImage.d.ts.map

package/dist/encodeImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encodeImage.d.ts","sourceRoot":"","sources":["../src/encodeImage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAMxE,wBAAsB,WAAW,CAC/B,KAAK,EAAE,QAAQ,CAAC,YAAY,CAAC,EAC7B,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,QAAQ,CAAC,kBAAkB,CAAC,GACrC,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAI5B"}

package/dist/encodeImage.js

@@ -0,0 +1,10 @@
+import { getImageEncoder } from './imageEncoderRegistry';
+// Encodes raw RGBA pixels to bytes of the given MIME type via the registered encoder. Returns null when
+// no encoder is registered for the type.
+export async function encodeImage(image, mimeType, options) {
+    const encoder = getImageEncoder(mimeType);
+    if (encoder === null)
+        return null;
+    return encoder(image, options);
+}
+//# sourceMappingURL=encodeImage.js.map

package/dist/encodeImage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encodeImage.js","sourceRoot":"","sources":["../src/encodeImage.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,wGAAwG;AACxG,yCAAyC;AACzC,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,KAA6B,EAC7B,QAAgB,EAChB,OAAsC;IAEtC,MAAM,OAAO,GAAG,eAAe,CAAC,QAAQ,CAAC,CAAC;IAC1C,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAClC,OAAO,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AACjC,CAAC"}

package/dist/imageDecoderRegistry.d.ts

@@ -0,0 +1,7 @@
+import type { ImageDecoder } from '@flighthq/types';
+export declare function clearImageDecoders(): void;
+export declare function getImageDecoder(mimeType: string): ImageDecoder | null;
+export declare function hasImageDecoder(mimeType: string): boolean;
+export declare function registerImageDecoder(mimeType: string, decoder: ImageDecoder): void;
+export declare function unregisterImageDecoder(mimeType: string): void;
+//# sourceMappingURL=imageDecoderRegistry.d.ts.map

package/dist/imageDecoderRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageDecoderRegistry.d.ts","sourceRoot":"","sources":["../src/imageDecoderRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAErE;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,IAAI,CAElF;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAE7D"}

package/dist/imageDecoderRegistry.js

@@ -0,0 +1,20 @@
+export function clearImageDecoders() {
+    decoders.clear();
+}
+export function getImageDecoder(mimeType) {
+    return decoders.get(mimeType) ?? null;
+}
+export function hasImageDecoder(mimeType) {
+    return decoders.has(mimeType);
+}
+export function registerImageDecoder(mimeType, decoder) {
+    decoders.set(mimeType, decoder);
+}
+export function unregisterImageDecoder(mimeType) {
+    decoders.delete(mimeType);
+}
+// Global MIME-keyed decoder registry. Empty at import — only register* populates it, so importing this
+// package has no side effects. Last-write-wins: a native host can override the web decoder for a MIME
+// type by registering after registerWebImageDecoders.
+const decoders = new Map();
+//# sourceMappingURL=imageDecoderRegistry.js.map

package/dist/imageDecoderRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageDecoderRegistry.js","sourceRoot":"","sources":["../src/imageDecoderRegistry.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,kBAAkB;IAChC,QAAQ,CAAC,KAAK,EAAE,CAAC;AACnB,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,QAAgB;IAC9C,OAAO,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC;AACxC,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,QAAgB;IAC9C,OAAO,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AAChC,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,QAAgB,EAAE,OAAqB;IAC1E,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;AAClC,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,QAAgB;IACrD,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AAC5B,CAAC;AAED,uGAAuG;AACvG,sGAAsG;AACtG,sDAAsD;AACtD,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAwB,CAAC"}

package/dist/imageEncoderRegistry.d.ts

@@ -0,0 +1,7 @@
+import type { ImageEncoder } from '@flighthq/types';
+export declare function clearImageEncoders(): void;
+export declare function getImageEncoder(mimeType: string): ImageEncoder | null;
+export declare function hasImageEncoder(mimeType: string): boolean;
+export declare function registerImageEncoder(mimeType: string, encoder: ImageEncoder): void;
+export declare function unregisterImageEncoder(mimeType: string): void;
+//# sourceMappingURL=imageEncoderRegistry.d.ts.map

package/dist/imageEncoderRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageEncoderRegistry.d.ts","sourceRoot":"","sources":["../src/imageEncoderRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAErE;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,IAAI,CAElF;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAE7D"}

package/dist/imageEncoderRegistry.js

@@ -0,0 +1,20 @@
+export function clearImageEncoders() {
+    encoders.clear();
+}
+export function getImageEncoder(mimeType) {
+    return encoders.get(mimeType) ?? null;
+}
+export function hasImageEncoder(mimeType) {
+    return encoders.has(mimeType);
+}
+export function registerImageEncoder(mimeType, encoder) {
+    encoders.set(mimeType, encoder);
+}
+export function unregisterImageEncoder(mimeType) {
+    encoders.delete(mimeType);
+}
+// Global MIME-keyed encoder registry. Empty at import — only register* populates it, so importing this
+// package has no side effects. Last-write-wins: a native host can override the web encoder for a MIME
+// type by registering after registerWebImageEncoders.
+const encoders = new Map();
+//# sourceMappingURL=imageEncoderRegistry.js.map

package/dist/imageEncoderRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageEncoderRegistry.js","sourceRoot":"","sources":["../src/imageEncoderRegistry.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,kBAAkB;IAChC,QAAQ,CAAC,KAAK,EAAE,CAAC;AACnB,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,QAAgB;IAC9C,OAAO,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC;AACxC,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,QAAgB;IAC9C,OAAO,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AAChC,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,QAAgB,EAAE,OAAqB;IAC1E,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;AAClC,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,QAAgB;IACrD,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AAC5B,CAAC;AAED,uGAAuG;AACvG,sGAAsG;AACtG,sDAAsD;AACtD,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAwB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './decodeImage';
+export * from './detectImageMimeType';
+export * from './encodeImage';
+export * from './imageDecoderRegistry';
+export * from './imageEncoderRegistry';
+export * from './registerWebImageDecoders';
+export * from './registerWebImageEncoders';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from './decodeImage';
+export * from './detectImageMimeType';
+export * from './encodeImage';
+export * from './imageDecoderRegistry';
+export * from './imageEncoderRegistry';
+export * from './registerWebImageDecoders';
+export * from './registerWebImageEncoders';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC"}

package/dist/registerWebImageDecoders.d.ts

@@ -0,0 +1,2 @@
+export declare function registerWebImageDecoders(): void;
+//# sourceMappingURL=registerWebImageDecoders.d.ts.map

package/dist/registerWebImageDecoders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerWebImageDecoders.d.ts","sourceRoot":"","sources":["../src/registerWebImageDecoders.ts"],"names":[],"mappings":"AAOA,wBAAgB,wBAAwB,IAAI,IAAI,CAI/C"}

package/dist/registerWebImageDecoders.js

@@ -0,0 +1,48 @@
+import { registerImageDecoder } from './imageDecoderRegistry';
+// Registers the browser's createImageBitmap + OffscreenCanvas decoder under every MIME type the platform
+// can decode. Opt-in — nothing runs until the caller invokes this. A native host registers wasm codecs
+// instead and never calls this.
+export function registerWebImageDecoders() {
+    for (const mimeType of webDecodableMimeTypes) {
+        registerImageDecoder(mimeType, decodeImageWithCanvas);
+    }
+}
+// One decoder shared across every browser-decodable MIME type: createImageBitmap sniffs the format from
+// the bytes, so the registration key does not need to reach the Blob. getImageData is always straight
+// (non-premultiplied) RGBA, so premultiplied output cannot come from a single canvas pass — when
+// premultiplyAlpha is requested we decode straight, then premultiply the pixels in JS.
+const decodeImageWithCanvas = async (bytes, options) => {
+    // slice() yields a fresh, non-readonly Uint8Array for Blob and detaches from any pooled input buffer.
+    const bitmap = await createImageBitmap(new Blob([bytes.slice()]));
+    const width = bitmap.width;
+    const height = bitmap.height;
+    const canvas = new OffscreenCanvas(width, height);
+    const context = canvas.getContext('2d');
+    context.drawImage(bitmap, 0, 0);
+    bitmap.close();
+    const data = context.getImageData(0, 0, width, height).data;
+    if (options?.premultiplyAlpha === true)
+        premultiplyRgbaInPlace(data);
+    return { data, width, height };
+};
+// In-place straight → premultiplied RGBA: scale each color channel by alpha/255. Only the premultiplied
+// decode path calls this, since canvas getImageData always yields straight alpha.
+function premultiplyRgbaInPlace(data) {
+    for (let i = 0; i < data.length; i += 4) {
+        const alpha = data[i + 3];
+        if (alpha === 255)
+            continue;
+        data[i] = (data[i] * alpha) / 255;
+        data[i + 1] = (data[i + 1] * alpha) / 255;
+        data[i + 2] = (data[i + 2] * alpha) / 255;
+    }
+}
+const webDecodableMimeTypes = [
+    'image/png',
+    'image/jpeg',
+    'image/webp',
+    'image/gif',
+    'image/avif',
+    'image/bmp',
+];
+//# sourceMappingURL=registerWebImageDecoders.js.map

package/dist/registerWebImageDecoders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerWebImageDecoders.js","sourceRoot":"","sources":["../src/registerWebImageDecoders.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D,yGAAyG;AACzG,uGAAuG;AACvG,gCAAgC;AAChC,MAAM,UAAU,wBAAwB;IACtC,KAAK,MAAM,QAAQ,IAAI,qBAAqB,EAAE,CAAC;QAC7C,oBAAoB,CAAC,QAAQ,EAAE,qBAAqB,CAAC,CAAC;IACxD,CAAC;AACH,CAAC;AAED,wGAAwG;AACxG,sGAAsG;AACtG,iGAAiG;AACjG,uFAAuF;AACvF,MAAM,qBAAqB,GAAiB,KAAK,EAC/C,KAA2B,EAC3B,OAAsC,EACf,EAAE;IACzB,sGAAsG;IACtG,MAAM,MAAM,GAAG,MAAM,iBAAiB,CAAC,IAAI,IAAI,CAAC,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;IAClE,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAC3B,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAC7B,MAAM,MAAM,GAAG,IAAI,eAAe,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAClD,MAAM,OAAO,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,CAAsC,CAAC;IAC7E,OAAO,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAChC,MAAM,CAAC,KAAK,EAAE,CAAC;IACf,MAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC;IAC5D,IAAI,OAAO,EAAE,gBAAgB,KAAK,IAAI;QAAE,sBAAsB,CAAC,IAAI,CAAC,CAAC;IACrE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;AACjC,CAAC,CAAC;AAEF,wGAAwG;AACxG,kFAAkF;AAClF,SAAS,sBAAsB,CAAC,IAAuB;IACrD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QACxC,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC1B,IAAI,KAAK,KAAK,GAAG;YAAE,SAAS;QAC5B,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,GAAG,CAAC;QAClC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,GAAG,CAAC;QAC1C,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,GAAG,CAAC;IAC5C,CAAC;AACH,CAAC;AAED,MAAM,qBAAqB,GAAsB;IAC/C,WAAW;IACX,YAAY;IACZ,YAAY;IACZ,WAAW;IACX,YAAY;IACZ,WAAW;CACZ,CAAC"}

package/dist/registerWebImageEncoders.d.ts

@@ -0,0 +1,2 @@
+export declare function registerWebImageEncoders(): void;
+//# sourceMappingURL=registerWebImageEncoders.d.ts.map

package/dist/registerWebImageEncoders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerWebImageEncoders.d.ts","sourceRoot":"","sources":["../src/registerWebImageEncoders.ts"],"names":[],"mappings":"AAMA,wBAAgB,wBAAwB,IAAI,IAAI,CAI/C"}

package/dist/registerWebImageEncoders.js

@@ -0,0 +1,23 @@
+import { registerImageEncoder } from './imageEncoderRegistry';
+// Registers the OffscreenCanvas + convertToBlob encoder under every MIME type the platform can encode.
+// Opt-in — nothing runs until the caller invokes this. A native host registers wasm encoders instead.
+export function registerWebImageEncoders() {
+    for (const mimeType of webEncodableMimeTypes) {
+        registerImageEncoder(mimeType, createCanvasImageEncoder(mimeType));
+    }
+}
+// Each encoder closes over its MIME type so convertToBlob emits that format (unlike decode, encode must
+// name the target format). quality is forwarded as the lossy-format hint; lossless PNG ignores it.
+function createCanvasImageEncoder(mimeType) {
+    return async (image, options) => {
+        const canvas = new OffscreenCanvas(image.width, image.height);
+        const context = canvas.getContext('2d');
+        // ImageData needs a mutable Uint8ClampedArray; copy so a Readonly input is honored and not aliased.
+        const pixels = new Uint8ClampedArray(image.data);
+        context.putImageData(new ImageData(pixels, image.width, image.height), 0, 0);
+        const blob = await canvas.convertToBlob({ type: mimeType, quality: options?.quality });
+        return new Uint8Array(await blob.arrayBuffer());
+    };
+}
+const webEncodableMimeTypes = ['image/png', 'image/jpeg', 'image/webp'];
+//# sourceMappingURL=registerWebImageEncoders.js.map

package/dist/registerWebImageEncoders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerWebImageEncoders.js","sourceRoot":"","sources":["../src/registerWebImageEncoders.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D,uGAAuG;AACvG,sGAAsG;AACtG,MAAM,UAAU,wBAAwB;IACtC,KAAK,MAAM,QAAQ,IAAI,qBAAqB,EAAE,CAAC;QAC7C,oBAAoB,CAAC,QAAQ,EAAE,wBAAwB,CAAC,QAAQ,CAAC,CAAC,CAAC;IACrE,CAAC;AACH,CAAC;AAED,wGAAwG;AACxG,mGAAmG;AACnG,SAAS,wBAAwB,CAAC,QAAgB;IAChD,OAAO,KAAK,EAAE,KAA6B,EAAE,OAAsC,EAAuB,EAAE;QAC1G,MAAM,MAAM,GAAG,IAAI,eAAe,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QAC9D,MAAM,OAAO,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,CAAsC,CAAC;QAC7E,oGAAoG;QACpG,MAAM,MAAM,GAAG,IAAI,iBAAiB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACjD,OAAO,CAAC,YAAY,CAAC,IAAI,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAC7E,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;QACvF,OAAO,IAAI,UAAU,CAAC,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;IAClD,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,qBAAqB,GAAsB,CAAC,WAAW,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@flighthq/image-codec",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/types": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "DOM-free image decode/encode seam: MIME-keyed decoder/encoder registry over swappable per-format backends",
+  "sideEffects": false
+}

package/src/decodeImage.test.ts

@@ -0,0 +1,63 @@
+import type { DecodedImage, ImageDecodeOptions } from '@flighthq/types';
+import { vi } from 'vitest';
+
+import { decodeImage, decodeImagePremultiplied } from './decodeImage';
+import { clearImageDecoders, registerImageDecoder } from './imageDecoderRegistry';
+
+// PNG magic bytes so the omitted-mimeType path resolves through detectImageMimeType.
+const pngBytes = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+
+function fakeDecoded(): DecodedImage {
+  return { data: new Uint8ClampedArray([1, 2, 3, 4]), width: 1, height: 1 };
+}
+
+afterEach(() => {
+  clearImageDecoders();
+});
+
+describe('decodeImage', () => {
+  it('auto-detects the MIME type when omitted and dispatches to the registered decoder', async () => {
+    const decoder = vi.fn(async () => fakeDecoded());
+    registerImageDecoder('image/png', decoder);
+    const result = await decodeImage(pngBytes);
+    expect(result).toEqual(fakeDecoded());
+    expect(decoder).toHaveBeenCalledWith(pngBytes);
+  });
+
+  it('uses an explicit MIME type over detection', async () => {
+    const decoder = vi.fn(async () => fakeDecoded());
+    registerImageDecoder('image/jpeg', decoder);
+    await decodeImage(pngBytes, 'image/jpeg');
+    expect(decoder).toHaveBeenCalledOnce();
+  });
+
+  it('returns null when no decoder is registered', async () => {
+    expect(await decodeImage(pngBytes)).toBeNull();
+  });
+
+  it('returns null when the MIME type cannot be determined', async () => {
+    expect(await decodeImage(new Uint8Array([0, 1, 2, 3]))).toBeNull();
+  });
+
+  it('does not request premultiplied output', async () => {
+    const decoder = vi.fn(async () => fakeDecoded());
+    registerImageDecoder('image/png', decoder);
+    await decodeImage(pngBytes);
+    expect(decoder).toHaveBeenCalledWith(pngBytes);
+  });
+});
+
+describe('decodeImagePremultiplied', () => {
+  it('passes premultiplyAlpha true to the decoder', async () => {
+    const decoder = vi.fn(async (_bytes: Readonly<Uint8Array>, _options?: Readonly<ImageDecodeOptions>) =>
+      fakeDecoded(),
+    );
+    registerImageDecoder('image/png', decoder);
+    await decodeImagePremultiplied(pngBytes);
+    expect(decoder).toHaveBeenCalledWith(pngBytes, { premultiplyAlpha: true });
+  });
+
+  it('returns null when no decoder is registered', async () => {
+    expect(await decodeImagePremultiplied(pngBytes)).toBeNull();
+  });
+});

package/src/detectImageMimeType.test.ts

@@ -0,0 +1,60 @@
+import { detectImageMimeType } from './detectImageMimeType';
+
+describe('detectImageMimeType', () => {
+  it('returns null for a buffer that is too small', () => {
+    expect(detectImageMimeType(new ArrayBuffer(2))).toBeNull();
+  });
+
+  it('returns null for an unrecognised header', () => {
+    const buf = new ArrayBuffer(16);
+    new Uint8Array(buf).set([0x00, 0x01, 0x02, 0x03]);
+    expect(detectImageMimeType(buf)).toBeNull();
+  });
+
+  it('detects PNG', () => {
+    const buf = new ArrayBuffer(16);
+    new Uint8Array(buf).set([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    expect(detectImageMimeType(buf)).toBe('image/png');
+  });
+
+  it('detects JPEG', () => {
+    const buf = new ArrayBuffer(16);
+    new Uint8Array(buf).set([0xff, 0xd8, 0xff, 0xe0]);
+    expect(detectImageMimeType(buf)).toBe('image/jpeg');
+  });
+
+  it('detects GIF', () => {
+    const buf = new ArrayBuffer(16);
+    new Uint8Array(buf).set([0x47, 0x49, 0x46, 0x38, 0x39, 0x61]);
+    expect(detectImageMimeType(buf)).toBe('image/gif');
+  });
+
+  it('detects WebP', () => {
+    const buf = new ArrayBuffer(16);
+    new Uint8Array(buf).set([
+      0x52,
+      0x49,
+      0x46,
+      0x46, // RIFF
+      0x00,
+      0x00,
+      0x00,
+      0x00, // size (ignored)
+      0x57,
+      0x45,
+      0x42,
+      0x50, // WEBP
+    ]);
+    expect(detectImageMimeType(buf)).toBe('image/webp');
+  });
+
+  it('detects BMP', () => {
+    const buf = new ArrayBuffer(16);
+    new Uint8Array(buf).set([0x42, 0x4d]);
+    expect(detectImageMimeType(buf)).toBe('image/bmp');
+  });
+
+  it('accepts a Uint8Array directly', () => {
+    expect(detectImageMimeType(new Uint8Array([0x89, 0x50, 0x4e, 0x47]))).toBe('image/png');
+  });
+});

package/src/encodeImage.test.ts

@@ -0,0 +1,37 @@
+import type { DecodedImage } from '@flighthq/types';
+import { vi } from 'vitest';
+
+import { encodeImage } from './encodeImage';
+import { clearImageEncoders, registerImageEncoder } from './imageEncoderRegistry';
+
+function fakeImage(): DecodedImage {
+  return { data: new Uint8ClampedArray([1, 2, 3, 4]), width: 1, height: 1 };
+}
+
+afterEach(() => {
+  clearImageEncoders();
+});
+
+describe('encodeImage', () => {
+  it('dispatches to the registered encoder and returns its bytes', async () => {
+    const bytes = new Uint8Array([9, 8, 7]);
+    const encoder = vi.fn(async () => bytes);
+    registerImageEncoder('image/png', encoder);
+    const image = fakeImage();
+    const result = await encodeImage(image, 'image/png');
+    expect(result).toBe(bytes);
+    expect(encoder).toHaveBeenCalledWith(image, undefined);
+  });
+
+  it('forwards encode options to the encoder', async () => {
+    const encoder = vi.fn(async () => new Uint8Array(0));
+    registerImageEncoder('image/jpeg', encoder);
+    const image = fakeImage();
+    await encodeImage(image, 'image/jpeg', { quality: 0.5 });
+    expect(encoder).toHaveBeenCalledWith(image, { quality: 0.5 });
+  });
+
+  it('returns null when no encoder is registered', async () => {
+    expect(await encodeImage(fakeImage(), 'image/png')).toBeNull();
+  });
+});

package/src/imageDecoderRegistry.test.ts

@@ -0,0 +1,69 @@
+import type { DecodedImage, ImageDecoder } from '@flighthq/types';
+
+import {
+  clearImageDecoders,
+  getImageDecoder,
+  hasImageDecoder,
+  registerImageDecoder,
+  unregisterImageDecoder,
+} from './imageDecoderRegistry';
+
+const fakeDecoder: ImageDecoder = async (): Promise<DecodedImage> => ({
+  data: new Uint8ClampedArray(4),
+  width: 1,
+  height: 1,
+});
+
+afterEach(() => {
+  clearImageDecoders();
+});
+
+describe('clearImageDecoders', () => {
+  it('removes every registered decoder', () => {
+    registerImageDecoder('image/png', fakeDecoder);
+    registerImageDecoder('image/jpeg', fakeDecoder);
+    clearImageDecoders();
+    expect(hasImageDecoder('image/png')).toBe(false);
+    expect(hasImageDecoder('image/jpeg')).toBe(false);
+  });
+});
+
+describe('getImageDecoder', () => {
+  it('returns the registered decoder', () => {
+    registerImageDecoder('image/png', fakeDecoder);
+    expect(getImageDecoder('image/png')).toBe(fakeDecoder);
+  });
+
+  it('returns null when no decoder is registered', () => {
+    expect(getImageDecoder('image/png')).toBeNull();
+  });
+});
+
+describe('hasImageDecoder', () => {
+  it('reflects registration state', () => {
+    expect(hasImageDecoder('image/png')).toBe(false);
+    registerImageDecoder('image/png', fakeDecoder);
+    expect(hasImageDecoder('image/png')).toBe(true);
+  });
+});
+
+describe('registerImageDecoder', () => {
+  it('is empty until called', () => {
+    expect(hasImageDecoder('image/png')).toBe(false);
+  });
+
+  it('overwrites an existing decoder (last-write-wins)', () => {
+    const other: ImageDecoder = async () => ({ data: new Uint8ClampedArray(4), width: 1, height: 1 });
+    registerImageDecoder('image/png', fakeDecoder);
+    registerImageDecoder('image/png', other);
+    expect(getImageDecoder('image/png')).toBe(other);
+  });
+});
+
+describe('unregisterImageDecoder', () => {
+  it('removes a single decoder', () => {
+    registerImageDecoder('image/png', fakeDecoder);
+    unregisterImageDecoder('image/png');
+    expect(hasImageDecoder('image/png')).toBe(false);
+  });
+});

package/src/imageEncoderRegistry.test.ts

@@ -0,0 +1,65 @@
+import type { ImageEncoder } from '@flighthq/types';
+
+import {
+  clearImageEncoders,
+  getImageEncoder,
+  hasImageEncoder,
+  registerImageEncoder,
+  unregisterImageEncoder,
+} from './imageEncoderRegistry';
+
+const fakeEncoder: ImageEncoder = async (): Promise<Uint8Array> => new Uint8Array(0);
+
+afterEach(() => {
+  clearImageEncoders();
+});
+
+describe('clearImageEncoders', () => {
+  it('removes every registered encoder', () => {
+    registerImageEncoder('image/png', fakeEncoder);
+    registerImageEncoder('image/jpeg', fakeEncoder);
+    clearImageEncoders();
+    expect(hasImageEncoder('image/png')).toBe(false);
+    expect(hasImageEncoder('image/jpeg')).toBe(false);
+  });
+});
+
+describe('getImageEncoder', () => {
+  it('returns the registered encoder', () => {
+    registerImageEncoder('image/png', fakeEncoder);
+    expect(getImageEncoder('image/png')).toBe(fakeEncoder);
+  });
+
+  it('returns null when no encoder is registered', () => {
+    expect(getImageEncoder('image/png')).toBeNull();
+  });
+});
+
+describe('hasImageEncoder', () => {
+  it('reflects registration state', () => {
+    expect(hasImageEncoder('image/png')).toBe(false);
+    registerImageEncoder('image/png', fakeEncoder);
+    expect(hasImageEncoder('image/png')).toBe(true);
+  });
+});
+
+describe('registerImageEncoder', () => {
+  it('is empty until called', () => {
+    expect(hasImageEncoder('image/png')).toBe(false);
+  });
+
+  it('overwrites an existing encoder (last-write-wins)', () => {
+    const other: ImageEncoder = async () => new Uint8Array(1);
+    registerImageEncoder('image/png', fakeEncoder);
+    registerImageEncoder('image/png', other);
+    expect(getImageEncoder('image/png')).toBe(other);
+  });
+});
+
+describe('unregisterImageEncoder', () => {
+  it('removes a single encoder', () => {
+    registerImageEncoder('image/png', fakeEncoder);
+    unregisterImageEncoder('image/png');
+    expect(hasImageEncoder('image/png')).toBe(false);
+  });
+});

package/src/registerWebImageDecoders.test.ts

@@ -0,0 +1,67 @@
+import { vi } from 'vitest';
+
+import { clearImageDecoders, getImageDecoder, hasImageDecoder } from './imageDecoderRegistry';
+import { registerWebImageDecoders } from './registerWebImageDecoders';
+
+// jsdom / node lack createImageBitmap + OffscreenCanvas + Blob; these minimal stand-ins let the
+// canvas decoder run. getImageData always returns straight (non-premultiplied) RGBA, matching the browser.
+const straightPixels = [200, 100, 50, 128];
+
+class MockOffscreenCanvas {
+  constructor(
+    readonly width: number,
+    readonly height: number,
+  ) {}
+
+  getContext(): unknown {
+    return {
+      drawImage: vi.fn(),
+      getImageData: () => ({ data: new Uint8ClampedArray(straightPixels) }),
+    };
+  }
+}
+
+beforeEach(() => {
+  vi.stubGlobal(
+    'createImageBitmap',
+    vi.fn(async () => ({ width: 1, height: 1, close: vi.fn() })),
+  );
+  vi.stubGlobal('OffscreenCanvas', MockOffscreenCanvas);
+  vi.stubGlobal(
+    'Blob',
+    class {
+      constructor(readonly parts: readonly unknown[]) {}
+    },
+  );
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  clearImageDecoders();
+});
+
+describe('registerWebImageDecoders', () => {
+  it('registers a decoder under every browser-decodable MIME type', () => {
+    registerWebImageDecoders();
+    for (const mimeType of ['image/png', 'image/jpeg', 'image/webp', 'image/gif', 'image/avif', 'image/bmp']) {
+      expect(hasImageDecoder(mimeType)).toBe(true);
+    }
+  });
+
+  it('decodes to straight (non-premultiplied) RGBA', async () => {
+    registerWebImageDecoders();
+    const decoder = getImageDecoder('image/png');
+    const result = await decoder!(new Uint8Array([0x89, 0x50, 0x4e, 0x47]));
+    expect(result.width).toBe(1);
+    expect(result.height).toBe(1);
+    expect(Array.from(result.data)).toEqual(straightPixels);
+  });
+
+  it('premultiplies the straight result when premultiplyAlpha is requested', async () => {
+    registerWebImageDecoders();
+    const decoder = getImageDecoder('image/png');
+    const result = await decoder!(new Uint8Array([0x89, 0x50, 0x4e, 0x47]), { premultiplyAlpha: true });
+    // 200*128/255 -> 100, 100*128/255 -> 50, 50*128/255 -> 25, alpha unchanged.
+    expect(Array.from(result.data)).toEqual([100, 50, 25, 128]);
+  });
+});

package/src/registerWebImageEncoders.test.ts

@@ -0,0 +1,74 @@
+import type { DecodedImage } from '@flighthq/types';
+import { vi } from 'vitest';
+
+import { clearImageEncoders, getImageEncoder, hasImageEncoder } from './imageEncoderRegistry';
+import { registerWebImageEncoders } from './registerWebImageEncoders';
+
+// node lacks OffscreenCanvas + ImageData; these stand-ins record the convertToBlob call and hand back
+// fixed bytes so the encoder's byte extraction can be verified.
+const convertToBlobMock = vi.fn(async (_options: { type: string; quality?: number }) => ({
+  arrayBuffer: async () => new Uint8Array([1, 2, 3]).buffer,
+}));
+
+class MockOffscreenCanvas {
+  constructor(
+    readonly width: number,
+    readonly height: number,
+  ) {}
+
+  getContext(): unknown {
+    return { putImageData: vi.fn() };
+  }
+
+  convertToBlob(options: { type: string; quality?: number }): Promise<{ arrayBuffer: () => Promise<ArrayBuffer> }> {
+    return convertToBlobMock(options);
+  }
+}
+
+function fakeImage(): DecodedImage {
+  return { data: new Uint8ClampedArray([10, 20, 30, 255]), width: 1, height: 1 };
+}
+
+beforeEach(() => {
+  vi.stubGlobal('OffscreenCanvas', MockOffscreenCanvas);
+  vi.stubGlobal(
+    'ImageData',
+    class {
+      constructor(
+        readonly data: Uint8ClampedArray,
+        readonly width: number,
+        readonly height: number,
+      ) {}
+    },
+  );
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  convertToBlobMock.mockClear();
+  clearImageEncoders();
+});
+
+describe('registerWebImageEncoders', () => {
+  it('registers an encoder under every browser-encodable MIME type', () => {
+    registerWebImageEncoders();
+    for (const mimeType of ['image/png', 'image/jpeg', 'image/webp']) {
+      expect(hasImageEncoder(mimeType)).toBe(true);
+    }
+  });
+
+  it('encodes to bytes via convertToBlob under the registered MIME type', async () => {
+    registerWebImageEncoders();
+    const encoder = getImageEncoder('image/png');
+    const bytes = await encoder!(fakeImage());
+    expect(Array.from(bytes)).toEqual([1, 2, 3]);
+    expect(convertToBlobMock).toHaveBeenCalledWith({ type: 'image/png', quality: undefined });
+  });
+
+  it('forwards the quality option to convertToBlob', async () => {
+    registerWebImageEncoders();
+    const encoder = getImageEncoder('image/jpeg');
+    await encoder!(fakeImage(), { quality: 0.7 });
+    expect(convertToBlobMock).toHaveBeenCalledWith({ type: 'image/jpeg', quality: 0.7 });
+  });
+});