rapier-jxl 2.0.0 → 2.2.0

package/kernels-simd.wat

@@ -0,0 +1,252 @@
+;; SPDX-License-Identifier: MIT
+;; Own bounded integer kernels. Pointers and lengths are checked by kernels.mjs.
+;; Tiny arithmetic helpers are explicitly inlined: Node 22 does not inline WAT calls
+;; by default. i64 multiplication followed by arithmetic >>24 is floor, not truncation.
+;; SIMD averages add one to negative sums before >>1, matching JavaScript's /2 |0.
+(module
+  (import "env" "memory" (memory 1 128))
+  (func $residual
+    (export "residual")
+    (param $p i32)
+    (param $w i32)
+    (param $h i32)
+    (param $pred i32)
+    (param $offset i32)
+    (param $out i32)
+    (local $L v128)
+    (local $T v128)
+    (local $NW v128)
+    (local $V v128)
+    (local $S v128)
+    (local $x i32)
+    (local $y i32)
+    (local $row i32)
+    (local $left i32)
+    (local $top i32)
+    (local $nw i32)
+    (local $g i32)
+    (local $v i32)
+    (local.set $row (i32.shl (local.get $w) (i32.const 2)))
+    (loop $ys
+      (local.set $x (i32.const 0))
+      (loop $xs
+        (block $next
+          (if
+            (i32.and
+              (i32.and (i32.ne (local.get $y) (i32.const 0)) (i32.ne (local.get $x) (i32.const 0)))
+              (i32.and
+                (i32.le_u (i32.add (local.get $x) (i32.const 4)) (local.get $w))
+                (i32.or (i32.eq (local.get $pred) (i32.const 3)) (i32.eq (local.get $pred) (i32.const 5)))))
+            (then
+              (local.set $L (v128.load (i32.sub (local.get $p) (i32.const 4))))
+              (local.set $T (v128.load (i32.sub (local.get $p) (local.get $row))))
+              (local.set $S (i32x4.add (local.get $L) (local.get $T)))
+              (if
+                (i32.eq (local.get $pred) (i32.const 3))
+                (then
+                  (local.set $V
+                    (i32x4.shr_s
+                      (i32x4.add
+                        (local.get $S)
+                        (v128.and (i32x4.shr_s (local.get $S) (i32.const 31)) (i32x4.splat (i32.const 1))))
+                      (i32.const 1))))
+                (else
+                  (local.set $NW (v128.load (i32.sub (i32.sub (local.get $p) (local.get $row)) (i32.const 4))))
+                  (local.set $V
+                    (i32x4.max_s
+                      (i32x4.min_s (local.get $L) (local.get $T))
+                      (i32x4.min_s
+                        (i32x4.max_s (local.get $L) (local.get $T))
+                        (i32x4.sub (local.get $S) (local.get $NW)))))))
+              (local.set $V
+                (i32x4.sub
+                  (i32x4.sub (v128.load (local.get $p)) (local.get $V))
+                  (i32x4.splat (local.get $offset))))
+              (v128.store
+                (local.get $out)
+                (v128.xor (i32x4.shl (local.get $V) (i32.const 1)) (i32x4.shr_s (local.get $V) (i32.const 31))))
+              (local.set $p (i32.add (local.get $p) (i32.const 16)))
+              (local.set $out (i32.add (local.get $out) (i32.const 16)))
+              (local.set $x (i32.add (local.get $x) (i32.const 4)))
+              (br $next)))
+          (local.set $v (i32.const 0))
+          (if
+            (local.get $pred)
+            (then
+              (local.set $left
+                (if
+                  (result i32)
+                  (local.get $x)
+                  (then (i32.load (i32.sub (local.get $p) (i32.const 4))))
+                  (else
+                    (if
+                      (result i32)
+                      (local.get $y)
+                      (then (i32.load (i32.sub (local.get $p) (local.get $row))))
+                      (else (i32.const 0))))))
+              (local.set $top
+                (if
+                  (result i32)
+                  (local.get $y)
+                  (then (i32.load (i32.sub (local.get $p) (local.get $row))))
+                  (else (local.get $left))))
+              (local.set $nw
+                (if
+                  (result i32)
+                  (i32.and (i32.ne (local.get $x) (i32.const 0)) (i32.ne (local.get $y) (i32.const 0)))
+                  (then (i32.load (i32.sub (i32.sub (local.get $p) (local.get $row)) (i32.const 4))))
+                  (else (local.get $left))))
+              (local.set $g (i32.sub (i32.add (local.get $left) (local.get $top)) (local.get $nw)))
+              (if (i32.eq (local.get $pred) (i32.const 1)) (then (local.set $v (local.get $left))))
+              (if (i32.eq (local.get $pred) (i32.const 2)) (then (local.set $v (local.get $top))))
+              (if
+                (i32.eq (local.get $pred) (i32.const 3))
+                (then (local.set $v (i32.div_s (i32.add (local.get $left) (local.get $top)) (i32.const 2)))))
+              (if
+                (i32.eq (local.get $pred) (i32.const 4))
+                (then
+                  (local.set $v
+                    (select
+                      (local.get $left)
+                      (local.get $top)
+                      (i32.lt_s
+                        (i32.sub
+                          (i32.xor
+                            (i32.sub (local.get $g) (local.get $left))
+                            (i32.shr_s (i32.sub (local.get $g) (local.get $left)) (i32.const 31)))
+                          (i32.shr_s (i32.sub (local.get $g) (local.get $left)) (i32.const 31)))
+                        (i32.sub
+                          (i32.xor
+                            (i32.sub (local.get $g) (local.get $top))
+                            (i32.shr_s (i32.sub (local.get $g) (local.get $top)) (i32.const 31)))
+                          (i32.shr_s (i32.sub (local.get $g) (local.get $top)) (i32.const 31))))))))
+              (if
+                (i32.eq (local.get $pred) (i32.const 5))
+                (then
+                  (local.set $v
+                    (select
+                      (select (local.get $left) (local.get $top) (i32.lt_s (local.get $left) (local.get $top)))
+                      (select
+                        (select (local.get $left) (local.get $top) (i32.gt_s (local.get $left) (local.get $top)))
+                        (local.get $g)
+                        (i32.lt_s
+                          (select
+                            (local.get $left)
+                            (local.get $top)
+                            (i32.gt_s (local.get $left) (local.get $top)))
+                          (local.get $g)))
+                      (i32.gt_s
+                        (select (local.get $left) (local.get $top) (i32.lt_s (local.get $left) (local.get $top)))
+                        (select
+                          (select
+                            (local.get $left)
+                            (local.get $top)
+                            (i32.gt_s (local.get $left) (local.get $top)))
+                          (local.get $g)
+                          (i32.lt_s
+                            (select
+                              (local.get $left)
+                              (local.get $top)
+                              (i32.gt_s (local.get $left) (local.get $top)))
+                            (local.get $g))))))))))
+          (i32.store
+            (local.get $out)
+            (i32.xor
+              (i32.shl
+                (i32.sub (i32.sub (i32.load (local.get $p)) (local.get $v)) (local.get $offset))
+                (i32.const 1))
+              (i32.shr_s
+                (i32.sub (i32.sub (i32.load (local.get $p)) (local.get $v)) (local.get $offset))
+                (i32.const 31))))
+          (local.set $out (i32.add (local.get $out) (i32.const 4)))
+          (local.set $p (i32.add (local.get $p) (i32.const 4)))
+          (local.set $x (i32.add (local.get $x) (i32.const 1))))
+        (br_if $xs (i32.lt_u (local.get $x) (local.get $w))))
+      (local.set $y (i32.add (local.get $y) (i32.const 1)))
+      (br_if $ys (i32.lt_u (local.get $y) (local.get $h)))))
+  (func $fill
+    (export "fill")
+    (param $src i32)
+    (param $n i32)
+    (param $channels i32)
+    (param $p0 i32)
+    (param $p1 i32)
+    (param $p2 i32)
+    (param $p3 i32)
+    (local $V v128)
+    (local $R v128)
+    (local $G v128)
+    (local $B v128)
+    (local $Co v128)
+    (local $Cg v128)
+    (local $Tmp v128)
+    (local $v i32)
+    (local $r i32)
+    (local $g i32)
+    (local $b i32)
+    (local $co i32)
+    (local $cg i32)
+    (local $tmp i32)
+    (local $i i32)
+    (block $vectorsDone
+      (loop $vectors
+        (br_if $vectorsDone (i32.gt_u (i32.add (local.get $i) (i32.const 4)) (local.get $n)))
+        (local.set $V (v128.load (local.get $src)))
+        (local.set $R (v128.and (local.get $V) (i32x4.splat (i32.const 255))))
+        (if
+          (i32.ge_u (local.get $channels) (i32.const 3))
+          (then
+            (local.set $G (v128.and (i32x4.shr_u (local.get $V) (i32.const 8)) (i32x4.splat (i32.const 255))))
+            (local.set $B (v128.and (i32x4.shr_u (local.get $V) (i32.const 16)) (i32x4.splat (i32.const 255))))
+            (local.set $Co (i32x4.sub (local.get $R) (local.get $B)))
+            (local.set $Tmp (i32x4.add (local.get $B) (i32x4.shr_s (local.get $Co) (i32.const 1))))
+            (local.set $Cg (i32x4.sub (local.get $G) (local.get $Tmp)))
+            (v128.store (local.get $p0) (i32x4.add (local.get $Tmp) (i32x4.shr_s (local.get $Cg) (i32.const 1))))
+            (v128.store (local.get $p1) (local.get $Co))
+            (v128.store (local.get $p2) (local.get $Cg))
+            (if
+              (i32.eq (local.get $channels) (i32.const 4))
+              (then (v128.store (local.get $p3) (i32x4.shr_u (local.get $V) (i32.const 24))))))
+          (else
+            (v128.store (local.get $p0) (local.get $R))
+            (if
+              (i32.eq (local.get $channels) (i32.const 2))
+              (then (v128.store (local.get $p1) (i32x4.shr_u (local.get $V) (i32.const 24)))))))
+        (local.set $p0 (i32.add (local.get $p0) (i32.const 16)))
+        (local.set $p1 (i32.add (local.get $p1) (i32.const 16)))
+        (local.set $p2 (i32.add (local.get $p2) (i32.const 16)))
+        (local.set $p3 (i32.add (local.get $p3) (i32.const 16)))
+        (local.set $src (i32.add (local.get $src) (i32.const 16)))
+        (local.set $i (i32.add (local.get $i) (i32.const 4)))
+        (br $vectors)))
+    (block $done
+      (loop $next
+        (br_if $done (i32.ge_u (local.get $i) (local.get $n)))
+        (local.set $v (i32.load (local.get $src)))
+        (local.set $r (i32.and (local.get $v) (i32.const 255)))
+        (if
+          (i32.ge_u (local.get $channels) (i32.const 3))
+          (then
+            (local.set $g (i32.and (i32.shr_u (local.get $v) (i32.const 8)) (i32.const 255)))
+            (local.set $b (i32.and (i32.shr_u (local.get $v) (i32.const 16)) (i32.const 255)))
+            (local.set $co (i32.sub (local.get $r) (local.get $b)))
+            (local.set $tmp (i32.add (local.get $b) (i32.shr_s (local.get $co) (i32.const 1))))
+            (local.set $cg (i32.sub (local.get $g) (local.get $tmp)))
+            (i32.store (local.get $p0) (i32.add (local.get $tmp) (i32.shr_s (local.get $cg) (i32.const 1))))
+            (i32.store (local.get $p1) (local.get $co))
+            (i32.store (local.get $p2) (local.get $cg))
+            (if
+              (i32.eq (local.get $channels) (i32.const 4))
+              (then (i32.store (local.get $p3) (i32.shr_u (local.get $v) (i32.const 24))))))
+          (else
+            (i32.store (local.get $p0) (local.get $r))
+            (if
+              (i32.eq (local.get $channels) (i32.const 2))
+              (then (i32.store (local.get $p1) (i32.shr_u (local.get $v) (i32.const 24)))))))
+        (local.set $p0 (i32.add (local.get $p0) (i32.const 4)))
+        (local.set $p1 (i32.add (local.get $p1) (i32.const 4)))
+        (local.set $p2 (i32.add (local.get $p2) (i32.const 4)))
+        (local.set $p3 (i32.add (local.get $p3) (i32.const 4)))
+        (local.set $src (i32.add (local.get $src) (i32.const 4)))
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (br_if $next (i32.lt_u (local.get $i) (local.get $n)))))))

