@poe-platform/safe-bash 0.1.838 → 0.1.840

package/dist/safe-bash-command-imagemagick/index.js

@@ -1,5 +1,96 @@
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
+// packages/safe-bash-command-imagemagick/src/quantize.ts
+function* quantizePixelSteps(length, requested) {
+  if (!Number.isSafeInteger(requested) || requested < 1) throw new Error("colors must be a positive integer");
+  let bins = /* @__PURE__ */ new Map(), mask = 4294967295, precision = 8;
+  const key = (data, i) => (data[i] << 24 | data[i + 1] << 16 | data[i + 2] << 8 | data[i + 3]) & mask;
+  for (let position = 0; position < length; position += 4096) {
+    yield;
+    const size = Math.min(4096, length - position), data = yield { kind: "read", position, length: size };
+    if (!data || data.length !== size) throw new Error("Truncated quantization pixels");
+    for (let i = 0; i < size; i += 4) {
+      const id = key(data, i);
+      let bin = bins.get(id);
+      if (!bin) {
+        bin = { count: 0, sums: [0, 0, 0, 0], color: [] };
+        bins.set(id, bin);
+      }
+      bin.count++;
+      for (let c = 0; c < 4; c++) bin.sums[c] += data[i + c];
+    }
+    if (bins.size > 65536) {
+      const channelMask = 255 << 8 - --precision & 255;
+      mask = channelMask * 16843009;
+      const reduced = /* @__PURE__ */ new Map();
+      let work = 0;
+      for (const [id, bin] of bins) {
+        if (++work % 1024 === 0) yield;
+        const next = id & mask, existing = reduced.get(next);
+        if (!existing) reduced.set(next, bin);
+        else {
+          existing.count += bin.count;
+          for (let c = 0; c < 4; c++) existing.sums[c] += bin.sums[c];
+        }
+      }
+      bins = reduced;
+    }
+  }
+  const pending = [{ colors: [...bins.values()], budget: requested }];
+  while (pending.length) {
+    yield;
+    const { colors, budget } = pending.pop();
+    if (!colors.length) continue;
+    const sums = [0, 0, 0, 0], squares = [0, 0, 0, 0];
+    let count = 0;
+    for (let i = 0; i < colors.length; i++) {
+      if (i % 1024 === 0) yield;
+      const bin = colors[i];
+      count += bin.count;
+      for (let c = 0; c < 4; c++) {
+        sums[c] += bin.sums[c];
+        squares[c] += bin.sums[c] ** 2 / bin.count;
+      }
+    }
+    if (colors.length <= budget) {
+      for (let i = 0; i < colors.length; i++) {
+        if (i % 1024 === 0) yield;
+        colors[i].color = colors[i].sums.map((value) => Math.round(value / colors[i].count));
+      }
+    } else if (budget === 1) {
+      const average = sums.map((value) => Math.round(value / count));
+      for (let i = 0; i < colors.length; i++) {
+        if (i % 1024 === 0) yield;
+        colors[i].color = average;
+      }
+    } else {
+      let axis = 0, variance = -1;
+      for (let c = 0; c < 4; c++) {
+        const next = squares[c] - sums[c] ** 2 / count;
+        if (next >= variance) {
+          variance = next;
+          axis = c;
+        }
+      }
+      colors.sort((a, b) => a.sums[axis] / a.count - b.sums[axis] / b.count);
+      let population = 0, split = 0;
+      do {
+        population += colors[split++].count;
+      } while (population < count / 2 && split < colors.length - 1);
+      const leftBudget = Math.min(split, Math.max(1, Math.floor(budget / 2)));
+      pending.push({ colors: colors.slice(0, split), budget: leftBudget }, { colors: colors.slice(split), budget: budget - leftBudget });
+    }
+  }
+  for (let position = 0; position < length; position += 4096) {
+    yield;
+    const size = Math.min(4096, length - position), source = yield { kind: "read", position, length: size };
+    if (!source || source.length !== size) throw new Error("Truncated quantization pixels");
+    const data = new Uint8Array(size);
+    for (let i = 0; i < size; i += 4) data.set(bins.get(key(source, i)).color, i);
+    yield { kind: "write", position, data };
+  }
+}
+
 // packages/safe-bash-command-imagemagick/src/connected-components.ts
 import { yieldTurn as yieldTurn2 } from "../safe-bash-contracts/yield.js";
 
@@ -875,9 +966,10 @@ function* warpPixelSteps(source, plan, background) {
 }
 
 // packages/safe-bash-command-imagemagick/src/morphology-kernel.ts
