@@ -1,6 +1,12 @@
 # Changelog
 
-## 3.5.1
+## 3.6.0
+
+### Features
+
+- `Image.encodeAVIF()` and `Image.encodeJXL()` take `metadata` like the other encoders: author, description,
+  copyright, creation time and software (by default ImageScript and its version) as Exif. In AVIFs it is an Exif item
+  describing the image, JPEG XLs get the container (with an Exif box; the codestream stays what `cjxl -e 1` writes).
 
 ### Improvements
 
 
@@ -1,7 +1,7 @@
 /*!
  * Encodes AVIFs: the image as an AV1 still picture (YUV of BT.601's matrix, full range, like avifenc's defaults; RGB
- * if lossless, monochrome if gray), transparency as a monochrome auxiliary image, in a HEIF container with the boxes
- * libavif writes. The quality maps to the quantizer like avifenc's, with libaom's quantizer_to_qindex (Copyright (c)
+ * if lossless, monochrome if gray), transparency as a monochrome auxiliary image, Exif as a metadata item, in a HEIF
+ * container with the boxes libavif writes. The quality maps to the quantizer like avifenc's, with libaom's quantizer_to_qindex (Copyright (c)
  * 2016, Alliance for Open Media, BSD-2-Clause License, see THIRD_PARTY_NOTICES.md)
  */
 import { encodeAV1 } from './av1/encode.ts';
@@ -16,6 +16,8 @@ export interface AVIFOptions {
     subsampling: '4:4:4' | '4:2:0';
     /** how hard to search for the best modes, 0-2 */
     effort: number;
+    /** Exif data (a TIFF header and IFDs) */
+    exif?: Uint8Array;
 }
 
 // libaom's quantizer_to_qindex (avifenc's quality: (100 - quality) * 63 / 100, rounded)
@@ -168,7 +170,7 @@ function seqMonochrome(d: Uint8Array, o: number): boolean {
 }
 
 /** Encodes RGBA pixels as an AVIF (with an alpha image if the image has transparency) */