package/kernels.mjs

@@ -0,0 +1,141 @@
+// Rapier's optional integer WebAssembly kernels. MIT (LICENSE).
+// No fetch, runtime dependency, shared memory or floating-point byte decisions.
+import {kernelHooks} from './kernel-hooks.mjs';
+import {BitWriter, LIMITS} from './bits.mjs';
+import {SCALAR, SIMD, SIMD_PROBE} from './kernels-bytes.mjs';
+
+export const {configureKernels, kernelMode} = (() => {
+const P = 65536, R = 327680, PROPERTY = 589824, CONTEXT = 851968;
+const OUTPUT = 1114128, TABLE = 1642496, SOURCE = 1769472, STATE = 2097152;
+const DIV = 16, WEIGHTS = 272, BUCKET = 16656, MAP = 20672, ALPHABET = 257;
+const CUTS = [-500,-392,-255,-191,-127,-95,-63,-47,-31,-23,-15,-11,-7,-4,-3,-1,0,1,3,5,7,11,15,23,31,47,63,95,127,191,255,392,500];
+let engine, active = 'off';
+const decode = text => Uint8Array.from(atob(text), c => c.charCodeAt(0));
+const acceptablePlane = (p, w, h, offset) => p instanceof Int16Array && Number.isInteger(w) && Number.isInteger(h) && w > 0 && h > 0 && w <= 16384 && w * h <= 65536 && p.length >= w * h && Number.isInteger(offset) && Math.abs(offset) <= 32768;
+const acceptableWriter = w => !w || (w instanceof BitWriter && w.write === BitWriter.prototype.write && w.grow === BitWriter.prototype.grow);
+// A hybrid-integer configuration the kernels write: split up to 15, msb and lsb within it, and every token a residual below
+// 2^19 can take inside the 224 symbols below the LZ77 lengths. A raw histogram (lossless-coding.mjs) is bins for the
+// residual values and the 33 length tokens: at most the 4,096 of a palette's indices and 33 more, in the arena's table.
+const PLAIN = {split: 0, msb: 0, lsb: 0};
+const acceptableConfig = c => Number.isInteger(c.split) && Number.isInteger(c.msb) && Number.isInteger(c.lsb) && c.split >= 0 && c.split <= 15 && c.msb >= 0 && c.lsb >= 0 && c.msb + c.lsb <= c.split && (1 << c.split) + ((19 - c.split) << (c.msb + c.lsb)) <= 224;
+const RAW_BINS = 4096 + 33;
+
+function createEngine() {
+  const memory = new WebAssembly.Memory({initial: 48, maximum: 128});
+  const names = new Map(Object.entries(new WebAssembly.Instance(new WebAssembly.Module(decode(SCALAR)), {env: {memory}}).exports));
+  // Lookup strings are ABI names, never JavaScript property-mangler candidates.
+  const scalar = {residual: names.get('residual'), tokens: names.get('tokens'), fill: names.get('fill'), weighted: names.get('weighted')};
+  const u8 = new Uint8Array(memory.buffer), i32 = new Int32Array(memory.buffer);
+  for (let i = 0; i < 64; i++) i32[(DIV >> 2) + i] = Math.floor(16777216 / (i + 1));
+  for (let most = 12; most <= 13; most++) for (let sum = 0; sum < 2048; sum++) {
+    const shift = Math.max(0, 26 - Math.clz32(sum + 1));
+    i32[(WEIGHTS >> 2) + (most - 12) * 2048 + sum] = 4 + ((most * i32[(DIV >> 2) + (sum >> shift)]) >> shift);
+  }
+  for (let i = 0; i < 1003; i++) i32[(BUCKET >> 2) + i] = CUTS.filter(cut => cut < i - 501).length;
+  return {memory, scalar, simd: null, u8, i32};
+}
+
+// Both passes use one bulk crossing. In particular the writer never calls back into
+// JS per token. Code tables use explicit little-endian i32 fields in private memory.
+function tokens(w, targets, count, contexts, config = PLAIN, rawLength = 0) {
+  const {scalar, i32, u8} = engine, stride = rawLength || ALPHABET;
+  if (!acceptableWriter(w) || !targets.length || targets.length > 34) return false;
+  if (w) {
+    i32.fill(0, TABLE >> 2, (TABLE >> 2) + targets.length * ALPHABET * 2);
+    for (let c = 0; c < targets.length; c++) {
+      const code = targets[c];
+      if (!code?.lengths || !code?.codes || code.lengths.length > ALPHABET) return false;
+      for (let s = 0; s < code.lengths.length; s++) {
+        i32[(TABLE >> 2) + (c * ALPHABET + s) * 2] = code.lengths[s];
+        i32[(TABLE >> 2) + (c * ALPHABET + s) * 2 + 1] = code.codes[s];
+      }
+    }
+  } else {
+    for (let c = 0; c < targets.length; c++) {
+      if (!(targets[c] instanceof Uint32Array) || targets[c].length !== stride) return false;
+      i32.set(targets[c], (TABLE >> 2) + c * stride);
+    }
+  }
+  const written = scalar.tokens(R, contexts, count, TABLE, OUTPUT, w ? 1 : 0, w ? w.acc : 0, w ? w.pending : 0, config.split, config.msb, config.lsb, rawLength);
+  if (w) {
+    if (w.at + written + 8 >= w.bytes.length) w.grow(written + 8);
+    w.bytes.set(u8.subarray(OUTPUT, OUTPUT + written), w.at);
+    w.at += written; w.acc = i32[(OUTPUT - 8) >> 2]; w.pending = i32[(OUTPUT - 4) >> 2];
+  } else for (let c = 0; c < targets.length; c++) targets[c].set(i32.subarray((TABLE >> 2) + c * stride, (TABLE >> 2) + (c + 1) * stride));
+  return true;
+}
+function channel(w, target, plane, width, height, leaf, raw) {
+  const config = leaf.config || PLAIN;
+  if (!acceptablePlane(plane, width, height, leaf.offset) || leaf.multiplier !== 1 || !Number.isInteger(leaf.predictor) || leaf.predictor < 0 || leaf.predictor > 5 || !acceptableWriter(w) || !acceptableConfig(config)) return false;
+  // A raw histogram is counted, never written, into bins that fit the arena's table.
+  if (raw && (w || !(target instanceof Uint32Array) || target.length < 34 || target.length > RAW_BINS)) return false;
+  const n = width * height;
+  if (w && w.at + n * 8 + 32 > LIMITS.bytes) return false;
+  engine.i32.set(plane.subarray(0, n), P >> 2);
+  (active === 'simd' ? engine.simd : engine.scalar).residual(P, width, height, leaf.predictor, leaf.offset, R);
+  return tokens(w, [target], n, 0, config, raw ? target.length : 0);
+}
+function weighted(w, targets, plane, width, height, offset, contextOf, residuals, properties) {
+  if (!acceptablePlane(plane, width, height, offset) || !acceptableWriter(w)) return false;
+  const n = width * height, {i32, scalar} = engine;
+  if (w && w.at + n * 8 + 32 > LIMITS.bytes) return false;
+  if (residuals && (!(residuals instanceof Uint32Array) || residuals.length < n)) return false;
+  if (properties && (!(properties instanceof Int32Array) || properties.length < n)) return false;
+  if (contextOf.length !== 34 || contextOf.some(c => !Number.isInteger(c) || c < 0 || c >= 34)) return false;
+  if (!residuals && contextOf.some(c => c >= targets.length)) return false;
+  i32.set(plane.subarray(0, n), P >> 2); i32.set(contextOf, MAP >> 2);
+  i32.fill(0, STATE >> 2, (STATE >> 2) + (width + 2) * 10);
+  scalar.weighted(P, width, height, offset, R, PROPERTY, CONTEXT, MAP, BUCKET, DIV, WEIGHTS, STATE);
+  if (residuals) {
+    residuals.set(i32.subarray(R >> 2, (R >> 2) + n));
+    if (properties) properties.set(i32.subarray(PROPERTY >> 2, (PROPERTY >> 2) + n));
+    return true;
+  }
+  if (properties) properties.set(i32.subarray(PROPERTY >> 2, (PROPERTY >> 2) + n));
+  return tokens(w, targets, n, CONTEXT);
+}
+function fill(rgba, imageWidth, x0, y0, w, h, channels, planes) {
+  const n = w * h;
+  if (n < 1 || n > 65536 || channels < 1 || channels > 4) return false;
+  const {u8, i32} = engine;
+  for (let y = 0; y < h; y++) {
+    const at = ((y0 + y) * imageWidth + x0) * 4;
+    u8.set(rgba.subarray(at, at + w * 4), SOURCE + y * w * 4);
+  }
+  (active === 'simd' ? engine.simd : engine.scalar).fill(SOURCE, n, channels, P, R, PROPERTY, CONTEXT);
+  for (let c = 0; c < channels; c++) {
+    const at = [P, R, PROPERTY, CONTEXT][c] >> 2;
+    planes[c].set(i32.subarray(at, at + n));
+  }
+  return true;
+}
+
+/** Select this optional door explicitly. Missing/blocked WASM or SIMD returns to JS.
+ * `parts` is a deterministic per-realm ablation switch, not a timing-based decision.
+ * Set it before an encode, never inside a progress callback.
+ */
+function configureKernels(mode = 'auto', parts) {
+  if (!['off', 'auto', 'scalar', 'simd'].includes(mode)) throw new RangeError('Unknown JXL kernel mode: ' + mode);
+  kernelHooks.channel = kernelHooks.weighted = kernelHooks.fill = null; active = 'off';
+  if (mode === 'off') return active;
+  try {
+    if (typeof WebAssembly !== 'object' || !WebAssembly.validate || new Uint8Array(new Uint32Array([1]).buffer)[0] !== 1) return active;
+    // A SIMD request is not silently tested as scalar: unsupported SIMD is JS.
+    const simd = mode !== 'scalar' && SIMD && WebAssembly.validate(decode(SIMD_PROBE));
+    if (mode !== 'scalar' && !simd) return active;
+    engine ||= createEngine();
+    if (simd && !engine.simd) {
+      const names = new Map(Object.entries(new WebAssembly.Instance(new WebAssembly.Module(decode(SIMD)), {env: {memory: engine.memory}}).exports));
+      engine.simd = {residual: names.get('residual'), fill: names.get('fill')};
+    }
+    active = simd ? 'simd' : 'scalar';
+    const enabled = parts ? new Map(Object.entries(parts)) : null;
+    if (!enabled || enabled.get('channel')) kernelHooks.channel = channel;
+    if (!enabled || enabled.get('weighted')) kernelHooks.weighted = weighted;
+    if (!enabled || enabled.get('fill')) kernelHooks.fill = fill;
+  } catch { active = 'off'; kernelHooks.channel = kernelHooks.weighted = kernelHooks.fill = null; }
+  return active;
+}
+function kernelMode() { return active; }
+return {configureKernels, kernelMode};
+})();

