@@ -12,6 +12,10 @@
   Deno, Bun and browsers (Web Workers; bundlers like Vite pick up the worker's module). Small images (under about
   640x640 pixels at effort 0, 448x448 at 1, 320x320 at 2), browser pages without cross-origin isolation (no
   SharedArrayBuffer), runtimes without workers, and workers that fail to start encode on the calling thread as before.
+- Lossy `encodeJXL()` searches the varblocks in worker threads (`JXLEncodeOptions.threads`, the same default), rows of
+  64x64 areas in parallel like libjxl's: the same files. A 1920x1080 photo takes 1.1 s instead of 2.4 s at effort 1 and
+  1.8 s instead of 5.0 s at effort 2 (8 threads). Effort 0 (which has no search) and images under about 512x512 pixels
+  at effort 1, 384x384 at 2, encode without threads.
 
 ### Tests
 
 
@@ -25,10 +25,10 @@ export function isJXL(d: Uint8Array): boolean {
 
 /**
  * Encodes RGBA pixels as a JPEG XL, lossless or lossy (with a Butteraugli distance above 0, and an effort 0-2): the
- * codestream, in the container if there is Exif data (a TIFF header and IFDs)
+ * codestream, in the container if there is Exif data (a TIFF header and IFDs); lossy with up to threads worker threads
  */
-export function encode(rgba: Uint8Array, width: number, height: number, exif?: Uint8Array, distance = 0, effort = 1): Uint8Array {
-    const stream = distance > 0 ? encodeVarDCT(rgba, width, height, { distance, effort }) : encodeRGBA(rgba, width, height);
+export async function encode(rgba: Uint8Array, width: number, height: number, exif?: Uint8Array, distance = 0, effort = 1, threads = 1): Promise<Uint8Array> {
+    const stream = distance > 0 ? await encodeVarDCT(rgba, width, height, { distance, effort, threads }) : 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];
 
@@ -4,6 +4,7 @@
  * area: the best 8x8 transform of each block, merged into larger DCTs where they are estimated to cost less.
  * Copyright (c) the JPEG XL Project Authors, BSD-3-Clause License (see THIRD_PARTY_NOTICES.md)
  */
+import { runChunks, shared, type ChunkTask, type Thread } from '../../util/threads.ts';
 import { forwardTransform } from './transforms-enc.ts';
 import { inverseTransform } from './dct.ts';
 import { defaultDequant, MATRIX_INDEX } from './quant.ts';
@@ -117,8 +118,8 @@ function best8x8(x: number, y: number, speed: number, cfg: Config): [number, num
 class Strategy {
     readonly types: Int8Array;
 
-    constructor(readonly bw: number, readonly bh: number) {
-        this.types = new Int8Array(bw * bh);
+    constructor(readonly bw: number, readonly bh: number, types?: Int8Array) {
+        this.types = types ?? new Int8Array(bw * bh);
     }
 
     set(bx: number, by: number, type: number): void {
@@ -285,15 +286,42 @@ function processRect(bx: number, by: number, w: number, h: number, speed: number
  * The varblock types of an image (XYB planes of whole blocks, rows stride apart): libjxl's search at a speed tier (5:
  * its effort 5, 4: also the 4x8 and AFV transforms)
  */
-export function chooseVarblocks(planes: Float32Array[], stride: number, bw: number, bh: number, field: QuantField, distance: number, speed: number): Int8Array {
+export async function chooseVarblocks(planes: Float32Array[], stride: number, bw: number, bh: number, field: QuantField, distance: number, speed: number, threads: Thread[] | null): Promise<Int8Array> {
+    const types = new Int8Array(threads ? new SharedArrayBuffer(bw * bh) : new ArrayBuffer(bw * bh));
+    const task: VarblockTask = {
+        task: 'jxl-varblocks', stride, bw, bh, distance, speed, types,
+        planes: threads ? planes.map(shared) : planes,
+        field: threads ? { quant: shared(field.quant), mask: shared(field.mask), mask1x1: shared(field.mask1x1) } : field,
+    };
+    // (a row of 64x64 areas each, independent of the others)
+    await runChunks(threads, task, Math.ceil(bh / 8), varblockChunks(task));
+    return types;
+}
+
+/** The varblock search of rows of 64x64 areas (see chooseVarblocks) */
+export interface VarblockTask extends ChunkTask {
+    planes: Float32Array[];
+    stride: number;
+    bw: number;
+    bh: number;
+    field: QuantField;
+    distance: number;
+    speed: number;
+    types: Int8Array;
+}
+
+/** The search of a row of 64x64 areas (the chunk), its types set */
+export function varblockChunks({ planes, stride, bw, bh, field, distance, speed, types }: VarblockTask): (chunk: number) => void {
     const ratio = (distance + 0.13731742964354549) / (1 + 0.13731742964354549);
     const cfg: Config = {
         planes, stride, bw, field, distance,
         infoLossMul: 1.2 * ratio ** 0.33677806662454718,
         zerosMul: 9.3089059022677905 * ratio ** 0.50990926717963703,
         costDelta: 10.833273317067883 * ratio ** 0.36702940662370243
     };
-    const s = new Strategy(bw, bh);
-    for (let by = 0; by < bh; by += 8) for (let bx = 0; bx < bw; bx += 8) processRect(bx, by, Math.min(8, bw - bx), Math.min(8, bh - by), speed, cfg, s);
-    return s.types;
+    const s = new Strategy(bw, bh, types);
+    return row => {
+        const by = row * 8;
+        for (let bx = 0; bx < bw; bx += 8) processRect(bx, by, Math.min(8, bw - bx), Math.min(8, bh - by), speed, cfg, s);
+    };
 }
@@ -5,6 +5,7 @@
  * contexts, chroma from luma per tile (libjxl's fast search), the edge preserving filter. Copyright (c) the JPEG XL
  * Project Authors, BSD-3-Clause License (see THIRD_PARTY_NOTICES.md)
  */
+import { startThreads } from '../../util/threads.ts';
 import { findPatches } from './patches-enc.ts';
 import { BitWriter } from './bit-writer.ts';
 import { imageHeader, u32 } from './headers-enc.ts';
@@ -22,8 +23,14 @@ export interface VarDCTOptions {
     distance: number;
     /** 0: 8x8 DCTs only (like libjxl's effort 3), 1: libjxl's varblock search (its effort 5), 2: also the 4x8 and AFV transforms */
     effort: number;
+    /** at most this many worker threads (1: none) */
+    threads: number;
 }
 
+// (images below this many pixels encode faster without threads, which take about 0.1 s to start: by effort; effort 0
+// has no varblock search, what the threads run)
+const MIN_THREADED_PIXELS = [Infinity, 512 * 512, 384 * 384];
+
 // libjxl's opsin absorbance matrix and bias (lib/jxl/cms/opsin_params.h)
 const OPSIN = [
     0.30, 0.622, 0.078,
@@ -167,7 +174,7 @@ function chromaFromLuma(raw: Float32Array[], types: Int8Array, muls: Int32Array,
 }
 
 /** Encodes RGBA pixels as a lossy JPEG XL codestream, alpha (if the image has transparency) losslessly */
-export function encodeVarDCT(rgba: Uint8Array, width: number, height: number, { distance, effort }: VarDCTOptions): Uint8Array {
+export async function encodeVarDCT(rgba: Uint8Array, width: number, height: number, { distance, effort, threads: maxThreads }: VarDCTOptions): Promise<Uint8Array> {
     if (width < 1 || height < 1) throw new RangeError('JPEG XL: dimensions must be at least 1');
     const bw = Math.ceil(width / 8), bh = Math.ceil(height / 8), pw = bw * 8;
     const planes = toXYB(rgba, width, height, pw, bh * 8);
@@ -191,7 +198,24 @@ export function encodeVarDCT(rgba: Uint8Array, width: number, height: number, {
     // HF multipliers
     // patches at effort 2: text-like features of screenshots stored once (subtracted from the planes here)
     const patches = effort >= 2 ? findPatches(planes, pw, width, height, distance, alpha ? 1 : 0) : null;
-    const types = effort ? chooseVarblocks(planes, pw, bw, bh, initialQuantField(distance * 0.62, planes, pw, bh * 8, 0.725 / (distance * 0.62)), distance, effort === 1 ? 5 : 4) : new Int8Array(bw * bh);
+    // (the search in threads, if they start: the same types)
+    let types = new Int8Array(bw * bh);
+    if (effort) {
+        const field = initialQuantField(distance * 0.62, planes, pw, bh * 8, 0.725 / (distance * 0.62));
+        // (at most one per 256x256 pixels: more take longer to start than they save)
+        const n = Math.min(maxThreads, Math.ceil(bh / 8), Math.floor(width * height / 65536));
+        let threads = n > 1 && width * height >= MIN_THREADED_PIXELS[effort] ? startThreads(n) : null;
+        try {
+            types = await chooseVarblocks(planes, pw, bw, bh, field, distance, effort === 1 ? 5 : 4, threads);
+        } catch (e) {
+            if (!threads) throw e;
+            for (const t of threads) t.terminate();
+            threads = null;
+            types = await chooseVarblocks(planes, pw, bw, bh, field, distance, effort === 1 ? 5 : 4, null);
+        } finally {
+            if (threads) for (const t of threads) t.terminate();
+        }
+    }
     const muls = new Int32Array(bw * bh).fill(mul);
 
     // the varblocks' coefficients (in the planes' layout) and the LF of their blocks
 
@@ -12,6 +12,12 @@ import * as hdr from './codecs/hdr.ts';
 import * as avif from './codecs/avif.ts';
 import * as avifEnc from './codecs/avif-enc.ts';
 import { availableThreads } from './util/threads.ts';
+
+// (worker threads: the processors available, at most 8)
+const defaultThreads = (): number => Math.max(1, Math.min(availableThreads(), 8));
+const checkThreads = (threads: number): void => {
+    if (!Number.isInteger(threads) || threads < 1) throw new RangeError(`threads must be a positive integer, not ${threads}`);
+};
 import * as jxl from './codecs/jxl.ts';
 import type { ToneMapping } from './codecs/hdr.ts';
 import * as quantize from './codecs/quantize.ts';
@@ -221,6 +227,13 @@ export interface JXLEncodeOptions {
      * text-like features that repeat (the glyphs of screenshots) once, as patches like `cjxl -e 7`. Default: `1`
      */
     effort?: number;
+    /**
+     * At most this many worker threads search the transforms of lossy compression in parallel (the same file, faster),
+     * `1` for none. Effort 0 (no search), small images (under about 512x512 pixels at effort 1, 384x384 at 2), and
+     * runtimes whose workers can't share memory (browsers without cross-origin isolation) encode without them.
+     * Default: the processors available, at most 8
+     */
+    threads?: number;
     /** Metadata to include, see {@link Metadata} */
     metadata?: Metadata;
 }
@@ -2176,8 +2189,8 @@ 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, threads = Math.max(1, Math.min(availableThreads(), 8)), metadata = {} }: AVIFEncodeOptions = {}): Promise<Uint8Array> {
-        if (!Number.isInteger(threads) || threads < 1) throw new RangeError(`threads must be a positive integer, not ${threads}`);
+    async encodeAVIF({ quality = 60, alphaQuality = 100, subsampling = '4:4:4', effort = 1, threads = defaultThreads(), metadata = {} }: AVIFEncodeOptions = {}): Promise<Uint8Array> {
+        checkThreads(threads);
         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, threads });
     }
@@ -2190,16 +2203,17 @@ export class Image {
      * transparency) is lossless either way. The codestream is in the container, with the metadata as Exif
      * @param options See {@link JXLEncodeOptions}
      */
-    async encodeJXL({ quality, effort = 1, metadata = {} }: JXLEncodeOptions = {}): Promise<Uint8Array> {
+    async encodeJXL({ quality, effort = 1, threads = defaultThreads(), metadata = {} }: JXLEncodeOptions = {}): Promise<Uint8Array> {
         if (!Number.isInteger(effort) || effort < 0 || effort > 2) throw new RangeError(`effort must be an integer 0-2, not ${effort}`);
+        checkThreads(threads);
         let distance = 0;
         if (quality !== undefined) {
             const q = finite(quality, 'quality');
             if (q < 0 || q > 100) throw new RangeError(`quality must be 0-100, not ${q}`);
             // (cjxl's distance of a quality)
             distance = q >= 100 ? 0 : q >= 30 ? 0.1 + (100 - q) * 0.09 : 53 / 3000 * q * q - 23 / 20 * q + 25;
         }
-        return jxl.encode(this.__bytes__(), this.width, this.height, exifData(resolveMetadata(metadata)), distance, effort);
+        return jxl.encode(this.__bytes__(), this.width, this.height, exifData(resolveMetadata(metadata)), distance, effort, threads);
     }
 
     /**
 
@@ -129,3 +129,37 @@ export function startThreads(n: number): Thread[] | null {
         return null;
     }
 }
+
+/** A task split into chunks, for runChunks: the worker task's name and its data (typed arrays in shared memory) */
+export interface ChunkTask {
+    task: string;
+    /** the next chunk to take (an Int32Array of 1 in shared memory, set by runChunks) */
+    counter?: Int32Array;
+    chunks?: number;
+}
+
+/**
+ * Runs chunks 0 to count - 1 of a task, each threads' next one (worker.ts runs a chunk task's chunks with the same
+ * function as local, see chunkTasks there), or all of them here without threads: their results
+ */
+export async function runChunks<R>(threads: Thread[] | null, task: ChunkTask, count: number, local: (chunk: number) => R): Promise<R[]> {
+    const results = new Array<R>(count);
+    if (!threads || count < 2) {
+        for (let i = 0; i < count; i++) results[i] = local(i);
+        return results;
+    }
+    const counter = new Int32Array(new SharedArrayBuffer(4));
+    await Promise.all(threads.slice(0, count).map(t => t.run({ ...task, counter, chunks: count }, m => {
+        const { chunk, result } = m as { chunk: number, result: R };
+        results[chunk] = result;
+    })));
+    return results;
+}
+
+/** A copy of a typed array in shared memory (for threads) */
+export function shared<T extends Float32Array | Int32Array | Int8Array | Uint8Array | Uint16Array>(array: T): T {
+    const Type = array.constructor as new (buffer: SharedArrayBuffer) => T;
+    const copy = new Type(new SharedArrayBuffer(array.byteLength));
+    copy.set(array);
+    return copy;
+}
@@ -1,5 +1,12 @@
 // the module worker threads run (see threads.ts): tasks posted to it, their results posted back
 import { searchRows, filterTrials, type SearchTask, type FilterTask } from '../codecs/av1/encode.ts';
+import { varblockChunks } from '../codecs/jxl/acs-enc.ts';
+import type { ChunkTask } from './threads.ts';
+
+// the chunk tasks (see runChunks): a task's function of its chunks
+const chunkTasks: Record<string, (task: never) => (chunk: number) => unknown> = {
+    'jxl-varblocks': varblockChunks,
+};
 
 interface Port {
     post(message: unknown): void;
@@ -19,6 +26,10 @@ function handle(port: Port, task: { task: string }): void {
         let result: unknown;
         if (task.task === 'av1-search') result = searchRows(task as SearchTask, message);
         else if (task.task === 'av1-filter') result = filterTrials(task as FilterTask);
+        else if (task.task in chunkTasks) {
+            const { counter, chunks } = task as ChunkTask, run = chunkTasks[task.task](task as never);
+            for (let chunk; (chunk = Atomics.add(counter as Int32Array, 0, 1)) < (chunks as number);) message({ chunk, result: run(chunk) });
+        }
         else throw new Error(`unknown task ${task.task}`);
         port.post({ result });
     } catch (e) {
 
@@ -1,15 +1,17 @@
-// the browser test's page script: AVIF with and without threads (the same file), the codecs' smoke test
+// the browser test's page script: AVIF and JXL with and without threads (the same files), the codecs' smoke test
 import { Image } from 'imagescript';
 import { smoke } from '../edge/smoke.mjs';
 
 const digest = async data => [...new Uint8Array(await crypto.subtle.digest('SHA-256', data))].map(b => b.toString(16).padStart(2, '0')).join('');
 (async () => {
     const results = { isolated: self.crossOriginIsolated };
     try {
-        const image = new Image(640, 480);
-        for (let y = 0; y < 480; y++) for (let x = 0; x < 640; x++) image.setPixelAt(x, y, Image.rgbaToColor(x * 3 & 255, y * 5 & 255, (x ^ y) & 255, 255));
+        const image = new Image(640, 512);
+        for (let y = 0; y < 512; y++) for (let x = 0; x < 640; x++) image.setPixelAt(x, y, Image.rgbaToColor(x * 3 & 255, y * 5 & 255, (x ^ y) & 255, 255));
         results.single = await digest(await image.encodeAVIF({ effort: 1, threads: 1, metadata: { creationTime: 0 } }));
         results.threaded = await digest(await image.encodeAVIF({ effort: 1, threads: 4, metadata: { creationTime: 0 } }));
+        results.jxlSingle = await digest(await image.encodeJXL({ quality: 85, threads: 1, metadata: { creationTime: 0 } }));
+        results.jxlThreaded = await digest(await image.encodeJXL({ quality: 85, threads: 4, metadata: { creationTime: 0 } }));
         results.smoke = await smoke();
     } catch (e) {
         results.error = String(e && e.stack || e);
 
@@ -50,6 +50,7 @@ try {
         if (r.error) problems.push(r.error);
         if (r.isolated !== isolated) problems.push(`crossOriginIsolated ${r.isolated}`);
         if (r.single !== r.threaded) problems.push('threads wrote a different file');
+        if (r.jxlSingle !== r.jxlThreaded) problems.push('threads wrote a different JPEG XL');
         if (isolated ? workers < 2 : workers) problems.push(`${workers} workers started`);
         for (const [step, result] of Object.entries(r.smoke ?? {})) if (String(result).startsWith('FAIL')) problems.push(`${step}: ${result}`);
         console.log(`${isolated ? 'cross-origin isolated' : 'not isolated'}: ${workers} workers, ${problems.length ? problems.join('\n  ') : 'ok'}`);
 
@@ -113,6 +113,16 @@ const codestream = jxl => {
         else if (jxl.length > effort0 * 1.02) panic(`effort ${effort}: ${jxl.length} B, effort 0 ${effort0} B`);
     }
     for (const effort of [-1, 3, 1.5]) if (!await shot.encodeJXL({quality: 90, effort}).then(() => false, e => e instanceof RangeError)) panic(`effort ${effort} should throw`);
+    // threads (the varblock search of rows of 64x64 areas in parallel): the same files as without
+    {
+        const big = photo.clone().resize(640, Image.RESIZE_AUTO);
+        for (const effort of [1, 2]) {
+            const one = await big.encodeJXL({quality: 85, effort, threads: 1, metadata: {creationTime: 0}});
+            const four = await big.encodeJXL({quality: 85, effort, threads: 4, metadata: {creationTime: 0}});
+            if (Buffer.compare(Buffer.from(one), Buffer.from(four))) panic(`threads, effort ${effort}: not the same file`);
+        }
+        for (const threads of [0, 2.5]) if (!await big.encodeJXL({quality: 85, threads}).then(() => false, e => e instanceof RangeError)) panic(`threads ${threads} should throw`);
+    }
     // patches (effort 2): repeated glyphs of text on a flat background are found, stored in a reference frame and
     // added back
     {