-function* morphologyPixelSteps(image, rx, ry, mode) {
+function* morphologyPixelSteps(image, rows, mode) {
   const { width, height } = image, histogram = new Float64Array(4 * 256);
-  const rank = Math.floor((rx * 2 + 1) * (ry * 2 + 1) / 2);
+  const ry = Math.floor(rows.length / 2);
+  const rank = Math.floor(rows.reduce((total, radius) => total + radius * 2 + 1, 0) / 2);
   let work = 0;
   for (let y = 0; y < height; y++) {
     yield;
@@ -887,14 +979,18 @@ function* morphologyPixelSteps(image, rx, ry, mode) {
       for (let local = 0; local < count; local++) {
         const x = left + local;
         for (let phase = 0; phase < (x === 0 ? 1 : 2); phase++) {
-          const first = x === 0 ? -rx : phase === 0 ? x - rx - 1 : x + rx;
-          const last = x === 0 ? rx : first, delta = x === 0 || phase === 1 ? 1 : -1;
-          for (let dy = -ry; dy <= ry; dy++) for (let column = first; column <= last; column++) {
-            if (++work % 4096 === 0) yield;
-            const sx = Math.max(0, Math.min(width - 1, column)), sy = Math.max(0, Math.min(height - 1, y + dy));
-            const bytes = yield { kind: "read", position: (sy * width + sx) * 4, length: 4 };
-            if (!bytes || bytes.length !== 4) throw new Error("Truncated morphology pixels");
-            for (let c = 0; c < 4; c++) histogram[c * 256 + bytes[c]] += delta;
+          const delta = x === 0 || phase === 1 ? 1 : -1;
+          for (let dy = -ry; dy <= ry; dy++) {
+            const rx = rows[dy + ry];
+            const first = x === 0 ? -rx : phase === 0 ? x - rx - 1 : x + rx;
+            const last = x === 0 ? rx : first;
+            for (let column = first; column <= last; column++) {
+              if (++work % 4096 === 0) yield;
+              const sx = Math.max(0, Math.min(width - 1, column)), sy = Math.max(0, Math.min(height - 1, y + dy));
+              const bytes = yield { kind: "read", position: (sy * width + sx) * 4, length: 4 };
+              if (!bytes || bytes.length !== 4) throw new Error("Truncated morphology pixels");
+              for (let c = 0; c < 4; c++) histogram[c * 256 + bytes[c]] += delta;
+            }
           }
         }
         for (let c = 0; c < 4; c++) {
@@ -1332,6 +1428,7 @@ function* compareImageSteps(imgA, imgB, options) {
   const height = Math.max(imgA.height, imgB.height);
   const totalPixels = Math.max(1, width * height);
   let aeCount = 0;
+  let aeMagnitude = 0;
   let sumAbs = 0;
   let sumSq = 0;
   let maxAbs = 0;
@@ -1341,6 +1438,15 @@ function* compareImageSteps(imgA, imgB, options) {
   let sumLumSqB = 0;
   let sumLumAB = 0;
   const hasAlpha = imgA.hasAlpha || imgB.hasAlpha;
+  const nccChannels = metric === "ncc" ? Array.from({ length: imgA.hasAlpha && imgB.hasAlpha ? 4 : 3 }, () => ({
+    rawA: 0,
+    rawB: 0,
+    sumA: 0,
+    sumB: 0,
+    squareA: 0,
+    squareB: 0,
+    product: 0
+  })) : [];
   for (let y = 0; y < height; y++) {
     if ((y & 511) === 511)
       yield;
@@ -1353,6 +1459,7 @@ function* compareImageSteps(imgA, imgB, options) {
         dataA = yield { kind: "read", image: 0, position: (y * imgA.width + left) * 4, length };
         if (!(dataA instanceof Uint8Array) || dataA.length !== length)
           throw new Error("Truncated comparison pixels");
+        dataA = dataA.slice();
       }
       if (y < imgB.height && left < imgB.width) {
         const length = Math.min(count, imgB.width - left) * 4;
@@ -1375,6 +1482,20 @@ function* compareImageSteps(imgA, imgB, options) {
         const gB = offB >= 0 ? dataB[offB + 1] : 0;
         const bB = offB >= 0 ? dataB[offB + 2] : 0;
         const aB = offB >= 0 ? dataB[offB + 3] : 0;
+        for (let channel = 0; channel < nccChannels.length; channel++) {
+          const stats = nccChannels[channel];
+          const rawA = offA >= 0 ? dataA[offA + channel] : 0;
+          const rawB = offB >= 0 ? dataB[offB + channel] : 0;
+          const a = channel === 3 ? rawA : rawA * aA / 255;
+          const b = channel === 3 ? rawB : rawB * aB / 255;
+          stats.rawA += rawA;
+          stats.rawB += rawB;
+          stats.sumA += a;
+          stats.sumB += b;
+          stats.squareA += a * a;
+          stats.squareB += b * b;
+          stats.product += a * b;
+        }
         const dr = Math.abs(rA - rB);
         const dg = Math.abs(gA - gB);
         const db = Math.abs(bA - bB);
@@ -1384,6 +1505,8 @@ function* compareImageSteps(imgA, imgB, options) {
         const pdr = Math.abs(rA * alphaA - rB * alphaB);
         const pdg = Math.abs(gA * alphaA - gB * alphaB);
         const pdb = Math.abs(bA * alphaA - bB * alphaB);
+        const aeR = hasAlpha ? pdr : dr, aeG = hasAlpha ? pdg : dg, aeB = hasAlpha ? pdb : db;
+        aeMagnitude += (aeR > fuzz ? aeR : 0) + (aeG > fuzz ? aeG : 0) + (aeB > fuzz ? aeB : 0) + (hasAlpha && da > fuzz ? da : 0);
         const maxDelta = hasAlpha ? Math.max(pdr, pdg, pdb, da) : Math.max(dr, dg, db);
         if (!inBoundsA || !inBoundsB || maxDelta > fuzz) {
           aeCount++;
@@ -1445,11 +1568,10 @@ function* compareImageSteps(imgA, imgB, options) {
   const c1 = 1e-4;
   const c2 = 9e-4;
   const ssim = (2 * muA * muB + c1) * (2 * covAB + c2) / ((muA * muA + muB * muB + c1) * (varA + varB + c2));
-  const ncc = varA === 0 && varB === 0 ? 1 : covAB / (Math.sqrt(varA * varB) || 1);
   let metricStr;
   switch (metric) {
     case "ae":
-      metricStr = String(aeCount);
+      metricStr = `${formatSignificantMetric(aeMagnitude / (numCh * 255))} (${formatSignificantMetric(aeMagnitude / (totalPixels * numCh * 255))})`;
       break;
     case "mae":
       metricStr = `${formatMetricNum(maeNorm * 65535)} (${formatMetricNum(maeNorm)})`;
@@ -1461,23 +1583,37 @@ function* compareImageSteps(imgA, imgB, options) {
       metricStr = `${formatMetricNum(paeNorm * 65535)} (${formatMetricNum(paeNorm)})`;
       break;
     case "psnr":
-      metricStr = mseNorm === 0 ? "inf" : formatMetricNum(10 * Math.log10(1 / mseNorm));
+      metricStr = mseNorm === 0 ? "120 (1)" : formatMetricNum(10 * Math.log10(1 / mseNorm));
       break;
-    case "ssim":
-      metricStr = formatMetricNum(ssim);
+    case "ssim": {
+      const distortion = yield* compareSsimSteps(imgA, imgB);
+      metricStr = `${formatSignificantMetric(distortion * 65535)} (${formatSignificantMetric(distortion)})`;
       break;
+    }
     case "dssim":
       metricStr = formatMetricNum((1 - ssim) / 2);
       break;
-    case "ncc":
-      metricStr = formatMetricNum(ncc);
+    case "ncc": {
+      let varianceA = 0, varianceB = 0, covariance = 0;
+      for (const stats of nccChannels) {
+        const meanA = stats.rawA / (imgA.width * imgA.height);
+        const meanB = stats.rawB / (imgB.width * imgB.height);
+        varianceA += Math.max(0, stats.squareA - 2 * meanA * stats.sumA + totalPixels * meanA * meanA);
+        varianceB += Math.max(0, stats.squareB - 2 * meanB * stats.sumB + totalPixels * meanB * meanB);
+        covariance += stats.product - meanA * stats.sumB - meanB * stats.sumA + totalPixels * meanA * meanB;
+      }
+      const denominator = Math.sqrt(varianceA) * Math.sqrt(varianceB);
+      const similarity = denominator === 0 ? 0 : covariance / denominator;
+      const distortion = Math.abs(1 - similarity) < 2e-12 ? 0 : (1 - similarity) / 2;
+      metricStr = `${formatSignificantMetric(distortion * 65535)} (${formatSignificantMetric(distortion)})`;
       break;
+    }
     case "rmse":
     default:
       metricStr = `${formatMetricNum(rmseNorm * 65535)} (${formatMetricNum(rmseNorm)})`;
       break;
   }
-  const exitCode = dissimilarityThreshold !== void 0 ? rmseNorm > dissimilarityThreshold ? 1 : 0 : aeCount > 0 ? 1 : 0;
+  const exitCode = metric === "psnr" && mseNorm === 0 ? 1 : dissimilarityThreshold !== void 0 ? rmseNorm > dissimilarityThreshold ? 1 : 0 : aeCount > 0 ? 1 : 0;
   return { width, height, metric: metricStr, exitCode };
 }
 function formatMetricNum(n) {
@@ -1488,6 +1624,65 @@ function formatMetricNum(n) {
   const fixed = n.toFixed(6).replace(/\.?0+$/, "");
   return fixed === "-0" ? "0" : fixed;
 }
+function formatSignificantMetric(n) {
+  const rounded = Number(n.toPrecision(6));
+  if (rounded === 0 || rounded >= 1e-4 && rounded < 1e6)
+    return String(rounded);
+  const [mantissa, exponent] = rounded.toExponential().split("e");
+  return `${mantissa}e${exponent[0]}${exponent.slice(1).padStart(2, "0")}`;
+}
+function* compareSsimSteps(imgA, imgB) {
+  const width = Math.max(imgA.width, imgB.width), height = Math.max(imgA.height, imgB.height);
+  const channels = imgA.hasAlpha && imgB.hasAlpha ? 4 : 3;
+  const weights = Array.from({ length: 11 }, (_, i) => Math.exp(-((i - 5) ** 2) / (2 * 1.5 ** 2)));
+  const weightSum = weights.reduce((sum, value) => sum + value, 0);
+  for (let i = 0; i < weights.length; i++)
+    weights[i] = weights[i] / weightSum;
+  let similarity = 0;
+  for (let y = 0; y < height; y++) {
+    for (let left = 0; left < width; left += 1014) {
+      yield;
+      const count = Math.min(1014, width - left);
+      const rows = [[], []];
+      const starts = [];
+      for (const image of [0, 1]) {
+        const info = image === 0 ? imgA : imgB;
+        const start = Math.min(info.width - 1, Math.max(0, left - 5));
+        const end = Math.min(info.width, left + count + 5);
+        starts[image] = start;
+        for (let v = -5; v <= 5; v++) {
+          const row = Math.max(0, Math.min(info.height - 1, y + v));
+          const length = (end - start) * 4;
+          const data = yield { kind: "read", image, position: (row * info.width + start) * 4, length };
+          if (!(data instanceof Uint8Array) || data.length !== length)
+            throw new Error("Truncated comparison pixels");
+          rows[image].push(data.slice());
+        }
+      }
+      for (let x = left; x < left + count; x++) {
+        for (let channel = 0; channel < channels; channel++) {
+          let muA = 0, muB = 0, squareA = 0, squareB = 0, product = 0;
+          for (let v = 0; v < 11; v++) {
+            for (let u = 0; u < 11; u++) {
+              const offsetA = (Math.max(0, Math.min(imgA.width - 1, x + u - 5)) - starts[0]) * 4 + channel;
+              const offsetB = (Math.max(0, Math.min(imgB.width - 1, x + u - 5)) - starts[1]) * 4 + channel;
+              const a = rows[0][v][offsetA] / 255, b = rows[1][v][offsetB] / 255;
+              const weight = weights[u] * weights[v];
+              muA += weight * a;
+              muB += weight * b;
+              squareA += weight * a * a;
+              squareB += weight * b * b;
+              product += weight * a * b;
+            }
+          }
+          similarity += (2 * muA * muB + 1e-4) * (2 * (product - muA * muB) + 9e-4) / ((muA * muA + muB * muB + 1e-4) * (squareA - muA * muA + squareB - muB * muB + 9e-4));
+        }
+      }
+    }
+  }
+  const distortion = (1 - similarity / (width * height * channels)) / 2;
+  return Math.abs(distortion) < 1e-12 ? 0 : distortion;
+}
 
 // packages/safe-bash-command-imagemagick/src/identify-file.ts
 import { readImageMetadataFromSource as readImageMetadataFromSource2, tryPdfMetadata as tryPdfMetadata2, computeStoredImageStats, readImageMetadata as readImageMetadata2, decodeImage as decodeImage2, computeImageStatsSteps, UnsupportedStoredResource as UnsupportedStoredResource3, UnsupportedImageFormat as UnsupportedImageFormat3 } from "../image-ast/portable.js";
@@ -1584,7 +1779,7 @@ import {
 } from "../safe-bash-contracts/command.js";
 import { readBytes as readBytes2, writeBytes as writeBytes2 } from "../safe-bash-contracts/io.js";
 import { createOutputOperation } from "../safe-bash-contracts/output.js";
-import { readImageMetadataFromSource as readImageMetadataFromSource3, decodeImageToStorage as decodeImageToStorage2, transformStoredImage, UnsupportedStoredResource as UnsupportedStoredResource4, decodeImage as decodeImage3, decodePngToCanvas, FONT_5X7, encodeImage, readImageMetadata as readImageMetadata3, parseColor as baseParseColor, applyExifOrientationSteps, blurImageSteps, compositeImageSteps, computeImageStatsSteps as computeImageStatsSteps2, ensureAlphaImageSteps, extendImageSteps, extractChannelImageSteps, extractImageSteps, flattenImageSteps, flipImageSteps, flopImageSteps, gammaImageSteps, grayscaleImageSteps, linearImageSteps, medianImageSteps, modulateImageSteps, negateImageSteps, removeAlphaImageSteps, resizeImageSteps, rotateImageSteps, sharpenImageSteps, thresholdImageSteps, tintImageSteps, trimImageSteps } from "../image-ast/portable.js";
+import { readImageMetadataFromSource as readImageMetadataFromSource3, decodeImageToStorage as decodeImageToStorage2, transformStoredImage, UnsupportedStoredResource as UnsupportedStoredResource4, decodeImage as decodeImage3, decodePngToCanvas, FONT_5X7, encodeImage, readImageMetadata as readImageMetadata3, parseColor as baseParseColor, applyExifOrientationSteps, blurImageSteps, compositeImageSteps, computeImageStatsSteps as computeImageStatsSteps2, ensureAlphaImageSteps, extendImageSteps, extractChannelImageSteps, extractImageSteps, flattenImageSteps, flipImageSteps, flopImageSteps, grayscaleImageSteps, linearImageSteps, medianImageSteps, negateImageSteps, removeAlphaImageSteps, resizeImageSteps, rotateImageSteps, sharpenImageSteps, thresholdImageSteps, trimImageSteps } from "../image-ast/portable.js";
 var X11_NAMED_COLORS = {
   aliceblue: [240, 248, 255, 255],
   antiquewhite: [250, 235, 215, 255],
@@ -2001,6 +2196,10 @@ function magickMorphologyPlan(methodRaw, kernelSpec) {
     rx = Math.max(1, Math.round(Number(sizePart)));
     ry = rx;
   }
+  const disk = (colonIdx < 0 ? kernelSpec : kernelSpec.slice(0, colonIdx)).toLowerCase() === "disk";
+  const radius = Number(sizePart) || 4.5;
+  if (disk) ry = Math.max(0, Math.floor(radius));
+  const rows = Array.from({ length: ry * 2 + 1 }, (_, row) => disk ? Math.floor(Math.sqrt(radius * radius - (row - ry) ** 2)) : rx);
   const filter = (source, mode) => ({ source, mode });
   const diff = (a, b) => ({ mode: "diff", a, b });
   let steps;
@@ -2037,7 +2236,7 @@ function magickMorphologyPlan(methodRaw, kernelSpec) {
     default:
       steps = [filter(0, "max")];
   }
-  return { rx, ry, steps };
+  return { rows, steps };
 }
 function* subtractMagickPixelSteps(a, b) {
   const result = new Uint8Array(a.length);
@@ -2055,7 +2254,7 @@ function* applyMagickMorphology4ChSteps(img, methodRaw, kernelSpec, signal) {
       images.push({ ...a, data: yield* subtractMagickPixelSteps(a.data, b.data) });
     } else {
       const source = images[step.source];
-      images.push(yield* applyMagickRasterSteps(source, morphologyPixelSteps(source, plan.rx, plan.ry, step.mode), signal));
+      images.push(yield* applyMagickRasterSteps(source, morphologyPixelSteps(source, plan.rows, step.mode), signal));
     }
   }
   return images.at(-1);
@@ -2168,7 +2367,9 @@ function* applyMagickEvaluateSequenceSteps(stack, opRaw, signal) {
 }
 function parseMagickConvolveKernel(spec) {
   const afterColon = spec.includes(":") ? spec.slice(spec.indexOf(":") + 1) : spec;
-  return afterColon.trim().split(/[\s,]+/).filter((s) => s.length > 0).map(Number).filter(Number.isFinite);
+  const kernel = afterColon.trim().split(/[\s,]+/).filter((s) => s.length > 0).map(Number).filter(Number.isFinite);
+  const sum = kernel.reduce((total, weight) => total + weight, 0);
+  return sum === 0 ? kernel : kernel.map((weight) => weight / sum);
 }
 function* applyMagickCustomConvolveSteps(img, spec, signal) {
   const kernel = parseMagickConvolveKernel(spec);
@@ -2804,7 +3005,9 @@ function* applyMagickOpaqueSteps(img, target, replacement, fuzz, invert, signal)
     const dr = Math.abs(out[i] - target.r);
     const dg = Math.abs(out[i + 1] - target.g);
     const db = Math.abs(out[i + 2] - target.b);
-    const matched = Math.max(dr, dg, db) <= fuzz;
+    const alpha = out[i + 3];
+    const distance = (alpha - target.a) ** 2 + (dr ** 2 + dg ** 2 + db ** 2) * (alpha / 255) * (target.a / 255) / 3;
+    const matched = distance <= fuzz ** 2;
     if (invert ? !matched : matched) {
       out[i] = replacement.r;
       out[i + 1] = replacement.g;
@@ -2823,7 +3026,9 @@ function* applyMagickTransparentSteps(img, target, fuzz, invert, signal) {
     const dr = Math.abs(out[i] - target.r);
     const dg = Math.abs(out[i + 1] - target.g);
     const db = Math.abs(out[i + 2] - target.b);
-    const matched = Math.max(dr, dg, db) <= fuzz;
+    const alpha = out[i + 3];
+    const distance = (alpha - target.a) ** 2 + (dr ** 2 + dg ** 2 + db ** 2) * (alpha / 255) * (target.a / 255) / 3;
+    const matched = distance <= fuzz ** 2;
     if (invert ? !matched : matched) {
       out[i + 3] = 0;
     }
@@ -2835,7 +3040,7 @@ function* applyMagickEvaluateSteps(img, opRaw, valStr, channels, signal) {
   const op = opRaw.toLowerCase().replace(/[-_]/g, "");
   const isPct = valStr.trim().endsWith("%");
   const rawNum = parseFloat(valStr);
-  const vByte = isPct ? rawNum / 100 * 255 : rawNum <= 1 && valStr.includes(".") ? rawNum * 255 : rawNum > 255 ? rawNum / 257 : rawNum;
+  const vByte = isPct ? rawNum / 100 * 255 : rawNum / 257;
   const vFactor = isPct ? rawNum / 100 : rawNum;
   const out = new Uint8Array(img.data);
   const mask = [channels.r, channels.g, channels.b, channels.a];
@@ -3592,14 +3797,66 @@ function* applyMagickPosterizeSteps(img, levelsRaw, signal) {
   const levels = Math.max(2, Math.min(256, Math.round(levelsRaw)));
   const step = 255 / (levels - 1);
   const out = new Uint8Array(img.data);
+  let palette;
   for (let i = 0; i < out.length; i += 4) {
     if (++cooperativeWork % 65536 === 0)
       yield;
-    out[i] = clampByteVal(Math.round(out[i] / 255 * (levels - 1)) * step);
-    out[i + 1] = clampByteVal(Math.round(out[i + 1] / 255 * (levels - 1)) * step);
-    out[i + 2] = clampByteVal(Math.round(out[i + 2] / 255 * (levels - 1)) * step);
+    if (img.hasAlpha && out[i + 3] < 255 && levels <= 16) {
+      if (!palette) {
+        palette = { children: [] };
+        for (let a = 0; a < levels; a++) for (let b = 0; b < levels; b++) for (let g = 0; g < levels; g++) for (let r = 0; r < levels; r++) {
+          if (++cooperativeWork % 1024 === 0) {
+            signal?.throwIfAborted();
+            yield;
+          }
+          const color = a === 0 ? [0, 0, 0, 0] : [r * step, g * step, b * step, a * step];
+          const bytes2 = color.map((value, channel) => Math.round(channel === 3 ? value : value * color[3] / 255));
+          let node2 = palette;
+          for (let bit = 7; bit >= 0; bit--) {
+            const id = bytes2[0] >> bit & 1 | (bytes2[1] >> bit & 1) << 1 | (bytes2[2] >> bit & 1) << 2 | (bytes2[3] >> bit & 1) << 3;
+            node2 = node2.children[id] ??= { children: [] };
+          }
+          node2.color = color;
+        }
+      }
+      const alpha = out[i + 3] / 255;
+      const target = [out[i] * alpha, out[i + 1] * alpha, out[i + 2] * alpha, out[i + 3]];
+      const bytes = target.map(Math.round);
+      let node = palette, parent = palette;
+      for (let bit = 7; bit > 0; bit--) {
+        const id = bytes[0] >> bit & 1 | (bytes[1] >> bit & 1) << 1 | (bytes[2] >> bit & 1) << 2 | (bytes[3] >> bit & 1) << 3;
+        const child = node.children[id];
+        if (!child) break;
+        parent = node;
+        node = child;
+      }
+      let distance = Infinity, closest = [0, 0, 0, 0];
+      const pending = [parent];
+      while (pending.length) {
+        if (++cooperativeWork % 1024 === 0) {
+          signal?.throwIfAborted();
+          yield;
+        }
+        const candidate = pending.pop();
+        for (let child = candidate.children.length - 1; child >= 0; child--) {
+          if (candidate.children[child]) pending.push(candidate.children[child]);
+        }
+        if (!candidate.color) continue;
+        const color = candidate.color, candidateAlpha = color[3] / 255;
+        let error = (color[3] - target[3]) ** 2;
+        for (let channel = 0; channel < 3; channel++) error += (color[channel] * candidateAlpha - target[channel] * alpha) ** 2;
+        if (error <= distance) {
+          distance = error;
+          closest = color;
+        }
+      }
+      for (let channel = 0; channel < 4; channel++) out[i + channel] = clampByteVal(closest[channel]);
+    } else {
+      for (let channel = 0; channel < 4; channel++) out[i + channel] = clampByteVal(Math.round(out[i + channel] / 255 * (levels - 1)) * step);
+    }
   }
-  return { ...img, data: out };
+  const { data16: ignored, ...metadata } = img;
+  return { ...metadata, data: out };
 }
 function* applyMagickRasterSteps(img, steps, signal, dimensions = img, sources = [img]) {
   const data = new Uint8Array(dimensions.width * dimensions.height * 4);
@@ -3755,7 +4012,7 @@ function parseCompose(raw) {
 function magickCompositeMode(mode) {
   let name = "";
   for (const character of mode.toLowerCase()) if (character !== "-" && character !== "_" && character.trim()) name += character;
-  return { name, delegated: ["over", "srcover", "dstover", "destover", "plus", "add", "lineardodge", "colordodge", "colorburn", "hardlight", "softlight", "saturate"].includes(name) };
+  return { name, delegated: ["over", "srcover", "dstover", "destover", "plus", "add", "lineardodge", "colordodge", "colorburn", "saturate"].includes(name) };
 }
 function* applyMagickCompositeLayerSteps(dst, src, modeRaw, left, top, composeArgs, signal) {
   let cooperativeWork = 0;
@@ -3823,7 +4080,7 @@ function* applyMagickCompositeLayerSteps(dst, src, modeRaw, left, top, composeAr
         out[dIdx] = sr;
         out[dIdx + 1] = sg;
         out[dIdx + 2] = sb;
-        out[dIdx + 3] = saByte;
+        out[dIdx + 3] = dst.hasAlpha ? saByte : daByte;
         continue;
       }
       if (norm === "dst" || norm === "dest") {
@@ -3852,11 +4109,24 @@ function* applyMagickCompositeLayerSteps(dst, src, modeRaw, left, top, composeAr
         out[dIdx + 2] = sb;
         continue;
       }
+      if (norm === "softlight") {
+        const alpha = sa + da - sa * da;
+        for (let c = 0; c < 3; c++) {
+          const sc = src.data[sIdx + c] / 255 * sa;
+          const dc = dst.data[dIdx + c] / 255 * da;
+          const blend = sc <= 0.5 ? dc - (1 - 2 * sc) * dc * (1 - dc) : dc + (2 * sc - 1) * ((dc > 0.25 ? Math.sqrt(dc) : ((16 * dc - 12) * dc + 4) * dc) - dc);
+          out[dIdx + c] = alpha === 0 ? 0 : clampByteVal(255 * (dc * sa + da * blend + sc * (1 - da) + dc * (1 - sa)) / alpha);
+        }
+        out[dIdx + 3] = clampByteVal(alpha * 255);
+        continue;
+      }
       if (norm === "difference") {
+        if (saByte === 0)
+          continue;
         out[dIdx] = Math.abs(sr - dr);
         out[dIdx + 1] = Math.abs(sg - dg);
         out[dIdx + 2] = Math.abs(sb - db);
-        out[dIdx + 3] = Math.abs(saByte - daByte);
+        out[dIdx + 3] = dst.hasAlpha ? Math.abs(saByte - daByte) : daByte;
         continue;
       }
       if (norm === "in" || norm === "srcin") {
@@ -3910,10 +4180,10 @@ function* applyMagickCompositeLayerSteps(dst, src, modeRaw, left, top, composeAr
         out[dIdx] = clampByteVal(sr * sa * (1 - da) + dr * da * (1 - sa));
         out[dIdx + 1] = clampByteVal(sg * sa * (1 - da) + dg * da * (1 - sa));
         out[dIdx + 2] = clampByteVal(sb * sa * (1 - da) + db * da * (1 - sa));
-        out[dIdx + 3] = clampByteVal(outA * 255);
+        out[dIdx + 3] = dst.hasAlpha ? clampByteVal(outA * 255) : daByte;
         continue;
       }
-      if (norm === "multiply" || norm === "screen" || norm === "overlay" || norm === "darken" || norm === "lighten" || norm === "exclusion") {
+      if (norm === "multiply" || norm === "screen" || norm === "overlay" || norm === "hardlight" || norm === "darken" || norm === "lighten" || norm === "exclusion") {
         const gamma = sa + da - sa * da;
         const sChan = [sr / 255, sg / 255, sb / 255];
         const dChan = [dr / 255, dg / 255, db / 255];
@@ -3937,10 +4207,12 @@ function* applyMagickCompositeLayerSteps(dst, src, modeRaw, left, top, composeAr
               f = sc * dc;
             else if (norm === "screen")
               f = sc + dc - sc * dc;
+            else if (norm === "hardlight")
+              f = sc <= 0.5 ? 2 * sc * dc : 1 - 2 * (1 - sc) * (1 - dc);
             else
               f = dc <= 0.5 ? 2 * sc * dc : 1 - 2 * (1 - sc) * (1 - dc);
             const comp = f * sa * da + sc * sa * (1 - da) + dc * da * (1 - sa);
-            const unpremul = gamma > 1e-6 && norm === "overlay" ? comp / gamma : comp;
+            const unpremul = gamma > 1e-6 && (norm === "overlay" || norm === "hardlight") ? comp / gamma : comp;
             out[dIdx + c] = clampByteVal(unpremul * 255);
           }
         }
@@ -3964,7 +4236,7 @@ function* applyMagickCompositeLayerSteps(dst, src, modeRaw, left, top, composeAr
     const clipped = yield* extractImageSteps(src, { left: sx0, top: sy0, width: sx1 - sx0, height: sy1 - sy0 });
     return yield* compositeImageSteps(dst, [rgbaToCompositeLayer(clipped, Math.max(0, ox), Math.max(0, oy), parseCompose(modeRaw))]);
   }
-  return { ...dst, data: out, hasAlpha: true };
+  return { ...dst, data: out, hasAlpha: ["difference", "src", "source", "copy", "xor"].includes(norm) ? dst.hasAlpha : true };
 }
 function rgbaToCss(c) {
   if (c.a === 0) return "none";
@@ -4540,21 +4812,24 @@ function* appendStackImagesSteps(stack, vertical, state) {
   const totalW = vertical ? Math.max(...stack.map((im) => im.width)) : stack.reduce((acc, im) => acc + im.width, 0);
   const totalH = vertical ? stack.reduce((acc, im) => acc + im.height, 0) : Math.max(...stack.map((im) => im.height));
   const canvas = yield* createSolidRgbaImageSteps(totalW, totalH, state.background);
+  let hasAlpha = canvas.hasAlpha;
   let cursor = 0;
   for (const im of stack) {
     if (++work % 16384 === 0)
       yield;
-    if (vertical) {
-      const off = resolveGravityOffset(totalW - im.width, 0, state.gravity);
-      yield* blitOverRgbaInPlaceSteps(canvas, im, off.left, cursor);
-      cursor += im.height;
-    } else {
-      const off = resolveGravityOffset(0, totalH - im.height, state.gravity);
-      yield* blitOverRgbaInPlaceSteps(canvas, im, cursor, off.top);
-      cursor += im.width;
+    const off = resolveGravityOffset(vertical ? totalW - im.width : 0, vertical ? 0 : totalH - im.height, state.gravity);
+    const left = vertical ? off.left : cursor, top = vertical ? cursor : off.top;
+    for (let y = 0; y < im.height; y++) {
+      for (let x = 0; x < im.width; x += 4096) {
+        yield;
+        const start = (y * im.width + x) * 4;
+        canvas.data.set(im.data.subarray(start, start + Math.min(4096, im.width - x) * 4), ((top + y) * totalW + left + x) * 4);
+      }
     }
+    hasAlpha ||= im.hasAlpha;
+    cursor += vertical ? im.height : im.width;
   }
-  return canvas;
+  return { ...canvas, hasAlpha };
 }
 function inferOutputFormat(spec, fallback = "png") {
   const prefixMatch = /^([a-zA-Z0-9]+):(.*)$/.exec(spec);
@@ -5092,6 +5367,7 @@ function* accumulateMagickHistogram(data, histogram) {
   for (let i = 0; i < data.length; i += 4) {
     if (i && i % 65536 === 0) yield;
     for (let channel = 0; channel < 4; channel++) histogram[channel][data[i + channel]]++;
+    if (histogram[4]) histogram[4][Math.round(257 * (0.212656 * data[i] + 0.715158 * data[i + 1] + 0.072186 * data[i + 2]))]++;
   }
 }
 function* applyMagickLookup(image, lookup) {
@@ -5113,9 +5389,9 @@ function parseMagickAnalysisOperation(tokens, state, start) {
   const token = tokens[start];
   if (!["-auto-level", "-auto-gamma", "-normalize", "-contrast-stretch", "-linear-stretch", "-equalize"].includes(token ?? "")) return;
   let end = start;
-  const argument = token === "-normalize" ? "2%x1%" : token === "-contrast-stretch" || token === "-linear-stretch" ? tokens[++end] ?? "0%x0%" : "";
+  const argument = token === "-contrast-stretch" || token === "-linear-stretch" ? tokens[++end] ?? "0%x0%" : "";
   const independent = state.channelExplicit, channels = independent ? state.channels : { r: true, g: true, b: true, a: false };
-  return { end, lookup(histogram, image) {
+  return { end, luminance: token === "-linear-stretch" || (token === "-normalize" || token === "-contrast-stretch" || token === "-equalize") && !independent, lookup(histogram, image) {
     const lookup = Array.from({ length: 4 }, () => Uint8Array.from({ length: 256 }, (_, value) => value));
     const count = Math.max(1, image.width * image.height);
     if (token === "-auto-gamma") {
@@ -5142,36 +5418,59 @@ function parseMagickAnalysisOperation(tokens, state, start) {
         const range = maxs[channel] - mins[channel];
         if (active[channel] && range > 0) for (let value = 0; value < 256; value++) lookup[channel][value] = clampByteVal((value - mins[channel]) / range * 255);
       }
-    } else if (token === "-equalize") {
-      for (let channel = 0; channel < 3; channel++) {
-        let cumulative = 0, first = 0;
-        for (let value = 0; value < 256; value++) {
-          cumulative += histogram[channel][value];
-          if (first === 0 && cumulative > 0) first = cumulative;
-          lookup[channel][value] = clampByteVal((cumulative - first) / Math.max(1, count - first) * 255);
-        }
-      }
-    } else {
-      const [black, white] = argument.split("x"), percentage = argument.includes("%"), blackValue = parseFloat(black || "0") || 0, whiteValue = white !== void 0 ? parseFloat(white) || 0 : blackValue;
-      const lowTarget = percentage ? blackValue / 100 * count : blackValue, highTarget = percentage ? (100 - whiteValue) / 100 * count : count - whiteValue;
-      for (let channel = 0; channel < 3; channel++) {
-        let low = 0, high = 255, sum = 0;
-        for (let value = 0; value < 256; value++) {
-          sum += histogram[channel][value];
-          if (sum > lowTarget) {
-            low = value;
-            break;
-          }
+    } else if (token === "-linear-stretch") {
+      const [black, white] = argument.split("x"), percentage = argument.includes("%");
+      const lowTarget = (parseFloat(black || "0") || 0) * (percentage ? count / 100 : 1);
+      const highTarget = white === void 0 ? count - lowTarget : (parseFloat(white) || 0) * (percentage ? count / 100 : 1);
+      const bins = histogram[4];
+      let low = 0, high = bins.length - 1, sum = 0;
+      for (; low < bins.length - 1; low++) {
+        sum += bins[low];
+        if (sum >= lowTarget) break;
+      }
+      sum = 0;
+      for (; high > 0; high--) {
+        sum += bins[high];
+        if (sum >= highTarget) break;
+      }
+      const active = [channels.r, channels.g, channels.b, (!independent || channels.a) && image.hasAlpha];
+      for (let channel = 0; channel < 4; channel++) {
+        if (!active[channel]) continue;
+        for (let value = 0; value < 256; value++) lookup[channel][value] = high === low ? value * 257 > low ? 255 : 0 : clampByteVal((value * 257 - low) / (high - low) * 255);
+      }
+    } else if (token === "-normalize" || token === "-contrast-stretch") {
+      const [black, white] = argument.split("x"), percentage = argument.includes("%");
+      const blackValue = parseFloat(black || "0") || 0, whiteValue = white === void 0 ? blackValue : parseFloat(white) || 0;
+      const lowTarget = token === "-normalize" ? 0.02 * count : percentage ? blackValue / 100 * count : blackValue;
+      const highTarget = token === "-normalize" ? 0.01 * count : percentage ? whiteValue / 100 * count : whiteValue;
+      const active = [channels.r, channels.g, channels.b, (!independent || channels.a) && image.hasAlpha];
+      for (let channel = 0; channel < 4; channel++) {
+        if (!active[channel]) continue;
+        const bins = histogram[4] ?? histogram[channel], scale = histogram[4] ? 257 : 1;
+        let low = 0, high = bins.length - 1, sum = 0;
+        for (; low < bins.length - 1; low++) {
+          sum += bins[low];
+          if (sum > lowTarget) break;
         }
         sum = 0;
+        for (; high > 0; high--) {
+          sum += bins[high];
+          if (sum > highTarget) break;
+        }
+        if (high > low) for (let value = 0; value < 256; value++) lookup[channel][value] = clampByteVal((value * scale - low) / (high - low) * 255);
+      }
+    } else if (token === "-equalize") {
+      const active = [channels.r, channels.g, channels.b, (!independent || channels.a) && image.hasAlpha];
+      for (let channel = 0; channel < 4; channel++) {
+        if (!active[channel]) continue;
+        const bins = histogram[4] ?? histogram[channel], scale = histogram[4] ? 257 : 1;
+        const black = bins[0];
+        if (count === black) continue;
+        let cumulative = 0, bin = 0;
         for (let value = 0; value < 256; value++) {
-          sum += histogram[channel][value];
-          if (sum >= highTarget) {
-            high = value;
-            break;
-          }
+          for (; bin <= value * scale; bin++) cumulative += bins[bin];
+          lookup[channel][value] = clampByteVal((cumulative - black) / (count - black) * 255);
         }
-        if (high > low) for (let value = 0; value < 256; value++) lookup[channel][value] = clampByteVal((value - low) / (high - low) * 255);
       }
     }
     return lookup;
@@ -5180,7 +5479,25 @@ function parseMagickAnalysisOperation(tokens, state, start) {
 function parseMagickPixelOperation(tokens, settings, start, signal) {
   const state = { ...settings }, token = tokens[start];
   let i = start, apply;
-  if (token === "-alpha") {
+  if (token === "-colorspace" || token === "-grayscale") {
+    const space = (tokens[++i] ?? "gray").toLowerCase();
+    apply = function* (image) {
+      if (!space.includes("gray") && !space.includes("grey") && space !== "rec709luma" && space !== "rec601luma") return image;
+      const out = new Uint8Array(image.data);
+      for (let idx = 0; idx < out.length; idx += 4) {
+        if (idx % 65536 === 0) yield;
+        const gray = clampByteVal(space === "rec601luma" ? 0.298839 * out[idx] + 0.586811 * out[idx + 1] + 0.11435 * out[idx + 2] : 0.212656 * out[idx] + 0.715158 * out[idx + 1] + 0.072186 * out[idx + 2]);
+        out[idx] = out[idx + 1] = out[idx + 2] = gray;
+      }
+      const { data16: ignored, ...metadata } = image;
+      return { ...metadata, data: out, space: "b-w", channels: image.hasAlpha ? 2 : 1 };
+    };
+  } else if (token === "-gamma") {
+    const gamma = Math.max(0.1, Number(tokens[++i] ?? 1));
+    const channels = state.channelExplicit ? state.channels : { r: true, g: true, b: true, a: true };
+    const lookup = [channels.r, channels.g, channels.b, channels.a].map((active) => Uint8Array.from({ length: 256 }, (_, value) => active ? clampByteVal(255 * Math.pow(value / 255, 1 / gamma)) : value));
+    apply = (image) => applyMagickLookup(image, lookup);
+  } else if (token === "-alpha") {
     const mode = (tokens[++i] ?? "on").toLowerCase();
     if (mode === "remove") {
       apply = function* (im) {
@@ -5244,10 +5561,10 @@ function parseMagickPixelOperation(tokens, settings, start, signal) {
     apply = (image) => applyMagickColorMatrixSteps(image, matrix, signal);
   } else if (token === "-opaque" || token === "+opaque") {
     const target = parseColor(tokens[++i] ?? "#000000");
-    apply = (image) => applyMagickOpaqueSteps(image, target, state.fill, state.fuzz, token === "+opaque", signal);
+    apply = (image) => applyMagickOpaqueSteps(image, target, state.fill, state.alphaFuzz, token === "+opaque", signal);
   } else if (token === "-transparent" || token === "+transparent") {
     const target = parseColor(tokens[++i] ?? "#ffffff");
-    apply = (image) => applyMagickTransparentSteps(image, target, state.fuzz, token === "+transparent", signal);
+    apply = (image) => applyMagickTransparentSteps(image, target, state.alphaFuzz, token === "+transparent", signal);
   } else if (token === "-evaluate") {
     const operation = tokens[++i] ?? "Add", value = tokens[++i] ?? "0";
     apply = (image) => applyMagickEvaluateSteps(image, operation, value, state.channels, signal);
@@ -5257,7 +5574,7 @@ function parseMagickPixelOperation(tokens, settings, start, signal) {
   } else if (token === "-sepia-tone" || token === "-solarize") {
     const value = tokens[++i] ?? (token === "-sepia-tone" ? "80%" : "50%");
     apply = (image) => token === "-sepia-tone" ? applyMagickSepiaToneSteps(image, value, signal) : applyMagickSolarizeSteps(image, value, signal);
-  } else if (token === "-posterize" || token === "-colors") {
+  } else if (token === "-posterize") {
     const levels = Number(tokens[++i] ?? 8);
     apply = (image) => applyMagickPosterizeSteps(image, levels, signal);
   } else if (token === "-monochrome") {
@@ -5266,17 +5583,83 @@ function parseMagickPixelOperation(tokens, settings, start, signal) {
     };
   } else if (token === "-modulate") {
     const parts = (tokens[++i] ?? "100,100,100").split(",").map(Number);
-    const options = { brightness: (parts[0] ?? 100) / 100, saturation: (parts[1] ?? 100) / 100, hue: ((parts[2] ?? 100) - 100) * 1.8, lightness: 0 };
-    apply = (image) => modulateImageSteps(image, options);
+    const brightness = (parts[0] ?? 100) / 100, saturation = (parts[1] ?? 100) / 100, hueShift = ((parts[2] ?? 100) - 100) * 3 / 100;
+    apply = function* (image) {
+      const out = new Uint8Array(image.data);
+      for (let idx = 0; idx < out.length; idx += 4) {
+        if (idx % 65536 === 0) {
+          signal?.throwIfAborted();
+          yield;
+        }
+        const r = out[idx] / 255, g = out[idx + 1] / 255, b = out[idx + 2] / 255;
+        const max = Math.max(r, g, b), min = Math.min(r, g, b), delta = max - min;
+        const lightness = (max + min) / 2;
+        const sat = delta === 0 ? 0 : delta / (lightness <= 0.5 ? max + min : 2 - max - min);
+        let hue = delta === 0 ? 0 : max === r ? (g - b) / delta : max === g ? 2 + (b - r) / delta : 4 + (r - g) / delta;
+        hue = ((hue + hueShift) % 6 + 6) % 6;
+        const light = lightness * brightness;
+        const chroma = (1 - Math.abs(2 * light - 1)) * sat * saturation;
+        const secondary = chroma * (1 - Math.abs(hue % 2 - 1));
+        const offset = light - chroma / 2;
+        const red = hue < 1 || hue >= 5 ? chroma : hue < 2 || hue >= 4 ? secondary : 0;
+        const green = hue < 1 ? secondary : hue < 3 ? chroma : hue < 4 ? secondary : 0;
+        const blue = hue < 2 ? 0 : hue < 3 ? secondary : hue < 5 ? chroma : secondary;
+        out[idx] = clampByteVal((red + offset) * 255);
+        out[idx + 1] = clampByteVal((green + offset) * 255);
+        out[idx + 2] = clampByteVal((blue + offset) * 255);
+      }
+      const { data16: ignored, ...metadata } = image;
+      return { ...metadata, data: out };
+    };
   } else if (token === "-brightness-contrast") {
-    const geometry = parseMagickGeometry(tokens[++i] ?? "0x0"), slope = 1 + (geometry.height ?? 0) / 100, offset = (geometry.width ?? 0) / 100 * 255;
-    apply = (image) => linearImageSteps(image, [slope], [offset]);
+    const [brightness = 0, contrast = 0] = (tokens[++i] ?? "0x0").split("x").map((value) => parseFloat(value) || 0);
+    const slope = contrast < 0 ? 1 + contrast / 100 : 100 / Math.max(1e-12, 100 - contrast);
+    const offset = (brightness / 100 * 255 - 127.5) * slope + 127.5;
+    const channels = state.channelExplicit ? state.channels : { r: true, g: true, b: true, a: true };
+    apply = function* (image) {
+      const out = new Uint8Array(image.data);
+      const mask = [channels.r, channels.g, channels.b, channels.a && image.hasAlpha];
+      for (let idx = 0; idx < out.length; idx += 4) {
+        if (idx % 65536 === 0) yield;
+        for (let channel = 0; channel < 4; channel++) {
+          if (mask[channel]) out[idx + channel] = clampByteVal(out[idx + channel] * slope + offset);
+        }
+      }
+      return { ...image, data: out };
+    };
   } else if (token === "-threshold") {
     const raw = tokens[++i] ?? "50%", value = Math.round(raw.endsWith("%") ? parseFloat(raw) / 100 * 255 : parseFloat(raw));
     apply = (image) => thresholdImageSteps(image, value, true);
-  } else if (token === "-tint" || token === "-colorize") {
-    i++;
-    apply = (image) => tintImageSteps(image, state.fill);
+  } else if (token === "-colorize") {
+    const strength = parseFloat(tokens[++i] ?? "100") / 100;
+    const fill = [state.fill.r, state.fill.g, state.fill.b];
+    apply = function* (image) {
+      const out = new Uint8Array(image.data);
+      for (let idx = 0; idx < out.length; idx += 4) {
+        if (idx % 65536 === 0) yield;
+        for (let channel = 0; channel < 3; channel++) {
+          out[idx + channel] = clampByteVal(out[idx + channel] * (1 - strength) + fill[channel] * strength);
+        }
+      }
+      return { ...image, data: out };
+    };
+  } else if (token === "-tint") {
+    const strength = parseFloat(tokens[++i] ?? "100") / 100;
+    const fill = [state.fill.r, state.fill.g, state.fill.b];
+    const intensity = 0.212656 * state.fill.r + 0.715158 * state.fill.g + 0.072186 * state.fill.b;
+    const vector = fill.map((channel) => channel * strength - intensity);
+    apply = function* (image) {
+      const out = new Uint8Array(image.data);
+      for (let idx = 0; idx < out.length; idx += 4) {
+        if (idx % 65536 === 0) yield;
+        for (let channel = 0; channel < 3; channel++) {
+          const value = out[idx + channel];
+          const weight = value / 255 - 0.5;
+          out[idx + channel] = clampByteVal(value + vector[channel] * (1 - 4 * weight * weight));
+        }
+      }
+      return { ...image, data: out };
+    };
   } else if (token === "-negate" || token === "+negate") {
     const onlyGray = token === "+negate";
     const ch = state.channelExplicit ? state.channels : { r: true, g: true, b: true, a: false };
@@ -5529,10 +5912,16 @@ function* evaluatePipelineTokensSteps(tokens, files, state, parentStack = [], st
     } else if (analysisOperation) {
       i = analysisOperation.end;
       stack = yield* mapSteps(stack, function* (image) {
-        const histogram = Array.from({ length: 4 }, () => new Float64Array(256));
+        const histogram = Array.from({ length: analysisOperation.luminance ? 5 : 4 }, (_, channel) => new Float64Array(channel === 4 ? 65536 : 256));
         yield* accumulateMagickHistogram(image.data, histogram);
         return yield* applyMagickLookup(image, analysisOperation.lookup(histogram, image));
       });
+    } else if (t === "-colors") {
+      const colors = Number(tokens[++i]);
+      stack = yield* mapSteps(stack, (image) => {
+        const { data16: ignored, ...pixels } = image;
+        return applyMagickRasterSteps(pixels, quantizePixelSteps(image.data.length, colors), signal);
+      });
     } else if (pixelOperation) {
       i = pixelOperation.end;
       stack = yield* mapSteps(stack, pixelOperation.apply);
@@ -5756,18 +6145,6 @@ function* evaluatePipelineTokensSteps(tokens, files, state, parentStack = [], st
       stack = yield* mapSteps(stack, function* (im) {
         return yield* applyExifOrientationSteps(im);
       });
-    } else if (t === "-colorspace" || t === "-grayscale") {
-      const cs = (tokens[++i] ?? "gray").toLowerCase();
-      if (cs.includes("gray") || cs.includes("grey") || cs === "rec709luma" || cs === "rec601luma") {
-        stack = yield* mapSteps(stack, function* (im) {
-          return yield* grayscaleImageSteps(im);
-        });
-      }
-    } else if (t === "-gamma") {
-      const gammaVal = Math.max(0.1, Number(tokens[++i] ?? 1));
-      stack = yield* mapSteps(stack, function* (im) {
-        return yield* gammaImageSteps(im, gammaVal, gammaVal);
-      });
     } else if (t === "-raise" || t === "+raise") {
       const g = parseMagickGeometry(tokens[++i] ?? "4");
       const bw = Math.max(1, Math.round(g.width ?? 4));
@@ -5970,14 +6347,19 @@ function* evaluatePipelineTokensSteps(tokens, files, state, parentStack = [], st
       }
       stack = [appended];
     } else if (t === "-flatten" || t === "-mosaic" || t === "-layers" && ["flatten", "merge", "mosaic"].includes((tokens[i + 1] ?? "").toLowerCase())) {
+      const flatten = t === "-flatten" || t === "-layers" && tokens[i + 1]?.toLowerCase() === "flatten";
       if (t === "-layers")
         i++;
       if (stack.length > 0) {
         const oldStack = stack;
-        const maxW = Math.max(...oldStack.map((im) => im.width));
-        const maxH = Math.max(...oldStack.map((im) => im.height));
+        const maxW = flatten ? oldStack[0].width : Math.max(...oldStack.map((im) => im.width));
+        const maxH = flatten ? oldStack[0].height : Math.max(...oldStack.map((im) => im.height));
         const canvas = yield* createSolidRgbaImageSteps(maxW, maxH, state.background);
-        const layers = oldStack.map((im) => rgbaToCompositeLayer(im, 0, 0, state.compose));
+        const layers = [];
+        for (const im of oldStack) {
+          const clipped = im.width > maxW || im.height > maxH ? yield* extractImageSteps(im, { left: 0, top: 0, width: Math.min(im.width, maxW), height: Math.min(im.height, maxH) }) : im;
+          layers.push(rgbaToCompositeLayer(clipped, 0, 0, state.compose));
+        }
         const flattened = yield* compositeImageSteps(canvas, layers);
         if (canvas.data.buffer !== flattened.data.buffer) detachRgbaBuffer(canvas.data);
         for (const im of oldStack) {
@@ -6227,7 +6609,7 @@ async function morphStoredMagickImage(image, backend, plan, signal) {
       images.push({ ...image, position });
     } else {
       const source = images[step.source];
-      images.push(await transformStoredMagickRaster(source, backend, morphologyPixelSteps(source, plan.rx, plan.ry, step.mode), signal));
+      images.push(await transformStoredMagickRaster(source, backend, morphologyPixelSteps(source, plan.rows, step.mode), signal));
     }
   }
   return images.at(-1);
@@ -6276,7 +6658,8 @@ async function transformStoredMagickCoordinates(image, backend, token, geometry,
   return { ...image, position, width, height, ...token === "-splice" ? { hasAlpha: true } : {} };
 }
 async function compositeStoredMagick(base, overlay, backend, signal, left, top, mode, args, generic = false, inPlace = false, montageRounding = false) {
-  let hasAlpha = base.hasAlpha || !generic && !magickCompositeMode(mode).delegated;
+  const compositeMode = magickCompositeMode(mode);
+  let hasAlpha = base.hasAlpha || !generic && !compositeMode.delegated && !["difference", "src", "source", "copy", "xor"].includes(compositeMode.name);
   const position = inPlace ? base.position : backend.storage.allocate(base.width * base.height * 4);
   for (let start = 0; !inPlace && start < base.width * base.height * 4; start += 16384) {
     await yieldTurn9(signal);
@@ -6477,6 +6860,11 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
         });
         continue;
       }
+      if (!operandsOnly && token === "-colors") {
+        const colors = Number(tokens[++i]);
+        steps.push(async (image, backend) => image ? transformStoredMagickRaster(image, backend, quantizePixelSteps(image.width * image.height * 4, colors), signal) : void 0);
+        continue;
+      }
       const pixelOperation = operandsOnly ? void 0 : parseMagickPixelOperation(tokens, state, i, signal);
       if (pixelOperation) {
         i = pixelOperation.end;
@@ -6499,7 +6887,7 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
         i = analysisOperation.end;
         steps.push(async (image, backend) => {
           if (!image) return;
-          const histogram = Array.from({ length: 4 }, () => new Float64Array(256)), size = image.width * image.height * 4;
+          const histogram = Array.from({ length: analysisOperation.luminance ? 5 : 4 }, (_, channel) => new Float64Array(channel === 4 ? 65536 : 256)), size = image.width * image.height * 4;
           for (let offset = 0; offset < size; offset += 16384) {
             if (offset % 1048576 === 0) await yieldTurn9(signal);
             await drainSteps(accumulateMagickHistogram(await backend.storage.read(image.position + offset, Math.min(16384, size - offset)), histogram), signal);
@@ -6510,6 +6898,7 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
         continue;
       }
       if (!operandsOnly && (["-append", "+append", "-flatten", "-mosaic", "-composite"].includes(token) || token === "-layers" && ["flatten", "merge", "mosaic"].includes((tokens[i + 1] ?? "").toLowerCase()))) {
+        const flatten = token === "-flatten" || token === "-layers" && tokens[i + 1]?.toLowerCase() === "flatten";
         if (token === "-layers") i++;
         const settings = { ...state };
         stackStep(async (stack, backend) => {
@@ -6534,7 +6923,7 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
           const append = token.endsWith("append"), vertical = token === "-append";
           if (append && stack.length === 1) return stack;
           let width = 0, height = 0;
-          for (let n = 0; n < stack.length; n++) {
+          for (let n = 0; n < (flatten ? 1 : stack.length); n++) {
             await yieldTurn9(signal);
             const frame = await stack.get(n);
             width = append && !vertical ? width + frame.width : Math.max(width, frame.width);
@@ -6544,7 +6933,17 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
           let cursor = 0;
           for (let n = 0; n < stack.length; n++) {
             const frame = await stack.get(n), offset = resolveGravityOffset(vertical ? width - frame.width : 0, vertical ? 0 : height - frame.height, settings.gravity);
-            result = await compositeStoredMagick(result, frame, backend, signal, append ? vertical ? offset.left : cursor : 0, append ? vertical ? cursor : offset.top : 0, append ? "over" : settings.compose, void 0, !append, true);
+            if (append) {
+              const left = vertical ? offset.left : cursor, top = vertical ? cursor : offset.top;
+              for (let y = 0; y < frame.height; y++) {
+                for (let x = 0; x < frame.width; x += 4096) {
+                  await yieldTurn9(signal);
+                  const pixels = await backend.storage.read(frame.position + (y * frame.width + x) * 4, Math.min(4096, frame.width - x) * 4);
+                  await backend.storage.write(result.position + ((top + y) * width + left + x) * 4, pixels);
+                }
+              }
+              result = { ...result, hasAlpha: result.hasAlpha || frame.hasAlpha };
+            } else result = await compositeStoredMagick(result, frame, backend, signal, 0, 0, settings.compose, void 0, true, true);
             cursor += vertical ? frame.height : frame.width;
           }
           stack.length = 0;
@@ -6760,12 +7159,6 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
       } else if (!operandsOnly && token === "-rotate") {
         const angle = Number(tokens[++i] ?? 0), background = state.background;
         transform(() => ({ kind: "rotate", angle, background }));
-      } else if (!operandsOnly && token === "-gamma") {
-        const gamma = Math.max(0.1, Number(tokens[++i] ?? 1));
-        transform(() => ({ kind: "gamma", gamma, gammaOut: gamma }));
-      } else if (!operandsOnly && ["-colorspace", "-grayscale"].includes(token)) {
-        const space = (tokens[++i] ?? "gray").toLowerCase();
-        if (space.includes("gray") || space.includes("grey") || space === "rec709luma" || space === "rec601luma") transform(() => ({ kind: "grayscale" }));
       } else if (!operandsOnly && ["-blur", "-gaussian-blur", "-sharpen", "-unsharp"].includes(token)) {
         const geometry = parseMagickGeometry(tokens[++i] ?? "0x1"), sigma = Math.max(0.3, geometry.height ?? geometry.width ?? 1);
         const kind = token === "-blur" || token === "-gaussian-blur" ? "blur" : "sharpen";