-export function encode(rgba: Uint8Array, width: number, height: number, { quality, alphaQuality, subsampling, effort }: AVIFOptions): Uint8Array {
+export function encode(rgba: Uint8Array, width: number, height: number, { quality, alphaQuality, subsampling, effort, exif }: AVIFOptions): Uint8Array {
     if (width < 1 || height < 1) throw new RangeError('AVIF: dimensions must be at least 1');
     if (width > 65536 || height > 65536) throw new RangeError('AVIF: dimensions must be at most 65536');
     let opaque = true;
@@ -195,11 +197,18 @@ export function encode(rgba: Uint8Array, width: number, height: number, { qualit
     // the boxes: ftyp, meta (the items, their locations in mdat, their properties), mdat
     const profile = subsampled || gray ? 'MA1B' : 'MA1A';
     const ftyp = box('ftyp', ascii('avif'), u32(0), ascii('avif'), ascii('mif1'), ascii('miaf'), ascii(profile));
-    const hdlr = fullBox('hdlr', 0, 0, u32(0), ascii('pict'), u32(0), u32(0), u32(0), ascii('ImageScript'), [0]);
+    const hdlr = fullBox('hdlr', 0, 0, u32(0), ascii('pict'), u32(0), u32(0), u32(0), [0]);
     const pitm = fullBox('pitm', 0, 0, u16(1));
-    const infe = (id: number, name: string): number[] => fullBox('infe', 2, 0, u16(id), u16(0), ascii('av01'), ascii(name), [0]);
-    const iinf = fullBox('iinf', 0, 0, u16(alpha ? 2 : 1), infe(1, 'Color'), alpha ? infe(2, 'Alpha') : []);
-    const iref = alpha ? fullBox('iref', 0, 0, box('auxl', u16(2), u16(1), u16(1))) : [];
+    // the items: the color image (1), the alpha image, the Exif data (its TIFF header's offset, 0, then the TIFF data)
+    const items: { type: string, name: string, data: ArrayLike<number>[] }[] = [{ type: 'av01', name: 'Color', data: [color] }];
+    if (alpha) items.push({ type: 'av01', name: 'Alpha', data: [alpha] });
+    if (exif?.length) items.push({ type: 'Exif', name: 'Exif', data: [u32(0), exif] });
+    const sizes = items.map(item => item.data.reduce((n, d) => n + d.length, 0));
+    const infe = (id: number, type: string, name: string): number[] => fullBox('infe', 2, 0, u16(id), u16(0), ascii(type), ascii(name), [0]);
+    const iinf = fullBox('iinf', 0, 0, u16(items.length), ...items.map((item, i) => infe(i + 1, item.type, item.name)));
+    // (the alpha image is auxiliary to the color image, the Exif data describes it)
+    const exifId = exif?.length ? items.length : 0;
+    const iref = alpha || exifId ? fullBox('iref', 0, 0, alpha ? box('auxl', u16(2), u16(1), u16(1)) : [], exifId ? box('cdsc', u16(exifId), u16(1), u16(1)) : []) : [];
     const ispe = fullBox('ispe', 0, 0, u32(width), u32(height));
     const colr = box('colr', ascii('nclx'), u16(cicp[0]), u16(cicp[1]), u16(cicp[2]), [0x80]);
     const pixi = (channels: number): number[] => fullBox('pixi', 0, 0, [channels], new Array<number>(channels).fill(8));
@@ -208,18 +217,24 @@ export function encode(rgba: Uint8Array, width: number, height: number, { qualit
     const ipco = box('ipco', ispe, av1C(color), colr, pixi(gray ? 1 : 3), alpha ? av1C(alpha) : [], alpha ? pixi(1) : [], alpha ? auxC : []);
     const ipma = fullBox('ipma', 0, 0, u32(alpha ? 2 : 1), u16(1), [4, 1, 0x82, 3, 4], alpha ? [...u16(2), 4, 1, 0x85, 6, 7] : []);
     const iprp = box('iprp', ipco, ipma);
-    // the locations (absolute offsets into mdat, filled in once the size of meta is known)
-    const ilocFor = (offset: number): number[] => fullBox('iloc', 0, 0, [0x44, 0x00], u16(alpha ? 2 : 1),
-        u16(1), u16(0), u16(1), u32(offset), u32(color.length),
-        alpha ? [...u16(2), ...u16(0), ...u16(1), ...u32(offset + color.length), ...u32(alpha.length)] : []);
+    // the locations (absolute offsets into mdat, one after the other, filled in once the size of meta is known)
+    const ilocFor = (offset: number): number[] => fullBox('iloc', 0, 0, [0x44, 0x00], u16(items.length), ...items.map((_, i) => {
+        const at = offset + sizes.slice(0, i).reduce((n, size) => n + size, 0);
+        return [...u16(i + 1), ...u16(0), ...u16(1), ...u32(at), ...u32(sizes[i])];
+    }));
     const metaFor = (offset: number): number[] => fullBox('meta', 0, 0, hdlr, pitm, ilocFor(offset), iinf, iref, iprp);
     const headerSize = ftyp.length + metaFor(0).length + 8;
     const head = [...ftyp, ...metaFor(headerSize)];
-    const mdatSize = 8 + color.length + (alpha ? alpha.length : 0);
+    const mdatSize = 8 + sizes.reduce((n, size) => n + size, 0);
     const out = new Uint8Array(head.length + mdatSize);
     out.set(head);
     out.set([...u32(mdatSize), ...ascii('mdat')], head.length);
-    out.set(color, head.length + 8);
-    if (alpha) out.set(alpha, head.length + 8 + color.length);
+    let at = head.length + 8;
+    for (const item of items) {
+        for (const d of item.data) {
+            out.set(d, at);
+            at += d.length;
+        }
+    }
     return out;
 }
@@ -1,7 +1,7 @@
 /*!
  * JPEG XL (ISO/IEC 18181): bare codestreams and the container (ISO/IEC 18181-2: jxlc, jxlp boxes), the image header,
  * the frames up to the first one shown (with its orientation); see ./jxl/ for the decoder, ported from jxl-oxide and
- * libjxl (see THIRD_PARTY_NOTICES.md)
+ * libjxl (see THIRD_PARTY_NOTICES.md). Encoded images with Exif get the container (signature, ftyp, Exif, jxlc boxes)
  */
 import { MAX_PIXELS, checkPixels } from '../util/limits.ts';
 import { BitReader } from './jxl/bits.ts';
@@ -10,7 +10,8 @@ import { frameHeader, toc } from './jxl/frame-header.ts';
 import { decodeFrame, DecoderState } from './jxl/frame.ts';
 import { ColorOutput } from './jxl/color.ts';
 import { ToneMapping } from './hdr.ts';
-export { encodeRGBA as encode } from './jxl/fast-lossless.ts';
+import { encodeRGBA } from './jxl/fast-lossless.ts';
+import { concat } from '../util/mem.ts';
 
 const CONTAINER = [0, 0, 0, 12, 0x4a, 0x58, 0x4c, 0x20, 0x0d, 0x0a, 0x87, 0x0a];
 
@@ -20,6 +21,21 @@ export function isJXL(d: Uint8Array): boolean {
     return d.length >= 12 && CONTAINER.every((v, i) => d[i] === v);
 }
 
+/** Encodes RGBA pixels as a lossless JPEG XL: the codestream, in the container if there is Exif data (a TIFF header and IFDs) */
+export function encode(rgba: Uint8Array, width: number, height: number, exif?: Uint8Array): Uint8Array {
+    const stream = encodeRGBA(rgba, width, height);
+    if (!exif?.length) return stream;
+    // (ftyp: brand jxl, minor version 0, compatible jxl; Exif: the offset of the TIFF header, 0, then the TIFF data)
+    const jxl = [0x6a, 0x78, 0x6c, 0x20];
+    return concat([CONTAINER, ...box('ftyp', jxl, [0, 0, 0, 0], jxl), ...box('Exif', [0, 0, 0, 0], exif), ...box('jxlc', stream)]);
+}
+
+// a box: its header and content
+const box = (type: string, ...content: ArrayLike<number>[]): ArrayLike<number>[] => {
+    const size = 8 + content.reduce((n, c) => n + c.length, 0);
+    return [[size >>> 24, size >> 16 & 255, size >> 8 & 255, size & 255, ...Array.from(type, c => c.charCodeAt(0))], ...content];
+};
+
 const fourcc = (d: Uint8Array, o: number): string => String.fromCharCode(d[o], d[o + 1], d[o + 2], d[o + 3]);
 
 /** The codestream of a file: itself, or the container's jxlc box or jxlp boxes joined */
 
@@ -119,7 +119,7 @@ export interface WebPEncodeOptions {
     metadata?: Metadata;
 }
 
-/** Options of {@link Image.encodeTGA} */
+/** Options of {@link Image.encodeTGA} and {@link Image.encodeJXL} */
 export interface EncodeOptions {
     /** Metadata to include, see {@link Metadata} */
     metadata?: Metadata;
@@ -185,6 +185,8 @@ export interface AVIFEncodeOptions {
     subsampling?: '4:4:4' | '4:2:0';
     /** How hard the encoder searches for the best modes: 0-2, faster to smaller. Default: `1` */
     effort?: number;
+    /** Metadata to include, see {@link Metadata} */
+    metadata?: Metadata;
 }
 
 /** Text style options of {@link Image.renderText} */
@@ -2080,17 +2082,20 @@ export class Image {
      * Encodes the image as AVIF (AV1, with an alpha image if the image has transparency)
      * @param options See {@link AVIFEncodeOptions}
      */
-    async encodeAVIF({ quality = 60, alphaQuality = 100, subsampling = '4:4:4', effort = 1 }: AVIFEncodeOptions = {}): Promise<Uint8Array> {
-        return avifEnc.encode(this.__bytes__(), this.width, this.height, { quality: finite(quality, 'quality'), alphaQuality: finite(alphaQuality, 'alphaQuality'), subsampling, effort });
+    async encodeAVIF({ quality = 60, alphaQuality = 100, subsampling = '4:4:4', effort = 1, metadata = {} }: AVIFEncodeOptions = {}): Promise<Uint8Array> {
+        const exif = exifData(resolveMetadata(metadata));
+        return avifEnc.encode(this.__bytes__(), this.width, this.height, { quality: finite(quality, 'quality'), alphaQuality: finite(alphaQuality, 'alphaQuality'), subsampling, effort, exif });
     }
 
     /**
-     * Encodes the image as lossless JPEG XL, byte for byte like libjxl's `cjxl -e 1` on CPUs with AVX2 or NEON (its
-     * fast lossless mode: the gradient predictor, a palette if the image has at most 511 colors besides black, else
-     * YCoCg); greyscale if the image is, with alpha if it has transparency
+     * Encodes the image as lossless JPEG XL, the codestream byte for byte like libjxl's `cjxl -e 1` on CPUs with AVX2
+     * or NEON (its fast lossless mode: the gradient predictor, a palette if the image has at most 511 colors besides
+     * black, else YCoCg); greyscale if the image is, with alpha if it has transparency. The codestream is in the
+     * container, with the metadata as Exif
+     * @param options See {@link EncodeOptions}
      */
-    async encodeJXL(): Promise<Uint8Array> {
-        return jxl.encode(this.__bytes__(), this.width, this.height);
+    async encodeJXL({ metadata = {} }: EncodeOptions = {}): Promise<Uint8Array> {
+        return jxl.encode(this.__bytes__(), this.width, this.height, exifData(resolveMetadata(metadata)));
     }
 
     /**
 
@@ -9,7 +9,7 @@ import * as exif from './codecs/exif.ts';
  * |---|---|
  * | PNG, APNG | all (as text chunks) |
  * | JPEG | author, description, copyright, creation time, software (Exif); comment (comment marker) |
- * | WebP | author, description, copyright, creation time, software (Exif) |
+ * | WebP, AVIF, JPEG XL | author, description, copyright, creation time, software (Exif) |
  * | GIF | software, comment (comment extensions) |
  * | TGA | author, comment, creation time, software (extension area) |
  *
@@ -94,7 +94,7 @@ export function pngText(m: ResolvedMetadata): Record<string, string | undefined>
 }
 
 /**
- * @internal Exif data (a TIFF header and IFDs) for JPEG and WebP
+ * @internal Exif data (a TIFF header and IFDs) for JPEG, WebP, AVIF and JPEG XL
  * @ignore
  */
 export function exifData(m: ResolvedMetadata): Uint8Array {
 
@@ -41,6 +41,13 @@ const samples = image => {
     return [px, channels.length];
 };
 
+// the codestream of a container: the content of its last box, jxlc
+const codestream = jxl => {
+    let o = 0;
+    while (o + Buffer.from(jxl).readUInt32BE(o) < jxl.length) o += Buffer.from(jxl).readUInt32BE(o);
+    return jxl.subarray(o + 8);
+};
+
 (async () => {
     const {encode} = await import('../dist/codecs/jxl/fast-lossless.js');
     for (const [name, grey] of [['external.png'], ['circle.png'], ['readme.png'], ['potato.png'], ['external.png', true]]) {
@@ -49,7 +56,7 @@ const samples = image => {
         // (grey: the red channel)
         if (grey) for (let i = 0; i < image.bitmap.length; i += 4) image.bitmap[i + 1] = image.bitmap[i + 2] = image.bitmap[i];
         const jxl = await image.encodeJXL();
-        if (sha256(jxl) !== references[16][key]) panic(`${key}: not what cjxl -e 1 writes`);
+        if (sha256(codestream(jxl)) !== references[16][key]) panic(`${key}: not what cjxl -e 1 writes`);
         const [px, channels] = samples(image);
         if (sha256(encode(px, image.width, image.height, channels, 8)) !== references[8][key]) panic(`${key}: not what cjxl -e 1 writes without SIMD`);
         const decoded = await Image.decode(jxl);
 
@@ -19,6 +19,8 @@ const latin1 = (data, text) => Buffer.from(data).includes(Buffer.from(text, 'lat
         jpeg: m => image.encodeJPEG({quality: 90, metadata: m}),
         webp: m => image.encodeWebP({metadata: m}),
         tga: m => image.encodeTGA({metadata: m}),
+        avif: m => image.encodeAVIF({effort: 0, metadata: m}),
+        jxl: m => image.encodeJXL({metadata: m}),
         gif: m => animation.encodeGIF({metadata: m}),
         apng: m => animation.encodeAPNG({metadata: m}),
         'animated webp': m => animation.encodeWebP({metadata: m})
@@ -46,14 +48,21 @@ const latin1 = (data, text) => Buffer.from(data).includes(Buffer.from(text, 'lat
         if (!has(png, 'Thu, 15 Oct 2026 12:34:56 GMT')) panic('png: creation time missing');
     }
 
-    // JPEG and WebP: Exif (IFD0 strings, UTC date), JPEG also a comment marker
-    for (const format of ['jpeg', 'webp']) {
+    // JPEG, WebP, AVIF and JPEG XL: Exif (IFD0 strings, UTC date; AVIF and JPEG XL: the TIFF header's offset first),
+    // JPEG also a comment marker
+    for (const format of ['jpeg', 'webp', 'avif', 'jxl']) {
         const file = await encoders[format](metadata);
-        for (const text of ['Exif'.slice(format === 'webp' ? 4 : 0), 'MM\0*', 'Jörg', 'a description', 'Ⓒ someone', '2026:10:15 12:34:56\0', '+00:00'])
+        const header = {jpeg: 'Exif\0\0MM\0*', webp: 'EXIF', avif: '\0\0\0\0MM\0*', jxl: 'Exif\0\0\0\0MM\0*'}[format];
+        for (const text of [header, 'MM\0*', 'Jörg', 'a description', 'Ⓒ someone', '2026:10:15 12:34:56\0', '+00:00'])
             if (!has(file, text)) panic(`${format}: ${JSON.stringify(text)} missing from the Exif data`);
         if (format === 'jpeg' && !has(file, Buffer.from([0xff, 0xfe, 0, 11, ...Buffer.from('a comment')]))) panic('jpeg: comment marker missing');
     }
 
+    // AVIF: the Exif item (3, after the alpha image) describes the image (cdsc); JPEG XL: the container's boxes
+    if (!has(await encoders.avif(metadata), Buffer.from([...Buffer.from('cdsc'), 0, 3, 0, 1, 0, 1]))) panic('avif: Exif item reference missing');
+    if (Buffer.from(await encoders.jxl(metadata)).subarray(0, 48).toString('latin1').replace(/[^ -~]/g, '.') !== '....JXL ........ftypjxl ....jxl ....Exif....MM.*')
+        panic('jxl: container boxes wrong');
+
     // GIF: comment extensions
     if (!has(await animation.encodeGIF({metadata}), Buffer.from([0x21, 0xfe, 9, ...Buffer.from('a comment'), 0]))) panic('gif: comment extension missing');