package/local.mjs

@@ -0,0 +1,201 @@
+// SPDX-License-Identifier: MIT
+// Effort-only Modular modelling. Every group owns its tree and histograms; a bounded group of samples is the
+// working set, and the complete candidate competes against every lower rung at the door.
+import {BitWriter, packSigned} from './bits.mjs';
+import {writeImageHeader, writeModularFrameHeader, groupLayout, groupRect, groupPass, assembleCodestream, GROUP_DIM} from './frame.mjs';
+import {buildCode, writePrefixCode, countToken, writeHybrid} from './prefix.mjs';
+import {ALPHABET, LZ77, RESIDUAL_CONFIG, leaf, split, channelTree, writeTree, writeModularHeader, writeChannelHistograms} from './modular.mjs';
+import {codeWeighted} from './weighted.mjs';
+import {admitOutputSize} from './admit.mjs';
+import {planeFill} from './lossless.mjs';
+
+const localRaw = s => Math.max(0, s < 224 ? s - 1 : s - 236);
+const price = freqs => {
+  const code = buildCode(freqs), writer = new BitWriter(128);
+  writePrefixCode(writer, code);
+  let bits = writer.bitLength;
+  for (let s = 0; s < freqs.length; s++) if (freqs[s]) bits += freqs[s] * (code.lengths[s] + localRaw(s));
+  return bits;
+};
+
+// Residuals are exactly the decoder's unsigned values before entropy coding, including RGB under zero alpha.
+function residuals(plane, width, height, predictor, properties) {
+  const out = new Uint32Array(width * height);
+  if (predictor === 6) { codeWeighted(null, null, plane, width, height, 0, undefined, out, properties); return out; }
+  for (let y = 0, i = 0; y < height; y++) for (let x = 0; x < width; x++, i++) {
+    const left = x ? plane[i - 1] : y ? plane[i - width] : 0, top = y ? plane[i - width] : left;
+    const nw = x && y ? plane[i - width - 1] : left;
+    const prediction = predictor === 3 ? ((left + top) / 2) | 0 : Math.max(Math.min(left, top), Math.min(Math.max(left, top), left + top - nw));
+    out[i] = packSigned(plane[i] - prediction);
+  }
+  return out;
+}
+
+function tokens(values, contexts, count = 1) {
+  const freqs = Array.from({length: count}, () => new Uint32Array(ALPHABET)), pieces = [];
+  const emit = (i, value, base = 0) => {
+    const context = contexts ? contexts[i] : 0;
+    pieces.push(value, base, context); countToken(base ? LZ77.lengthConfig : RESIDUAL_CONFIG, value, freqs[context], base);
+  };
+  // A zero run can cross a tree leaf or row. Its first literal and copy use their own samples' contexts.
+  for (let i = 0; i < values.length;) {
+    let run = 1;
+    if (!values[i]) while (i + run < values.length && !values[i + run]) run++;
+    emit(i, values[i]);
+    if (run > LZ77.minLength) {
+      emit(i + 1, run - 1 - LZ77.minLength, LZ77.minSymbol);
+    } else for (let n = 1; n < run; n++) emit(i + n, 0);
+    i += run;
+  }
+  return {freqs, pieces};
+}
+
+function intervalPlan(values, properties, predictor, property, cuts) {
+  const contexts = Uint8Array.from(properties, value => {
+    let lo = 0, hi = cuts.length;
+    while (lo < hi) { const mid = (lo + hi) >> 1; if (value > cuts[mid]) lo = mid + 1; else hi = mid; }
+    return lo;
+  });
+  const coded = tokens(values, contexts, cuts.length + 1), count = coded.freqs.length, filled = coded.freqs.map(freq => freq.some(n => n));
+  const costs = new Float64Array(count + 1).fill(Infinity), from = new Uint8Array(count + 1);
+  costs[0] = 0;
+  for (let end = 1; end <= count; end++) {
+    const freq = new Uint32Array(ALPHABET);
+    let own = 0;
+    for (let start = end - 1; start >= 0; start--) {
+      if (filled[start]) { for (let s = 0; s < ALPHABET; s++) freq[s] += coded.freqs[start][s]; own = price(freq); }
+      const bits = costs[start] + own + 24;
+      if (bits < costs[end]) { costs[end] = bits; from[end] = start; }
+    }
+  }
+  const spans = [];
+  for (let end = count; end; end = from[end]) spans.unshift([from[end], end]);
+  const leaves = spans.map(() => leaf(predictor)), mapping = new Uint8Array(count);
+  const freqs = spans.map(([start, end], index) => {
+    const freq = new Uint32Array(ALPHABET);
+    for (let k = start; k < end; k++) { mapping[k] = index; for (let s = 0; s < ALPHABET; s++) freq[s] += coded.freqs[k][s]; }
+    return freq;
+  });
+  for (let i = 2; i < coded.pieces.length; i += 3) coded.pieces[i] = mapping[coded.pieces[i]];
+  const tree = (lo, hi) => {
+    if (lo === hi) return leaves[lo];
+    const mid = (lo + hi) >> 1;
+    return split(property, cuts[spans[mid][1] - 1], tree(mid + 1, hi), tree(lo, mid));
+  };
+  return {leaves, tree: tree(0, spans.length - 1), freqs, pieces: coded.pieces};
+}
+
+const WEIGHTED_LOCAL_CUTS = [-127, -31, -7, -1, 0, 1, 7, 31, 127];
+const GRADIENT_CUTS = [-191, -127, -63, -31, -7, -1, 0, 7, 31, 63, 127, 191, 255];
+function localProperties(plane, width, height, property) {
+  const out = new Int32Array(width * height);
+  for (let y = 0, i = 0; y < height; y++) for (let x = 0; x < width; x++, i++) {
+    const left = x ? plane[i - 1] : y ? plane[i - width] : 0, top = y ? plane[i - width] : left;
+    const nw = x && y ? plane[i - width - 1] : left;
+    out[i] = property === 9 ? left + top - nw : left - nw;
+  }
+  return out;
+}
+function planPrice(plan) {
+  const writer = new BitWriter(512);
+  const histograms = writeChannelHistograms(writer, writeTree(writer, plan.tree), plan.freqs, l => plan.leaves.indexOf(l));
+  let bits = writer.bitLength;
+  plan.freqs.forEach((freq, i) => { const {lengths} = histograms[i + 1].code; for (let s = 0; s < freq.length; s++) bits += freq[s] * ((lengths[s] || 0) + localRaw(s)); });
+  return bits;
+}
+
+function plansOf(planes, width, height, rung) {
+  return planes.map(plane => {
+    let best;
+    for (const predictor of [5, 3, 6]) {
+      const properties = predictor === 6 ? new Int32Array(width * height) : null;
+      const values = residuals(plane, width, height, predictor, properties), one = leaf(predictor);
+      const candidates = [{...tokens(values), leaves: [one], tree: one}];
+      if (properties) candidates.push(intervalPlan(values, properties, predictor, 15, WEIGHTED_LOCAL_CUTS));
+      // Property 9 is the unclamped gradient; property 10 is W - NW. Signed cuts let the latter separate both
+      // tails around a flat neighbourhood without treating a high-magnitude negative edge as a small one.
+      if (rung >= 6 && predictor === 5) for (const property of [9, 10]) {
+        const local = localProperties(plane, width, height, property), cuts = property === 9 ? GRADIENT_CUTS : WEIGHTED_LOCAL_CUTS;
+        candidates.push(intervalPlan(values, local, predictor, property, cuts));
+      }
+      for (const plan of candidates) { const bits = planPrice(plan); if (!best || bits < best.bits) best = {...plan, bits}; }
+    }
+    return best;
+  });
+}
+
+function writeModel(writer, plans) {
+  const leaves = plans.flatMap(plan => plan.leaves);
+  const histograms = writeChannelHistograms(writer, writeTree(writer, channelTree(plans.map(plan => plan.tree))), plans.flatMap(plan => plan.freqs), l => leaves.indexOf(l));
+  return () => {
+    for (let c = 0; c < plans.length; c++) {
+      const {pieces} = plans[c], codes = plans[c].leaves.map(l => histograms[leaves.indexOf(l) + 1].code);
+      for (let i = 0; i < pieces.length; i += 3) {
+        const base = pieces[i + 1];
+        writeHybrid(writer, codes[pieces[i + 2]], base ? LZ77.lengthConfig : RESIDUAL_CONFIG, pieces[i], base);
+      }
+    }
+  };
+}
+
+// A group's own trees and histograms, here or in a pool's worker: the group's section, its bytes returned.
+export function localGroup(setup) {
+  const fill = planeFill(setup), planes = Array.from({length: setup.palette ? 1 : setup.channels}, () => new Int16Array(GROUP_DIM * GROUP_DIM));
+  return (rgba, stride, x0, y0, w, h) => {
+    fill(planes, rgba, stride, x0, y0, w, h);
+    const section = new BitWriter(w * h * planes.length + 256);
+    writeModularHeader(section, {useGlobalTree: false});
+    writeModel(section, plansOf(planes, w, h, setup.rung))();
+    return section.finish();
+  };
+}
+
+export function* localSteps(rgba, width, height, shape, colorSpace, rung = 4, usePalette = false, pooled) {
+  const {channels} = shape, layout = groupLayout(width, height), groups = layout.groupsX * layout.groupsY;
+  const palette = usePalette ? shape.palette : null;
+  if (usePalette && !palette) return null;
+  const setup = {channels, alpha: shape.alpha, palette: palette && palette.colours, rung};
+  const header = new BitWriter(256);
+  writeImageHeader(header, width, height, shape.colour, shape.alpha, {colorSpace});
+  writeModularFrameHeader(header, {alpha: shape.alpha});
+  const transforms = palette ? [{type: 'palette', beginC: 0, numC: channels, nbColors: palette.colours.length}] : channels >= 3 ? [{type: 'rct', beginC: 0, rctType: 6}] : [];
+  // The palette's meta channel precedes the picture in the global section; local AC groups contain only indices.
+  let palettePlans;
+  if (palette) {
+    const count = palette.colours.length, values = new Int16Array(count * channels);
+    palette.colours.forEach((colour, i) => { for (let c = 0; c < channels; c++) values[c * count + i] = palette.byte(colour, c); });
+    palettePlans = plansOf([values], count, channels, rung);
+  }
+  const global = new BitWriter(4096), sections = [];
+  let sectionBytes = 0;
+  const appendSection = bytes => {
+    // Refuse before retaining later groups of an oversized optional candidate.
+    sectionBytes += bytes.length; admitOutputSize(sectionBytes);
+    sections.push(bytes);
+  };
+  global.write(1, 1); global.write(1, 1);
+  if (layout.single) {
+    // One group: everything in the global section, the palette's plans before the picture's.
+    const planes = Array.from({length: palette ? 1 : channels}, () => new Int16Array(GROUP_DIM * GROUP_DIM));
+    planeFill(setup)(planes, rgba, width, 0, 0, width, height);
+    const write = writeModel(global, [...palettePlans || [], ...plansOf(planes, width, height, rung)]);
+    writeModularHeader(global, {transforms});
+    write(); appendSection(global.finish());
+    if (yield 1) return null;
+    return assembleCodestream(header, sections);
+  }
+  let write;
+  if (palettePlans) write = writeModel(global, palettePlans);
+  else {
+    const leaves = Array.from({length: channels}, () => leaf(5));
+    writeChannelHistograms(global, writeTree(global, channelTree(leaves)), leaves.map(() => new Uint32Array(ALPHABET)), l => leaves.indexOf(l));
+  }
+  writeModularHeader(global, {transforms});
+  if (write) write();
+  appendSection(global.finish());
+  for (let i = 0; i < layout.dcGroupsX * layout.dcGroupsY + 1; i++) sections.push(new Uint8Array(0));
+  const group = localGroup(setup);
+  if ((yield* groupPass({pooled, kind: 'local', setup, at: g => (g + 1) / groups, stop: () => true},
+    groups, g => appendSection(group(rgba, width, ...groupRect(layout, width, height, g))), (g, bytes) => appendSection(bytes))) === null) return null;
+  return assembleCodestream(header, sections);
+}

package/lossless-coding.mjs

@@ -0,0 +1,30 @@
+// Rapier's JPEG XL encoder: exact hybrid-integer prices for lossless residuals. MIT (LICENSE).
+// Raw literal counts retain the low-bit distribution that an exponent-only histogram throws away. The
+// run-length alphabet is separate while counting; projection restores it at the standard LZ77 boundary.
+import {BitWriter, floorLog2} from './bits.mjs';
+import {uintConfig, hybridToken, buildCode, writePrefixCode, writeUintConfig} from './prefix.mjs';
+import {ALPHABET} from './modular.mjs';
+
+const LOSSLESS_INTEGER_CONFIGS = [uintConfig(0), uintConfig(4), uintConfig(4, 1, 1), uintConfig(3, 0, 1)];
+
+export function losslessCoding(raw) {
+  const end = raw.length - 33, token = [0, 0, 0];
+  let original, best;
+  for (const config of LOSSLESS_INTEGER_CONFIGS) {
+    const freqs = new Uint32Array(ALPHABET);
+    let extra = 0;
+    for (let value = 0; value < end; value++) if (raw[value]) {
+      hybridToken(config, value, token);
+      freqs[token[0]] += raw[value]; extra += raw[value] * token[1];
+    }
+    for (let s = 0; s < 33; s++) { freqs[224 + s] = raw[end + s]; extra += raw[end + s] * Math.max(0, s - 12); }
+    const code = buildCode(freqs), w = new BitWriter(128);
+    writeUintConfig(w, config); writePrefixCode(w, code);
+    let bits = w.bitLength + extra + (code.alphabetSize === 1 ? 1 : 5 + floorLog2(code.alphabetSize - 1));
+    for (let s = 0; s < freqs.length; s++) if (freqs[s]) bits += freqs[s] * code.lengths[s];
+    const model = {config, freqs, bits, extra};
+    if (!original) original = model;
+    if (!best || bits < best.bits) best = model;
+  }
+  return [original, best];
+}