@poe-platform/safe-bash 0.1.845 → 0.1.846

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

@@ -1,7 +1,90 @@
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
-// packages/safe-bash-command-imagemagick/src/deskew.ts
+// packages/safe-bash-command-imagemagick/src/raw-rgb.ts
+function rawRgbInput(width, height, depth, endian, byteLength) {
+  if (depth !== 8 && depth !== 16) throw new Error(`unsupported RGB input depth '${depth}'`);
+  const length = width * height * 3 * (depth / 8);
+  if (!Number.isSafeInteger(length) || length > byteLength) throw new Error("unexpected end-of-file in RGB input");
+  const header = new TextEncoder().encode(`P6
+${width} ${height}
+${depth === 8 ? 255 : 65535}
+`);
+  const swap = depth === 16 && endian !== "msb";
+  return {
+    size: header.length + length,
+    *read(position, size) {
+      const bytes = new Uint8Array(size);
+      const headerLength = Math.max(0, Math.min(size, header.length - position));
+      bytes.set(header.subarray(position, position + headerLength));
+      if (headerLength < size) {
+        const start = Math.max(0, position - header.length), end = start + size - headerLength;
+        const alignedStart = swap ? start - start % 2 : start;
+        const alignedEnd = swap ? end + end % 2 : end;
+        for (let offset = alignedStart; offset < alignedEnd; offset += 8192) {
+          const length2 = Math.min(8192, alignedEnd - offset);
+          const input = yield { position: offset, length: length2 };
+          if (input.length !== length2) throw new Error("unexpected end-of-file in RGB input");
+          for (let i = Math.max(start, offset); i < Math.min(end, offset + length2); i++) {
+            bytes[headerLength + i - start] = input[(swap ? i ^ 1 : i) - offset];
+          }
+        }
+      }
+      return bytes;
+    }
+  };
+}
+
+// packages/safe-bash-command-imagemagick/src/raw-output.ts
+import { encodeImage as encodeRaster, encodeStoredImage as encodeStoredRaster } from "../image-ast/portable.js";
 import { yieldTurn } from "../safe-bash-contracts/yield.js";
+function isRawCoder(format) {
+  return format === "rgb" || format === "rgba" || format === "bgr" || format === "bgra" || format === "gray";
+}
+function encodeImage(image, options) {
+  const format = options.format;
+  if (!isRawCoder(format)) return encodeRaster(image, { ...options, format });
+  const channels = format === "gray" ? 1 : format.endsWith("a") ? 4 : 3;
+  const depth = (image.bitsPerSample ?? 8) > 8 ? 16 : 8;
+  const data = new Uint8Array(image.width * image.height * channels * depth / 8);
+  const view = new DataView(data.buffer), samples = image.data16 ?? image.data;
+  const scale = image.data16 ? 65535 : 255, maximum = depth === 16 ? 65535 : 255;
+  let offset = 0;
+  for (let pixel = 0; pixel < image.width * image.height; pixel++) {
+    for (let channel = 0; channel < channels; channel++) {
+      const index = format.startsWith("bgr") && channel < 3 ? 2 - channel : channel;
+      const value = format === "gray" ? 0.212656 * samples[pixel * 4] + 0.715158 * samples[pixel * 4 + 1] + 0.072186 * samples[pixel * 4 + 2] : channel === 3 && !image.hasAlpha ? scale : samples[pixel * 4 + index];
+      const quantum = Math.round(value * maximum / scale);
+      if (depth === 16) view.setUint16(offset, quantum, options.endian === void 0 || options.endian === "lsb");
+      else data[offset] = quantum;
+      offset += depth / 8;
+    }
+  }
+  return { data, format: "raw", channels };
+}
+async function* encodeStoredImage(image, storage, signal, options) {
+  if (!isRawCoder(options.format)) return yield* encodeStoredRaster(image, storage, signal, { ...options, format: options.format });
+  let size = 0, channels = 0;
+  for (let pixel = 0; pixel < image.width * image.height; pixel += 4096) {
+    await yieldTurn(signal);
+    const count = Math.min(4096, image.width * image.height - pixel);
+    const data = new Uint8Array(await storage.read(image.position + pixel * 4, count * 4, { signal }));
+    if (data.length !== count * 4) throw new Error("Truncated raw pixel storage");
+    let data16;
+    if (image.storedData16) {
+      const bytes = await storage.read(image.storedData16.position + pixel * 8, count * 8, { signal });
+      if (bytes.length !== count * 8) throw new Error("Truncated raw sample storage");
+      data16 = new Uint16Array(new Uint8Array(bytes).buffer);
+    }
+    const encoded = encodeImage({ ...image, width: count, height: 1, data, ...data16 ? { data16 } : {} }, options);
+    size += encoded.data.length;
+    channels = encoded.channels;
+    yield encoded.data;
+  }
+  return { format: "raw", width: image.width, height: image.height, channels, premultiplied: false, size };
+}
+
+// packages/safe-bash-command-imagemagick/src/deskew.ts
+import { yieldTurn as yieldTurn2 } from "../safe-bash-contracts/yield.js";
 function* deskewAngle(width, height, spec) {
   const threshold = Number(spec.endsWith("%") ? spec.slice(0, -1) : spec) * (spec.endsWith("%") ? 255 / 100 : 255 / 65535);
   if (!spec || !Number.isFinite(threshold)) throw new Error("Invalid deskew threshold");
@@ -80,7 +163,7 @@ async function storedDeskewAngle(image, storage, spec, signal) {
   let next = steps.next();
   while (!next.done) {
     if (!next.value) {
-      await yieldTurn(signal);
+      await yieldTurn2(signal);
       next = steps.next();
     } else {
       const { position, length } = next.value;
@@ -105,7 +188,7 @@ function deskewPlan(image, radians) {
 }
 
 // packages/safe-bash-command-imagemagick/src/raster-backing.ts
-import { yieldTurn as yieldTurn2 } from "../safe-bash-contracts/yield.js";
+import { yieldTurn as yieldTurn3 } from "../safe-bash-contracts/yield.js";
 var RasterBackingCache = class {
   constructor(storage, signal) {
     this.storage = storage;
@@ -118,14 +201,14 @@ var RasterBackingCache = class {
   async allocate(length) {
     const region = { position: this.storage.allocate(length), length }, zero = new Uint8Array(Math.min(4096, length));
     for (let offset = 0; offset < length; offset += zero.length) {
-      if (offset % 65536 === 0) await yieldTurn2(this.signal);
+      if (offset % 65536 === 0) await yieldTurn3(this.signal);
       await this.storage.write(region.position + offset, zero.subarray(0, Math.min(zero.length, length - offset)), { signal: this.signal });
     }
     return region;
   }
   async page(region, offset) {
     this.signal.throwIfAborted();
-    if (++this.work % 16384 === 0) await yieldTurn2(this.signal);
+    if (++this.work % 16384 === 0) await yieldTurn3(this.signal);
     const start = Math.floor(offset / 4096) * 4096, key = region.position + ":" + start;
     let page = this.pages.get(key);
     if (page) {
@@ -181,7 +264,7 @@ var RasterBackingCache = class {
 };
 
 // packages/safe-bash-command-imagemagick/src/floodfill.ts
-import { yieldTurn as yieldTurn3 } from "../safe-bash-contracts/yield.js";
+import { yieldTurn as yieldTurn4 } from "../safe-bash-contracts/yield.js";
 function matchesAlphaFloodfill(r, g, b, a, refR, refG, refB, refA, fuzz) {
   return (a - refA) ** 2 + ((r - refR) ** 2 + (g - refG) ** 2 + (b - refB) ** 2) * (a / 255) * (refA / 255) / 3 <= 2 * fuzz ** 2;
 }
@@ -206,7 +289,7 @@ async function floodfillStoredImage(image, storage, seedX, seedY, target, replac
   await cache.flush();
   const position = storage.allocate(count * 4);
   for (let start2 = 0; start2 < count; start2 += 1024) {
-    await yieldTurn3(signal);
+    await yieldTurn4(signal);
     const length = Math.min(1024, count - start2), pixels = new Uint8Array(await storage.read(image.position + start2 * 4, length * 4, { signal }));
     const flags = await storage.read(visited.position + start2, length, { signal });
     if (pixels.length !== length * 4 || flags.length !== length) throw new Error("Truncated floodfill pixels");
@@ -342,6 +425,45 @@ function* extendEdgePixelSteps(source, width, height) {
   }
 }
 
+// packages/safe-bash-command-imagemagick/src/bilevel-kernel.ts
+function* bilevelPixelSteps(count, highDepth) {
+  const histogram = new Float64Array(65536), sampleBytes = highDepth ? 2 : 1;
+  let low = 0, high = 65535;
+  for (let pass = 0; pass < 2; pass++) {
+    for (let first = 0; first < count; first += 4096) {
+      yield;
+      const size = Math.min(4096, count - first);
+      const bytes = yield { kind: "read", position: first * 4 * sampleBytes, length: size * 4 * sampleBytes };
+      if (!bytes || bytes.length !== size * 4 * sampleBytes) throw new Error("Truncated bilevel pixels");
+      const samples = highDepth ? new Uint16Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 2) : bytes;
+      const data = pass ? new Uint8Array(size * 4) : void 0;
+      for (let pixel = 0; pixel < size; pixel++) {
+        const offset = pixel * 4;
+        const gray = Math.round((highDepth ? 1 : 257) * (0.212656 * samples[offset] + 0.715158 * samples[offset + 1] + 0.072186 * samples[offset + 2]));
+        if (!data) histogram[gray]++;
+        else {
+          const value = gray > (high > low ? (low + high) / 2 : 65535 / 2) ? 255 : 0;
+          data.fill(value, offset, offset + 3);
+          data[offset + 3] = 255;
+        }
+      }
+      if (data) yield { kind: "write", position: first * 4, data };
+    }
+    if (pass === 0) {
+      let sum = 0;
+      for (; low < 65535; low++) {
+        sum += histogram[low];
+        if (sum > 0.02 * count) break;
+      }
+      sum = 0;
+      for (; high > 0; high--) {
+        sum += histogram[high];
+        if (sum > 0.01 * count) break;
+      }
+    }
+  }
+}
+
 // packages/safe-bash-command-imagemagick/src/compare-phash.ts
 function* perceptualHashSteps(info, image) {
   const weights = Array.from({ length: 9 }, (_, i) => {
@@ -1510,7 +1632,7 @@ function* pointResizePixelSteps(image, width, height, sample = false) {
 
 // packages/safe-bash-command-imagemagick/src/trim.ts
 import { extractImageSteps, transformStoredImage } from "../image-ast/portable.js";
-import { yieldTurn as yieldTurn4 } from "../safe-bash-contracts/yield.js";
+import { yieldTurn as yieldTurn5 } from "../safe-bash-contracts/yield.js";
 function* trimBounds(width, height, fuzz) {
   const corners = [];
   for (const pixel of [0, width - 1, (height - 1) * width, width * height - 1]) {
@@ -1574,7 +1696,7 @@ async function trimStoredMagick(image, storage, fuzz, signal) {
   let next = steps.next();
   while (!next.done) {
     if (!next.value) {
-      await yieldTurn4(signal);
+      await yieldTurn5(signal);
       next = steps.next();
     } else {
       const { position: position2, length } = next.value;
@@ -1881,7 +2003,7 @@ function* quantizePixelSteps(length, requested, grayscale = false) {
 }
 
 // packages/safe-bash-command-imagemagick/src/connected-components.ts
-import { yieldTurn as yieldTurn5 } from "../safe-bash-contracts/yield.js";
+import { yieldTurn as yieldTurn6 } from "../safe-bash-contracts/yield.js";
 function* labelSteps(width, height, connectivity) {
   const components = [];
   for (let seed = 0; seed < width * height; seed++) {
@@ -1978,7 +2100,7 @@ async function connectedComponentsStored(image, storage, connectivity, verbose,
   while (!next.done) {
     const request = next.value;
     if (!request) {
-      await yieldTurn5(signal);
+      await yieldTurn6(signal);
       next = steps.next(0);
       continue;
     }
@@ -1993,7 +2115,7 @@ async function connectedComponentsStored(image, storage, connectivity, verbose,
     const report = reportSteps(next.value);
     let part = report.next();
     while (!part.done) {
-      await yieldTurn5(signal);
+      await yieldTurn6(signal);
       part = report.next();
     }
     text = part.value;
@@ -2001,7 +2123,7 @@ async function connectedComponentsStored(image, storage, connectivity, verbose,
   await cache.flush();
   const position = storage.allocate(size);
   for (let offset = 0; offset < size; offset += 4096) {
-    await yieldTurn5(signal);
+    await yieldTurn6(signal);
     const bytes = new Uint8Array(await storage.read(regions.labels.position + offset, Math.min(4096, size - offset), { signal })), view = new DataView(bytes.buffer);
     for (let i = 0; i < bytes.length; i += 4) {
       const value = Math.round((view.getUint32(i, true) - 1) / 257);
@@ -2158,7 +2280,7 @@ async function withImageInputs(input, stdinBytes, signal, run) {
 
 // packages/safe-bash-command-imagemagick/src/text-output.ts
 import { IntegerTable } from "@poe-platform/safe-fs/storage";
-import { yieldTurn as yieldTurn6 } from "../safe-bash-contracts/yield.js";
+import { yieldTurn as yieldTurn7 } from "../safe-bash-contracts/yield.js";
 var hex = (value) => value.toString(16).toUpperCase().padStart(2, "0");
 function pixelEnumerationLine(x, y, r, g, b, a) {
   return `${x},${y}: (${r},${g},${b},${a})  #${hex(r)}${hex(g)}${hex(b)}${a < 255 ? hex(a) : ""}  srgba(${r},${g},${b},${(a / 255).toFixed(3)})`;
@@ -2173,7 +2295,7 @@ async function* storedPixelEnumeration(image, storage, signal) {
 `;
   const size = image.width * image.height * 4;
   for (let start = 0; start < size; start += 16384) {
-    await yieldTurn6(signal);
+    await yieldTurn7(signal);
     const bytes = await storage.read(image.position + start, Math.min(16384, size - start));
     const original = (image.magickColorspace === "HSL" || image.magickColorspace === "HSB" || image.magickColorspace === "HWB" || image.magickColorspace === "XYZ" || image.magickColorspace === "YCbCr" || image.magickColorspace === "YUV") && image.storedData16 ? await storage.read(image.storedData16.position + start * 2, bytes.length * 2) : void 0;
     const data16 = original ? new Uint16Array(original.buffer.slice(original.byteOffset, original.byteOffset + original.byteLength)) : void 0;
@@ -2195,7 +2317,7 @@ async function* storedHistogram(image, storage, signal) {
   const sampleOffsets = (image.magickColorspace === "HWB" || image.magickColorspace === "XYZ" || image.magickColorspace === "YCbCr" || image.magickColorspace === "YUV") && image.storedHueSamples !== void 0 ? new IntegerTable(storage, 128) : void 0;
   let unique = 0;
   for (let start = 0; start < size; start += 16384) {
-    await yieldTurn6(signal);
+    await yieldTurn7(signal);
     const bytes = await storage.read(image.position + start, Math.min(16384, size - start));
     const original = (image.magickColorspace === "HSL" || image.magickColorspace === "HSB" || image.magickColorspace === "HWB" || image.magickColorspace === "XYZ" || image.magickColorspace === "YCbCr" || image.magickColorspace === "YUV") && image.storedData16 ? await storage.read(image.storedData16.position + start * 2, bytes.length * 2) : void 0;
     const data16 = original ? new Uint16Array(original.buffer.slice(original.byteOffset, original.byteOffset + original.byteLength)) : void 0;
@@ -2209,7 +2331,7 @@ async function* storedHistogram(image, storage, signal) {
     }
   }
   for (let index = 0; index < unique; index++) {
-    if (index % 128 === 0) await yieldTurn6(signal);
+    if (index % 128 === 0) await yieldTurn7(signal);
     const key = await order.get(BigInt(index));
     const samples = sampleOffsets ? await storage.read(image.storedHueSamples + Number(await sampleOffsets.get(BigInt(index))) * 8, 32) : void 0;
     const hueSamples = samples ? Array.from(new Float64Array(samples.buffer.slice(samples.byteOffset, samples.byteOffset + samples.byteLength))) : void 0;
@@ -2254,7 +2376,7 @@ async function* encodeText(parts, signal) {
 
 // packages/safe-bash-command-imagemagick/src/stored-stack.ts
 import { IntegerTable as IntegerTable2 } from "@poe-platform/safe-fs/storage";
-import { yieldTurn as yieldTurn7 } from "../safe-bash-contracts/yield.js";
+import { yieldTurn as yieldTurn8 } from "../safe-bash-contracts/yield.js";
 var magickInput = /* @__PURE__ */ Symbol("magickInput");
 var StoredImageStack = class {
   constructor(storage, signal, parent) {
@@ -2263,6 +2385,7 @@ var StoredImageStack = class {
     this.frames = parent?.frames ?? /* @__PURE__ */ new Map();
     this.records = parent?.records ?? /* @__PURE__ */ new WeakMap();
     this.delayRegions = parent?.delayRegions ?? /* @__PURE__ */ new WeakMap();
+    this.iccRegions = parent?.iccRegions ?? /* @__PURE__ */ new WeakMap();
     this.indices = new IntegerTable2(storage, 128);
   }
   storage;
@@ -2271,6 +2394,7 @@ var StoredImageStack = class {
   frames;
   records;
   delayRegions;
+  iccRegions;
   length = 0;
   cache(position, image) {
     this.frames.delete(position);
@@ -2281,12 +2405,12 @@ var StoredImageStack = class {
   async retain(image) {
     const known = this.records.get(image);
     if (known !== void 0) return known;
-    const { delay, storedDelay, ...metadata } = image, source = storedDelay ?? delay;
+    const { delay, storedDelay, icc, ...metadata } = image, source = storedDelay ?? delay;
     let delays = source ? this.delayRegions.get(source) : void 0;
     if (source && !delays) {
       delays = { position: this.storage.allocate(source.length * 9), length: source.length };
       for (let start = 0; start < source.length; start += 512) {
-        await yieldTurn7(this.signal);
+        await yieldTurn8(this.signal);
         const count = Math.min(512, source.length - start), bytes = new Uint8Array(count * 9), view = new DataView(bytes.buffer);
         for (let i = 0; i < count; i++) {
           const value = storedDelay ? await storedDelay.at(start + i, { signal: this.signal }) : delay[start + i];
@@ -2299,11 +2423,20 @@ var StoredImageStack = class {
       }
       this.delayRegions.set(source, delays);
     }
-    const record = { image: metadata, ...image[magickInput] ? { source: image[magickInput] } : {}, ...delays ? { delays } : {} };
+    let profile = icc ? this.iccRegions.get(icc) : void 0;
+    if (icc && !profile) {
+      profile = { position: this.storage.allocate(icc.length), length: icc.length };
+      for (let offset = 0; offset < icc.length; offset += 4096) {
+        await yieldTurn8(this.signal);
+        await this.storage.write(profile.position + offset, icc.subarray(offset, offset + 4096));
+      }
+      this.iccRegions.set(icc, profile);
+    }
+    const record = { image: metadata, ...profile ? { icc: profile } : {}, ...image[magickInput] ? { source: image[magickInput] } : {}, ...delays ? { delays } : {} };
     const text = JSON.stringify(record), encoder = new TextEncoder(), position = this.storage.allocate(8);
     let size = 0;
     for (let offset = 0; offset < text.length; ) {
-      await yieldTurn7(this.signal);
+      await yieldTurn8(this.signal);
       const bytes = new Uint8Array(4096), { read, written } = encoder.encodeInto(text.slice(offset, offset + 4097), bytes);
       await this.storage.write(this.storage.allocate(written), bytes.subarray(0, written));
       offset += read;
@@ -2326,11 +2459,20 @@ var StoredImageStack = class {
     const decoder = new TextDecoder();
     let text = "";
     for (let offset = 0; offset < size; offset += 4096) {
-      await yieldTurn7(this.signal);
+      await yieldTurn8(this.signal);
       text += decoder.decode(await this.storage.read(position + 8 + offset, Math.min(4096, size - offset)), { stream: true });
     }
     const record = JSON.parse(text + decoder.decode());
     const image = { ...record.image, ...record.source ? { [magickInput]: record.source } : {} };
+    if (record.icc) {
+      const icc = new Uint8Array(record.icc.length);
+      for (let offset = 0; offset < icc.length; offset += 4096) {
+        await yieldTurn8(this.signal);
+        icc.set(await this.storage.read(record.icc.position + offset, Math.min(4096, icc.length - offset)), offset);
+      }
+      Object.assign(image, { icc });
+      this.iccRegions.set(icc, record.icc);
+    }
     if (record.delays) {
       const region = record.delays, storage = this.storage, signal = this.signal;
       const reader = { length: region.length, async at(index, options) {
@@ -2375,12 +2517,12 @@ var StoredImageStack = class {
     const removed = new IntegerTable2(this.storage, 128);
     let work = 0;
     for (const index of indices) if (index >= 0 && index < this.length) {
-      if (++work % 128 === 0) await yieldTurn7(this.signal);
+      if (++work % 128 === 0) await yieldTurn8(this.signal);
       await removed.set(BigInt(index), 1n);
     }
     let next = 0;
     for (let index = 0; index < this.length; index++) {
-      if (index % 128 === 0) await yieldTurn7(this.signal);
+      if (index % 128 === 0) await yieldTurn8(this.signal);
       if (await removed.get(BigInt(index))) continue;
       if (next !== index) await this.indices.set(BigInt(next), await this.indices.get(BigInt(index)));
       next++;
@@ -2390,11 +2532,11 @@ var StoredImageStack = class {
 };
 
 // packages/safe-bash-command-imagemagick/src/remap.ts
-import { yieldTurn as yieldTurn8 } from "../safe-bash-contracts/yield.js";
+import { yieldTurn as yieldTurn9 } from "../safe-bash-contracts/yield.js";
 async function remapStoredImage(image, paletteImage, storage, dither, signal) {
   const palette = [], seen = /* @__PURE__ */ new Set();
   for (let offset = 0; offset < paletteImage.width * paletteImage.height * 4 && palette.length < 256; offset += 4096) {
-    await yieldTurn8(signal);
+    await yieldTurn9(signal);
     const length = Math.min(4096, paletteImage.width * paletteImage.height * 4 - offset), bytes = await storage.read(paletteImage.position + offset, length, { signal });
     if (bytes.length !== length) throw new Error("Truncated remap palette");
     for (let i = 0; i < length && palette.length < 256; i += 4) {
@@ -2409,7 +2551,7 @@ async function remapStoredImage(image, paletteImage, storage, dither, signal) {
   const count = image.width * image.height, cache = new RasterBackingCache(storage, signal);
   const errors = dither ? { position: storage.allocate(count * 16), length: count * 16 } : void 0;
   if (errors) for (let start = 0; start < count; start += 1024) {
-    await yieldTurn8(signal);
+    await yieldTurn9(signal);
     const length = Math.min(1024, count - start), pixels = await storage.read(image.position + start * 4, length * 4, { signal });
     if (pixels.length !== length * 4) throw new Error("Truncated remap pixels");
     const bytes = new Uint8Array(length * 16), view = new DataView(bytes.buffer);
@@ -2418,7 +2560,7 @@ async function remapStoredImage(image, paletteImage, storage, dither, signal) {
   }
   const position = storage.allocate(count * 4);
   for (let start = 0; start < count; start += 1024) {
-    await yieldTurn8(signal);
+    await yieldTurn9(signal);
     const length = Math.min(1024, count - start), pixels = new Uint8Array(await storage.read(image.position + start * 4, length * 4, { signal }));
     if (pixels.length !== length * 4) throw new Error("Truncated remap pixels");
     for (let i = 0; i < length; i++) {
@@ -3182,9 +3324,8 @@ function* embossPixelSteps(image, geometry) {
 }
 
 // packages/safe-bash-command-imagemagick/src/encoded-snapshots.ts
-import { encodeStoredImage } from "../image-ast/portable.js";
 import { IntegerTable as IntegerTable3 } from "@poe-platform/safe-fs/storage";
-import { yieldTurn as yieldTurn9 } from "../safe-bash-contracts/yield.js";
+import { yieldTurn as yieldTurn10 } from "../safe-bash-contracts/yield.js";
 var EncodedSnapshots = class {
   constructor(storage, signal) {
     this.storage = storage;
@@ -3214,7 +3355,7 @@ var EncodedSnapshots = class {
     };
     try {
       while (true) {
-        await yieldTurn9(this.signal);
+        await yieldTurn10(this.signal);
         const next = await encoder.next();
         if (next.done) {
           if (!next.value) throw new Error("Image encoding did not finish");
@@ -3226,7 +3367,7 @@ var EncodedSnapshots = class {
           new DataView(header.buffer).setFloat64(0, bytes.length, true);
           await this.storage.write(position, header);
           for (let start = 0; start < bytes.length; start += 4096) {
-            await yieldTurn9(this.signal);
+            await yieldTurn10(this.signal);
             await this.storage.write(position + 8 + start, bytes.subarray(start, start + 4096));
           }
           await this.buckets.set(hash, BigInt(position));
@@ -3265,7 +3406,7 @@ var EncodedSnapshots = class {
     const decoder = new TextDecoder();
     let text = "";
     for (let start = 0; start < size; start += 4096) {
-      await yieldTurn9(this.signal);
+      await yieldTurn10(this.signal);
       text += decoder.decode(await this.storage.read(position + 8 + start, Math.min(4096, size - start)), { stream: true });
     }
     const record = JSON.parse(text + decoder.decode());
@@ -3275,7 +3416,7 @@ var EncodedSnapshots = class {
   async find(path, hash) {
     let position = Number(await this.buckets.get(hash) ?? -1n);
     while (position >= 0) {
-      await yieldTurn9(this.signal);
+      await yieldTurn10(this.signal);
       const record = await this.record(position);
       if (record.path === path) return record;
       position = record.next ?? -1;
@@ -3333,13 +3474,13 @@ async function decodeFileImage(source, storage, filesystem, cwd, signal, options
 }
 
 // packages/safe-bash-command-imagemagick/src/compare-file.ts
-import { readImageMetadataFromSource, tryPdfMetadata, readImageMetadata, decodeImage, encodeStoredImage as encodeStoredImage2, tryImageFile, UnsupportedStoredResource as UnsupportedStoredResource2, UnsupportedImageFormat as UnsupportedImageFormat2 } from "../image-ast/portable.js";
+import { readImageMetadataFromSource, tryPdfMetadata, readImageMetadata, decodeImage, tryImageFile, UnsupportedStoredResource as UnsupportedStoredResource2, UnsupportedImageFormat as UnsupportedImageFormat2 } from "../image-ast/portable.js";
 import { PagedStorage as PagedStorage2, PagedStorageCache } from "@poe-platform/safe-fs/storage";
 import { FsError as FsError2 } from "@poe-platform/safe-fs/contracts";
 import { resolvePath as resolvePath2 } from "../safe-bash-contracts/path.js";
 import { writeBytes } from "../safe-bash-contracts/io.js";
 import { writeFileOutput } from "../safe-bash-contracts/filesystem-output-budget.js";
-import { yieldTurn as yieldTurn10 } from "../safe-bash-contracts/yield.js";
+import { yieldTurn as yieldTurn11 } from "../safe-bash-contracts/yield.js";
 var CompareInputFailure = class extends Error {
   constructor(reason) {
     super("Comparison input failed");
@@ -3364,7 +3505,7 @@ async function withCompareFiles(input, stdinBytes, signal, run) {
     const { data, data16: ignored, ...metadata } = image, position = storage.allocate(data.length);
     for (let offset = 0; offset < data.length; offset += 16384) {
       if (offset % 1048576 === 0)
-        await yieldTurn10(signal);
+        await yieldTurn11(signal);
       await storage.write(position + offset, data.subarray(offset, offset + 16384));
     }
     return { ...metadata, position };
@@ -3393,46 +3534,53 @@ async function withCompareFiles(input, stdinBytes, signal, run) {
   try {
     const result = await withImageInputs(input, stdinBytes, signal, async (read) => {
       const publishImage = async (image, path, encoding, snapshot, retire = true) => {
-        if (path !== "-" || snapshot) {
-          const output = resolvePath2(cwd, path), info = await tryImageFile({ image, storage, ...snapshot ? { encoded: snapshot } : {}, async close() {
-            if (retire) {
-              await storage.close();
-              await read.close();
-            }
-          } }, output, { filesystem: budgetedFs, workingDirectory: cwd, signal }, encoding);
-          if (info)
-            return;
-        }
-        const encoded = snapshot ? (async function* () {
-          for (let position = 0; position < snapshot.source.size; position += 16384) {
-            await yieldTurn10(signal);
-            yield new Uint8Array(await snapshot.source.read(position, Math.min(16384, snapshot.source.size - position), io));
-          }
-        })() : encodeStoredImage2(image, storage, signal, encoding), chunks = [];
-        let size = 0;
         try {
-          for await (const chunk of encoded) {
-            if (path === "-" && !snapshot && stdout)
-              await writeBytes(stdout, chunk, signal);
-            else {
-              chunks.push(chunk);
-              size += chunk.length;
+          if (path !== "-" || snapshot) {
+            const output = resolvePath2(cwd, path), info = await tryImageFile({ image, storage, ...snapshot ? { encoded: snapshot } : {}, async close() {
+              if (retire) {
+                await storage.close();
+                await read.close();
+              }
+            } }, output, { filesystem: budgetedFs, workingDirectory: cwd, signal }, { ...encoding, format: isRawCoder(encoding.format) ? "raw" : encoding.format });
+            if (info)
+              return;
+          }
+          const encoded = snapshot ? (async function* () {
+            for (let position = 0; position < snapshot.source.size; position += 16384) {
+              await yieldTurn11(signal);
+              yield new Uint8Array(await snapshot.source.read(position, Math.min(16384, snapshot.source.size - position), io));
+            }
+          })() : encodeStoredImage(image, storage, signal, encoding), chunks = [];
+          let size = 0;
+          try {
+            for await (const chunk of encoded) {
+              if (path === "-" && !snapshot && stdout)
+                await writeBytes(stdout, chunk, signal);
+              else {
+                chunks.push(chunk);
+                size += chunk.length;
+              }
             }
+          } finally {
+            await encoded.return(void 0);
           }
-        } finally {
-          await encoded.return(void 0);
-        }
-        if (path === "-" && !snapshot && stdout)
-          return;
-        const bytes = new Uint8Array(size);
-        let offset = 0;
-        for (const chunk of chunks) {
-          bytes.set(chunk, offset);
-          offset += chunk.length;
+          if (path === "-" && !snapshot && stdout)
+            return;
+          const bytes = new Uint8Array(size);
+          let offset = 0;
+          for (const chunk of chunks) {
+            bytes.set(chunk, offset);
+            offset += chunk.length;
+          }
+          if (path === "-" && !snapshot)
+            return bytes;
+          await writeFileOutput(context, bytes, (admitted) => fs.writeFile(resolvePath2(cwd, path), admitted, io));
+        } catch (error) {
+          signal.throwIfAborted();
+          if (error instanceof FsError2 && ["ENOENT", "ENOTDIR"].includes(error.code))
+            throw new FsError2(error.code, { syscall: "write", path, cause: error });
+          throw error;
         }
-        if (path === "-" && !snapshot)
-          return bytes;
-        await writeFileOutput(context, bytes, (admitted) => fs.writeFile(resolvePath2(cwd, path), admitted, io));
       };
       const publishPending = async () => {
         let index = 0;
@@ -3474,7 +3622,7 @@ async function withCompareFiles(input, stdinBytes, signal, run) {
               try {
                 let next = iterator.next();
                 while (!next.done) {
-                  await yieldTurn10(signal);
+                  await yieldTurn11(signal);
                   let configured = next.value, image;
                   try {
                     image = bytes ? await retain(decodeImage(bytes, configured)) : await decodeFileImage(checked, storage, fs, cwd, signal, configured);
@@ -3520,7 +3668,10 @@ async function withCompareFiles(input, stdinBytes, signal, run) {
             throw error;
           }
         },
-        stage: snapshots.stage.bind(snapshots),
+        async stage(image, path, encoding) {
+          if (path === "-") return publishImage(image, path, encoding, void 0, false);
+          await snapshots.stage(image, path, encoding);
+        },
         publishPending,
         async publishText(image, path, chunks) {
           const encoded = (async function* () {
@@ -3535,7 +3686,7 @@ async function withCompareFiles(input, stdinBytes, signal, run) {
           await publishPending();
         },
         async publish(image, path, encoding) {
-          if (!snapshots.size) return publishImage(image, path, encoding);
+          if (!snapshots.size && (!isRawCoder(encoding.format) || path === "-")) return publishImage(image, path, encoding);
           let bytes;
           if (path === "-") bytes = await publishImage(image, path, encoding);
           else await snapshots.stage(image, path, encoding);
@@ -3642,7 +3793,7 @@ async function withIdentifyFiles(input, stdinBytes, signal, run) {
 // packages/safe-bash-command-imagemagick/src/index.ts
 import { FsError as FsError4 } from "../safe-bash-contracts/errors.js";
 import { resolvePath as resolvePath3 } from "../safe-bash-contracts/path.js";
-import { yieldTurn as yieldTurn11, drainCooperativeSteps as drainSteps } from "../safe-bash-contracts/yield.js";
+import { yieldTurn as yieldTurn12, drainCooperativeSteps as drainSteps } from "../safe-bash-contracts/yield.js";
 import { InputByteBudget } from "../safe-bash-contracts/io.js";
 import { writeFileOutput as writeFileOutput2 } from "../safe-bash-contracts/filesystem-output-budget.js";
 import {
@@ -3651,7 +3802,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 as transformStoredImage2, UnsupportedStoredResource as UnsupportedStoredResource4, decodeImage as decodeImage3, decodePngToCanvas, FONT_5X7, encodeImage, readImageMetadata as readImageMetadata3, parseColor as baseParseColor, applyExifOrientationSteps, compositeImageSteps, computeImageStatsSteps as computeImageStatsSteps2, ensureAlphaImageSteps, extendImageSteps, extractChannelImageSteps, extractImageSteps as extractImageSteps2, flipImageSteps, flopImageSteps, grayscaleImageSteps, resizeImageSteps, rotateImageSteps, thresholdImageSteps } from "../image-ast/portable.js";
+import { readImageMetadataFromSource as readImageMetadataFromSource3, decodeImageToStorage as decodeImageToStorage2, transformStoredImage as transformStoredImage2, UnsupportedStoredResource as UnsupportedStoredResource4, decodeImage as decodeImage3, decodePngToCanvas, FONT_5X7, readImageMetadata as readImageMetadata3, parseColor as baseParseColor, applyExifOrientationSteps, compositeImageSteps, computeImageStatsSteps as computeImageStatsSteps2, ensureAlphaImageSteps, extendImageSteps, extractChannelImageSteps, extractImageSteps as extractImageSteps2, flipImageSteps, flopImageSteps, grayscaleImageSteps, resizeImageSteps, rotateImageSteps, thresholdImageSteps } from "../image-ast/portable.js";
 var X11_NAMED_COLORS = {
   aliceblue: [240, 248, 255, 255],
   antiquewhite: [250, 235, 215, 255],
@@ -4057,6 +4208,7 @@ function createDefaultState() {
     tile: void 0,
     strip: false,
     adjoin: true,
+    scene: 0,
     dither: true,
     formatStr: void 0,
     channels: { r: true, g: true, b: true, a: false },
@@ -4507,6 +4659,7 @@ function* formatMagickPropertyStringSteps(fmt, meta, getImage, context = {}, res
     Q: String(context.quality ?? meta.quality ?? 92)
   };
   const properties = {
+    ...meta.properties,
     orientation: ["Undefined", "TopLeft", "TopRight", "BottomRight", "BottomLeft", "LeftTop", "RightTop", "RightBottom", "LeftBottom"][meta.orientation ?? 0] ?? "Undefined",
     ...meta.jpegSamplingFactor === void 0 ? {} : { "jpeg:sampling-factor": meta.jpegSamplingFactor },
     "exif:orientation": meta.orientation === void 0 ? "" : String(meta.orientation),
@@ -4953,19 +5106,32 @@ function hasSceneOutputPattern(path) {
   return false;
 }
 function formatSceneOutputPath(pattern, index) {
-  const padMatch = /%0(\d+)d/.exec(pattern);
-  if (padMatch) {
-    const width = parseInt(padMatch[1], 10);
-    return pattern.replace(/%0\d+d/, String(index).padStart(width, "0"));
-  }
-  if (pattern.includes("%d")) {
-    return pattern.replace(/%d/, String(index));
+  let path = "", hasScene = false;
+  for (let cursor = 0; cursor < pattern.length; cursor++) {
+    if (pattern[cursor] === "%") {
+      if (pattern[cursor + 1] === "%") {
+        path += "%";
+        cursor++;
+        continue;
+      }
+      let end = cursor + 1;
+      while (pattern[end] !== void 0 && pattern[end] >= "0" && pattern[end] <= "9") end++;
+      if (pattern[end] === "d") {
+        const width = Number(pattern.slice(cursor + 1, end));
+        path += String(index).padStart(width, pattern[cursor + 1] === "0" ? "0" : " ");
+        hasScene = true;
+        cursor = end;
+        continue;
+      }
+    }
+    path += pattern[cursor];
   }
-  const dot = pattern.lastIndexOf(".");
+  if (hasScene) return path;
+  const dot = path.lastIndexOf(".");
   if (dot > 0) {
-    return `${pattern.slice(0, dot)}-${index}${pattern.slice(dot)}`;
+    return `${path.slice(0, dot)}-${index}${path.slice(dot)}`;
   }
-  return `${pattern}-${index}`;
+  return `${path}-${index}`;
 }
 function parseChannelMask(spec) {
   const s = spec.toLowerCase().trim();
@@ -6939,7 +7105,7 @@ async function decodeStoredMagickSvg(svg, density, backend, signal) {
   const encoder = new TextEncoder(), base = backend.storage.allocate(0);
   let size = 0;
   for (let offset = 0; offset < svg.length; ) {
-    await yieldTurn11(signal);
+    await yieldTurn12(signal);
     const bytes = new Uint8Array(4096), { read, written } = encoder.encodeInto(svg.slice(offset, offset + 4097), bytes);
     await backend.storage.write(backend.storage.allocate(written), bytes.subarray(0, written));
     offset += read;
@@ -7306,12 +7472,32 @@ function* appendStackImagesSteps(stack, vertical, state) {
   }
   return { ...canvas, hasAlpha };
 }
+function expandFilenameProperties(spec, state) {
+  let output = "";
+  for (let i = 0; i < spec.length; ) {
+    if (spec.startsWith("%%", i)) {
+      output += "%%";
+      i += 2;
+      continue;
+    }
+    if (spec.startsWith("%[filename:", i)) {
+      const end = spec.indexOf("]", i + 11);
+      if (end >= 0) {
+        const key = spec.slice(i + 2, end).toLowerCase();
+        output += state.filenameProperties?.[key] ?? spec.slice(i, end + 1);
+        i = end + 1;
+        continue;
+      }
+    }
+    output += spec[i++];
+  }
+  return output;
+}
 function inferOutputFormat(spec, fallback = "png") {
   const prefixMatch = /^([a-zA-Z0-9]+):(.*)$/.exec(spec);
   if (prefixMatch) {
     const prefix = prefixMatch[1].toLowerCase();
     const rest = prefixMatch[2];
-    if (prefix === "rgba") throw new Error("unsupported output coder 'rgba'");
     const fmt = extToImageFormat(prefix);
     if (fmt) {
       return { format: fmt, path: rest };
@@ -7326,7 +7512,11 @@ function inferOutputFormat(spec, fallback = "png") {
   return { format: fallback, path: spec };
 }
 function extToImageFormat(ext) {
+  const rawCoder = ext.toLowerCase();
+  if (isRawCoder(rawCoder)) return rawCoder;
   switch (ext.toLowerCase()) {
+    case "miff":
+      return "miff";
     case "png":
       return "png";
     case "jpg":
@@ -7341,6 +7531,8 @@ function extToImageFormat(ext) {
     case "tif":
     case "tiff":
       return "tiff";
+    case "pam":
+      return "pam";
     case "ppm":
       return "ppm";
     case "pgm":
@@ -7449,6 +7641,15 @@ function* parseInputOperandsSteps(token, files, state, stdinBytes, maxDecodeDime
   const { baseToken, pageSpec, inlineGeom } = parseInputToken(token);
   function* applyMod(imgs) {
     return yield* mapSteps(imgs, function* (im) {
+      if (state.orientation !== void 0) im = { ...im, orientation: state.orientation };
+      if (state.units !== void 0) im = applyMagickUnits(im, state.units);
+      for (const key of ["comment", "label"]) {
+        const value = state[key];
+        if (value !== void 0) {
+          const expanded = yield* formatMagickPropertyStringSteps(value, im, () => im, { filePath: baseToken });
+          im = { ...im, properties: { ...im.properties, [key]: expanded } };
+        }
+      }
       if (state.delay !== void 0) im = { ...im, delay: Array(im.delay?.length ?? 1).fill(state.delay) };
       return inlineGeom ? yield* applyInlineReadModifierSteps(im, inlineGeom, state.kernel) : im;
     });
@@ -7495,14 +7696,28 @@ function* parseInputOperandsSteps(token, files, state, stdinBytes, maxDecodeDime
   if (lower === "null:") {
     return yield* applyMod([yield* createSolidRgbaImageSteps(1, 1, { r: 0, g: 0, b: 0, a: 0 })]);
   }
-  let cleanToken = baseToken;
+  const rgb = lower.startsWith("rgb:");
+  let cleanToken = rgb ? baseToken.slice(4) : baseToken;
   const prefixMatch = /^([a-zA-Z0-9]+):(.*)$/.exec(cleanToken);
   if (prefixMatch && extToImageFormat(prefixMatch[1])) {
     cleanToken = prefixMatch[2];
   }
-  const rawBytes = cleanToken === "-" ? stdinBytes : files.get(cleanToken) ?? files.get(token);
+  let rawBytes = cleanToken === "-" ? stdinBytes : files.get(cleanToken) ?? files.get(token);
   if (!rawBytes)
     return void 0;
+  if (rgb) {
+    if (!state.hasSize) throw new Error("must specify image size for RGB input");
+    const raw = rawRgbInput(state.sizeWidth, state.sizeHeight, state.inputDepth ?? 16, state.inputEndian ?? "lsb", rawBytes.length);
+    const bytes = new Uint8Array(raw.size);
+    for (let position = 0; position < raw.size; position += 8192) {
+      yield;
+      const steps = raw.read(position, Math.min(8192, raw.size - position));
+      let next = steps.next();
+      while (!next.done) next = steps.next(rawBytes.subarray(next.value.position, next.value.position + next.value.length));
+      bytes.set(next.value, position);
+    }
+    rawBytes = bytes;
+  }
   let totalPages = 1;
   let inputMeta;
   try {
@@ -7653,7 +7868,7 @@ async function drainIdentifySteps(steps, signal) {
     while (!next.done) {
       try {
         if (next.value) await next.value.run();
-        else await yieldTurn11(signal);
+        else await yieldTurn12(signal);
         next = steps.next();
       } catch (error) {
         next = steps.throw(error);
@@ -8514,7 +8729,7 @@ async function transformStoredMagickPixels(image, backend, operation, signal, hi
   let storedData16;
   let storedHueSamples;
   for (let offset = 0; offset < size; offset += 16384) {
-    if (offset % 1048576 === 0) await yieldTurn11(signal);
+    if (offset % 1048576 === 0) await yieldTurn12(signal);
     const data = await backend.storage.read(image.position + offset, Math.min(16384, size - offset));
     const bytes16 = (highDepth || operation.highDepth) && image.storedData16 ? await backend.storage.read(image.storedData16.position + offset * 2, data.length * 2) : void 0;
     const data16 = bytes16 ? new Uint16Array(bytes16.buffer, bytes16.byteOffset, bytes16.byteLength / 2) : void 0;
@@ -8536,9 +8751,118 @@ async function transformStoredMagickPixels(image, backend, operation, signal, hi
   }
   return result;
 }
-async function prepareStoredHueOutput(image, format, backend, signal) {
-  if (image.magickColorspace !== "HSL" && image.magickColorspace !== "HSB" && image.magickColorspace !== "HWB" && image.magickColorspace !== "XYZ" && image.magickColorspace !== "YCbCr" && image.magickColorspace !== "YUV") return image;
-  return transformStoredMagickPixels(image, backend, { end: 0, highDepth: true, apply: (frame) => prepareHueOutput(frame, format) }, signal);
+function* prepareMiffPages(stack) {
+  const miffPages = [];
+  for (const frame of stack) {
+    yield;
+    miffPages.push(yield* prepareMagickOutput(frame, "miff"));
+  }
+  return { ...miffPages[0], miffPages };
+}
+function prepareStoredMiffPages(stack, image, backend, signal) {
+  return { ...image, storedMiffPages: { length: stack.length, async at(index) {
+    return prepareStoredMagickOutput(await stack.get(index), "miff", backend, signal);
+  } } };
+}
+function* prepareTiffPages(stack) {
+  const tiffPages = [];
+  for (const frame of stack) {
+    yield;
+    tiffPages.push(yield* prepareMagickOutput(frame, "tiff"));
+  }
+  return { ...tiffPages[0], tiffPages };
+}
+function prepareStoredTiffPages(stack, image, backend, signal) {
+  return { ...image, storedTiffPages: { length: stack.length, async at(index) {
+    return prepareStoredMagickOutput(await stack.get(index), "tiff", backend, signal);
+  } } };
+}
+function* prepareGifFrames(stack) {
+  let cooperativeWork = 0;
+  let fw = 0, fh = 0;
+  for (const frame of stack) {
+    fw = Math.max(fw, frame.width);
+    fh = Math.max(fh, frame.height);
+  }
+  const combined = new Uint8Array(fw * fh * stack.length * 4);
+  const delays = [];
+  const disposals = [];
+  for (let idx = 0; idx < stack.length; idx++) {
+    if (++cooperativeWork % 64 === 0) yield;
+    const outputFrame = yield* prepareMagickOutput(stack[idx], "gif");
+    disposals.push(typeof outputFrame.disposal === "number" ? outputFrame.disposal : 1);
+    delays.push(outputFrame.delay?.[stack[idx][magickInput]?.sceneIdx ?? 0] ?? 100);
+    for (let y = 0; y < outputFrame.height; y++) {
+      if (++cooperativeWork % 64 === 0) yield;
+      combined.set(outputFrame.data.subarray(y * outputFrame.width * 4, (y + 1) * outputFrame.width * 4), (idx * fw * fh + y * fw) * 4);
+    }
+  }
+  return {
+    ...yield* prepareMagickOutput(stack[0], "gif"),
+    width: fw,
+    height: fh * stack.length,
+    pages: stack.length,
+    pageHeight: fh,
+    delay: delays,
+    disposal: disposals,
+    gifFrames: stack.map((frame) => ({ width: frame.width, height: frame.height, x: frame.virtualCanvas?.x ?? 0, y: frame.virtualCanvas?.y ?? 0 })),
+    data: combined
+  };
+}
+async function prepareStoredGifFrames(stack, backend, signal) {
+  const first = await prepareStoredMagickOutput(await stack.get(0), "gif", backend, signal);
+  let width = first.width, height = first.height;
+  for (let index = 1; index < stack.length; index++) {
+    const frame = await stack.get(index);
+    width = Math.max(width, frame.width);
+    height = Math.max(height, frame.height);
+  }
+  const size = width * height * 4, position = backend.storage.allocate(size * stack.length);
+  for (let index = 0; index < stack.length; index++) {
+    const frame = await prepareStoredMagickOutput(await stack.get(index), "gif", backend, signal);
+    for (let y = 0; y < height; y++) for (let x = 0; x < width; x += 4096) {
+      await yieldTurn12(signal);
+      const count = Math.min(4096, width - x), bytes = new Uint8Array(count * 4);
+      if (y < frame.height && x < frame.width) bytes.set(await backend.storage.read(frame.position + (y * frame.width + x) * 4, Math.min(count, frame.width - x) * 4));
+      await backend.storage.write(position + index * size + (y * width + x) * 4, bytes);
+    }
+  }
+  const { storedData16: ignored, ...metadata } = first;
+  return {
+    ...metadata,
+    position,
+    width,
+    height: height * stack.length,
+    pages: stack.length,
+    pageHeight: height,
+    storedGifFrame: { async at(index) {
+      const frame = await stack.get(index);
+      return { width: frame.width, height: frame.height, x: frame.virtualCanvas?.x ?? 0, y: frame.virtualCanvas?.y ?? 0 };
+    } },
+    storedDisposal: { length: stack.length, async at(index) {
+      const frame = await stack.get(index);
+      return typeof frame.disposal === "number" ? frame.disposal : 1;
+    } },
+    storedDelay: { length: stack.length, async at(index) {
+      const frame = await stack.get(index);
+      const scene = frame[magickInput]?.sceneIdx ?? 0;
+      return await frame.storedDelay?.at(scene, { signal }) ?? frame.delay?.[scene] ?? 100;
+    } }
+  };
+}
+function* prepareMagickOutput(image, format) {
+  image = yield* prepareHueOutput(image, format);
+  if (format !== "pbm") return image;
+  const source = image.data16 ? { ...image, data: new Uint8Array(image.data16.buffer, image.data16.byteOffset, image.data16.byteLength) } : image;
+  return yield* applyMagickRasterSteps({ ...image, space: "b-w", channels: 1, hasAlpha: false }, bilevelPixelSteps(image.width * image.height, !!image.data16), void 0, { ...image, hasAlpha: false }, [source]);
+}
+async function prepareStoredMagickOutput(image, format, backend, signal) {
+  if (image.magickColorspace === "HSL" || image.magickColorspace === "HSB" || image.magickColorspace === "HWB" || image.magickColorspace === "XYZ" || image.magickColorspace === "YCbCr" || image.magickColorspace === "YUV") {
+    image = await transformStoredMagickPixels(image, backend, { end: 0, highDepth: true, apply: (frame) => prepareHueOutput(frame, format) }, signal);
+  }
+  if (format !== "pbm") return image;
+  const source = image.storedData16 ? { ...image, position: image.storedData16.position } : image;
+  return transformStoredMagickRaster({ ...image, space: "b-w", channels: 1, hasAlpha: false }, backend, bilevelPixelSteps(image.width * image.height, !!image.storedData16), signal, { ...image, hasAlpha: false }, [source]);
 }
 function parseMagickDisposal(value) {
   const names = ["undefined", "none", "background", "previous"];
@@ -8547,6 +8871,49 @@ function parseMagickDisposal(value) {
   if (["0", "1", "2", "3"].includes(value)) return Number(value);
   return 0;
 }
+function parseMagickOrientation(value) {
+  const orientation = ["undefined", "topleft", "topright", "bottomright", "bottomleft", "lefttop", "righttop", "rightbottom", "leftbottom"].indexOf(value.toLowerCase());
+  if (orientation < 0) throw new Error(`unrecognized image orientation '-orient' '${value}'`);
+  return orientation;
+}
+function parseMagickUnits(value) {
+  switch (value.toLowerCase()) {
+    case "pixelsperinch":
+      return "inch";
+    case "pixelspercentimeter":
+      return "cm";
+    case "undefined":
+      return "unknown";
+    default:
+      throw new Error(`unrecognized units type '-units' '${value}'`);
+  }
+}
+function applyMagickUnits(image, unit) {
+  const scale = image.resolution?.unit === "meter" ? 100 : 1;
+  const x = image.resolution ? image.resolution.x / scale : image.density;
+  const y = image.resolution ? image.resolution.y / scale : image.density;
+  return { ...image, density: x * (unit === "cm" ? 2.54 : 1), resolution: { x, y, unit } };
+}
+function magickResampleGeometry(image, value) {
+  const geometry = parseMagickGeometry(value);
+  const x = geometry.width ?? 72, y = geometry.height ?? x;
+  if (!(x > 0) || !(y > 0)) throw new Error(`invalid argument '-resample' '${value}'`);
+  const scale = image.resolution?.unit === "meter" ? 100 : 1;
+  const sourceX = (image.resolution ? image.resolution.x / scale : image.density) || 72;
+  const sourceY = (image.resolution ? image.resolution.y / scale : image.density) || 72;
+  return `${Math.max(1, Math.round(image.width * x / sourceX))}x${Math.max(1, Math.round(image.height * y / sourceY))}!`;
+}
+function applyMagickDensity(image, value) {
+  const geometry = parseMagickGeometry(value);
+  const x = geometry.width ?? 72, y = geometry.height ?? x;
+  const unit = image.resolution?.unit ?? "unknown";
+  const scale = unit === "meter" ? 100 : 1;
+  return {
+    ...image,
+    density: x * (unit === "cm" || unit === "meter" ? 2.54 : 1),
+    resolution: { x: x * scale, y: y * scale, unit }
+  };
+}
 function applyMagickReadSetting(tokens, state, start) {
   let i = start;
   const t = tokens[i];
@@ -8563,6 +8930,23 @@ function applyMagickReadSetting(tokens, state, start) {
   } else if (t === "+channel") {
     state.channels = { r: true, g: true, b: true, a: false };
     state.channelExplicit = false;
+  } else if (t === "-depth") {
+    state.inputDepth = Number(tokens[++i]);
+    if (!Number.isInteger(state.inputDepth) || state.inputDepth < 1) throw new Error("invalid input depth");
+  } else if (t === "-compress") {
+    const compression = (tokens[++i] ?? "").toLowerCase();
+    if (compression !== "none" && compression !== "zip") throw new Error(`unsupported compression '${compression}'`);
+    state.netpbmAscii = compression === "none";
+  } else if (t === "+compress") {
+    delete state.netpbmAscii;
+  } else if (t === "+depth") {
+    delete state.inputDepth;
+  } else if (t === "-endian") {
+    const endian = (tokens[++i] ?? "").toLowerCase();
+    if (!["msb", "lsb", "undefined"].includes(endian)) throw new Error(`unrecognized endian type '${endian}'`);
+    state.inputEndian = endian;
+  } else if (t === "+endian") {
+    delete state.inputEndian;
   } else if (t === "-size") {
     const g = parseMagickGeometry(tokens[++i] ?? "1x1");
     state.sizeWidth = Math.max(1, Math.round(g.width ?? 1));
@@ -8595,6 +8979,8 @@ function applyMagickReadSetting(tokens, state, start) {
     state.gravity = parseGravity(tokens[++i] ?? "center");
   } else if (t === "+gravity") {
     state.gravity = "northwest";
+  } else if (t === "-comment" || t === "-label") {
+    state[t === "-comment" ? "comment" : "label"] = tokens[++i] ?? "";
   } else if (t === "-sampling-factor") {
     state.samplingFactor = tokens[++i] ?? "";
   } else if (t === "+sampling-factor") {
@@ -8616,6 +9002,9 @@ function applyMagickReadSetting(tokens, state, start) {
     state.compose = parseCompose(cRaw);
   } else if (t === "-define") {
     const defStr = tokens[++i] ?? "";
+    if (defStr.toLowerCase().startsWith("png:exclude-chunk=")) {
+      state.omitPngResolution = defStr.slice("png:exclude-chunk=".length).split(",").some((chunk) => ["phys", "all"].includes(chunk.trim().toLowerCase()));
+    }
     if (defStr.toLowerCase().startsWith("connected-components:")) {
       const [key, value, extra] = defStr.toLowerCase().split("=");
       if (extra !== void 0 || key !== "connected-components:verbose" || value !== "true" && value !== "false") throw new Error(`Unsupported connected-components define: ${defStr}`);
@@ -8629,12 +9018,13 @@ function applyMagickReadSetting(tokens, state, start) {
     const k = (tokens[++i] ?? "").toLowerCase();
     const v = tokens[++i] ?? "";
     if (k.startsWith("option:connected-components:") || k.startsWith("connected-components:")) throw new Error(`Unsupported connected-components setting: ${k}`);
+    if (k.startsWith("filename:")) state.filenameProperties = { ...state.filenameProperties, [k]: v };
     if (k === "option:compose:args")
       state.composeArgs = v;
   } else return void 0;
   return i;
 }
-function* evaluatePipelineTokensSteps(tokens, files, state, parentStack, stdinBytes, signal, analysis = { text: "", warnings: "" }) {
+function* evaluatePipelineTokensSteps(tokens, files, state, parentStack, stdinBytes, signal, analysis = { text: "", warnings: "", bytes: [] }, registers = /* @__PURE__ */ new Map()) {
   let cooperativeWork = 63;
   let stack = [];
   let operandsOnly = false;
@@ -8647,9 +9037,20 @@ function* evaluatePipelineTokensSteps(tokens, files, state, parentStack, stdinBy
       i++;
       continue;
     }
+    if (t.slice(0, 4).toLowerCase() === "mpr:") {
+      const saved = registers.get(t.slice(4));
+      if (!saved) throw new Error(`unable to open image '${t}'`);
+      for (const image of saved) {
+        yield;
+        stack.push({ ...image, data: new Uint8Array(image.data) });
+      }
+      i++;
+      continue;
+    }
     if (operandsOnly) {
       const loaded = yield* parseInputOperandsSteps(t, files, state, stdinBytes);
-      if (loaded) stack.push(...loaded);
+      if (!loaded) throw new Error(`unable to open image '${t}'`);
+      stack.push(...loaded);
       i++;
       continue;
     }
@@ -8668,11 +9069,39 @@ function* evaluatePipelineTokensSteps(tokens, files, state, parentStack, stdinBy
       const endIdx = depth === 0 ? j - 1 : j;
       const subTokens = tokens.slice(i + 1, endIdx);
       const subState = { ...state };
-      const subResult = yield* evaluatePipelineTokensSteps(subTokens, files, subState, stack, stdinBytes, signal, analysis);
+      const subResult = yield* evaluatePipelineTokensSteps(subTokens, files, subState, stack, stdinBytes, signal, analysis, registers);
       stack.push(...subResult);
       i = j;
       continue;
     }
+    if (t === "-orient") {
+      const orientation = state.orientation = parseMagickOrientation(tokens[++i] ?? "");
+      stack = yield* mapSteps(stack, function* (image) {
+        yield;
+        return { ...image, orientation };
+      });
+      i++;
+      continue;
+    }
+    if (t === "-units") {
+      const units = state.units = parseMagickUnits(tokens[++i] ?? "");
+      stack = yield* mapSteps(stack, function* (image) {
+        yield;
+        return applyMagickUnits(image, units);
+      });
+      i++;
+      continue;
+    }
+    if (t === "-density") {
+      const value = tokens[++i] ?? "72";
+      state.density = Math.max(1, Math.round(parseMagickGeometry(value).width ?? 72));
+      stack = yield* mapSteps(stack, function* (image) {
+        yield;
+        return applyMagickDensity(image, value);
+      });
+      i++;
+      continue;
+    }
     if (t === "-set" && tokens[i + 1]?.toLowerCase() === "delay") {
       const delay = Number(tokens[i + 2] ?? 0) * 10;
       stack = yield* mapSteps(stack, function* (image) {
@@ -8691,6 +9120,26 @@ function* evaluatePipelineTokensSteps(tokens, files, state, parentStack, stdinBy
       i += 3;
       continue;
     }
+    if (t === "-set" && !tokens[i + 1]?.toLowerCase().startsWith("option:") && !tokens[i + 1]?.toLowerCase().startsWith("filename:") && !tokens[i + 1]?.toLowerCase().startsWith("connected-components:")) {
+      const key = tokens[++i] ?? "", value = tokens[++i] ?? "";
+      stack = yield* mapSteps(stack, function* (image) {
+        const expanded = yield* formatMagickPropertyStringSteps(value, image, () => image, image[magickInput]);
+        return key.toLowerCase() === "density" ? applyMagickDensity(image, expanded) : { ...image, properties: { ...image.properties, [key]: expanded } };
+      });
+      i++;
+      continue;
+    }
+    if (t === "+set") {
+      const key = tokens[++i] ?? "";
+      stack = yield* mapSteps(stack, function* (image) {
+        yield;
+        const properties = { ...image.properties };
+        delete properties[key];
+        return { ...image, properties };
+      });
+      i++;
+      continue;
+    }
     const setting = applyMagickReadSetting(tokens, state, i);
     const pixelOperation = setting === void 0 ? parseMagickPixelOperation(tokens, state, i, signal) : void 0;
     const warpOperation = setting === void 0 ? parseMagickWarpOperation(tokens, state, i) : void 0;
@@ -8732,35 +9181,59 @@ function* evaluatePipelineTokensSteps(tokens, files, state, parentStack, stdinBy
         return { ...output, ..."space" in plan && plan.space ? { space: plan.space, channels: plan.space === "srgb" ? 4 : output.channels } : {}, ...plan.virtualCanvas ? { virtualCanvas: plan.virtualCanvas } : {} };
       });
     } else if (t === "-write" || t === "+write") {
-      const writePath = tokens[++i] ?? "";
-      if (stack.length > 0 && writePath && writePath.toLowerCase() !== "null:") {
+      if (i + 1 >= tokens.length) throw new Error(`missing argument '${t}'`);
+      if (stack.length === 0) throw new Error(`no images for write '${t}'`);
+      const writePath = expandFilenameProperties(tokens[++i] ?? "", state);
+      if (writePath.slice(0, 4).toLowerCase() === "mpr:") {
+        const saved = [];
+        for (const image of stack) {
+          yield;
+          saved.push({ ...image, data: new Uint8Array(image.data) });
+        }
+        registers.set(writePath.slice(4), saved);
+      } else if (stack.length > 0 && writePath && writePath.toLowerCase() !== "null:") {
         const top = stack[stack.length - 1];
         const { format, path } = inferOutputFormat(writePath, top.format);
-        if (stack.length > 1 && (/%0?\d*d/.test(path) || !state.adjoin)) {
+        if (hasSceneOutputPattern(path) || stack.length > 1 && (!state.adjoin || path !== "-" && ["png", "jpeg", "bmp"].includes(format))) {
           for (let idx = 0; idx < stack.length; idx++) {
             if (++cooperativeWork % 65536 === 0)
               yield;
-            const framePath = formatSceneOutputPath(path, idx);
-            const { data: frameBytes } = encodeImage(yield* prepareHueOutput(stack[idx], format), { format, ...state.samplingFactor === void 0 ? {} : { samplingFactor: state.samplingFactor }, chromaSubsampling: state.quality < 90 ? "4:2:0" : "4:4:4", quality: state.quality });
+            const framePath = formatSceneOutputPath(path, state.scene + idx);
+            const { data: frameBytes } = encodeImage(yield* prepareMagickOutput(stack[idx], format), { format, netpbmAscii: state.netpbmAscii ?? false, ...state.inputDepth === void 0 ? {} : { netpbmDepth: Math.min(16, state.inputDepth) }, endian: state.inputEndian, omitPngResolution: state.strip || state.omitPngResolution === true, ...state.samplingFactor === void 0 ? {} : { samplingFactor: state.samplingFactor }, chromaSubsampling: state.quality < 90 ? "4:2:0" : "4:4:4", quality: state.quality });
             files.set(framePath, frameBytes);
           }
         } else {
-          const { data: encoded } = encodeImage(yield* prepareHueOutput(top, format), { format, ...state.samplingFactor === void 0 ? {} : { samplingFactor: state.samplingFactor }, chromaSubsampling: state.quality < 90 ? "4:2:0" : "4:4:4", quality: state.quality });
-          files.set(path, encoded);
+          const image = stack.length > 1 && format === "miff" ? yield* prepareMiffPages(stack) : stack.length > 1 && format === "tiff" ? yield* prepareTiffPages(stack) : stack.length > 1 && format === "gif" ? yield* prepareGifFrames(stack) : yield* prepareMagickOutput(top, format);
+          const { data: encoded } = encodeImage(image, { format, ...stack.length > 1 && format === "gif" ? { pageHeight: image.pageHeight } : {}, ...state.loop === void 0 ? {} : { loop: state.loop }, ...state.optimizeLayers ? { optimizeFrames: true } : {}, netpbmAscii: state.netpbmAscii ?? false, ...state.inputDepth === void 0 ? {} : { netpbmDepth: Math.min(16, state.inputDepth) }, endian: state.inputEndian, omitPngResolution: state.strip || state.omitPngResolution === true, ...state.samplingFactor === void 0 ? {} : { samplingFactor: state.samplingFactor }, chromaSubsampling: state.quality < 90 ? "4:2:0" : "4:4:4", quality: state.quality });
+          if (path === "-") analysis.bytes.push(encoded);
+          else files.set(path, encoded);
         }
       }
     } else if (t === "-geometry") {
       state.geometry = tokens[++i] ?? "+0+0";
     } else if (t === "-tile") {
       state.tile = tokens[++i];
+    } else if (t === "-profile" || t === "+profile") {
+      const name = tokens[++i];
+      if (!name) throw new Error(`missing argument '${t}'`);
+      const profile = t === "-profile" ? files.get(name) : void 0;
+      if (t === "-profile" && !profile) throw new Error(`unable to open profile '${name}'`);
+      stack = stack.map((image) => applyMagickProfile(image, name, profile));
     } else if (t === "-strip") {
       state.strip = true;
+      for (let index = 0; index < stack.length; index++) {
+        const { icc: ignored, properties: ignoredProperties, ...image } = stack[index];
+        stack[index] = image;
+      }
     } else if (t === "-format") {
       state.formatStr = tokens[++i] ?? "";
     } else if (t === "+adjoin") {
       state.adjoin = false;
     } else if (t === "-adjoin") {
       state.adjoin = true;
+    } else if (t === "-scene") {
+      state.scene = Number(tokens[++i]);
+      if (!Number.isSafeInteger(state.scene) || state.scene < 0) throw new Error("invalid scene number");
     } else if (t === "-delay") {
       state.delay = Number(tokens[++i] ?? 0) * 10;
     } else if (t === "-loop") {
@@ -8929,6 +9402,12 @@ function* evaluatePipelineTokensSteps(tokens, files, state, parentStack, stdinBy
         const { virtualCanvas: ignoredCanvas, ...reset } = image;
         return reset;
       });
+    } else if (t === "-resample") {
+      const value = tokens[++i] ?? "72";
+      stack = yield* mapSteps(stack, function* (image) {
+        const resized = yield* applyMagickResizeSteps(image, magickResampleGeometry(image, value), state.kernel);
+        return applyMagickDensity(resized, value);
+      });
     } else if (t === "-resize" || t === "-scale" || t === "-sample" || t === "-thumbnail") {
       const geom = tokens[++i] ?? "100%";
       const k = t === "-sample" ? "nearest" : state.kernel;
@@ -9307,25 +9786,36 @@ function* evaluatePipelineTokensSteps(tokens, files, state, parentStack, stdinBy
       if (mergeOntoCanvas) {
         state.background = prevBg;
       }
-      if (loaded) {
-        if (mergeOntoCanvas && loaded[0]) {
-          yield* blitOverRgbaInPlaceSteps(stack[0], loaded[0], 0, 0);
-          detachRgbaBuffer(loaded[0].data);
-        } else {
-          stack.push(...loaded);
-        }
+      if (!loaded) throw new Error(`unable to open image '${t}'`);
+      if (mergeOntoCanvas && loaded[0]) {
+        yield* blitOverRgbaInPlaceSteps(stack[0], loaded[0], 0, 0);
+        detachRgbaBuffer(loaded[0].data);
+      } else {
+        stack.push(...loaded);
       }
     }
     i++;
   }
   return stack;
 }
+function combineConvertOutput(result, analysis) {
+  const stdout = analysis.text + result.stdout, stderr = analysis.warnings + result.stderr;
+  if (!analysis.bytes.length) return { ...result, stdout, stderr };
+  const chunks = [...analysis.bytes, ...result.stdoutBytes ? [result.stdoutBytes] : stdout ? [new TextEncoder().encode(stdout)] : []];
+  const stdoutBytes = new Uint8Array(chunks.reduce((size, chunk) => size + chunk.length, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    stdoutBytes.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return { ...result, stdout: "", stderr, stdoutBytes };
+}
 function* runConvertCliSteps(argv, files, stdinBytes, signal) {
-  const analysis = { text: "", warnings: "" };
+  const analysis = { text: "", warnings: "", bytes: [] };
   const result = yield* runConvertCliResultSteps(argv, files, stdinBytes, signal, analysis);
-  return { ...result, stdout: analysis.text + result.stdout, stderr: analysis.warnings + result.stderr };
+  return combineConvertOutput(result, analysis);
 }
-function* runConvertCliResultSteps(argv, files, stdinBytes, signal, analysis = { text: "", warnings: "" }) {
+function* runConvertCliResultSteps(argv, files, stdinBytes, signal, analysis = { text: "", warnings: "", bytes: [] }) {
   const listRes = tryHandleMagickListOption(argv);
   if (listRes) return listRes;
   let cooperativeWork = 63;
@@ -9344,7 +9834,7 @@ function* runConvertCliResultSteps(argv, files, stdinBytes, signal, analysis = {
       stderr: ""
     };
   }
-  const outSpec = argv[argv.length - 1];
+  let outSpec = argv[argv.length - 1];
   const pipelineTokens = argv.slice(0, -1);
   const state = createDefaultState();
   try {
@@ -9357,9 +9847,10 @@ function* runConvertCliResultSteps(argv, files, stdinBytes, signal, analysis = {
 `
       };
     }
+    outSpec = expandFilenameProperties(outSpec, state);
     const finalImg = stack[stack.length - 1];
     const outLower = outSpec.toLowerCase();
-    if (outLower === "null:") return { exitCode: 0, stdout: "", stderr: "" };
+    if (outLower === "null:" || outLower.startsWith("mpr:")) return { exitCode: 0, stdout: "", stderr: "" };
     if (outLower === "info:" || outLower === "info:-") {
       const formatted = [];
       for (const [idx, im] of stack.entries()) {
@@ -9392,50 +9883,21 @@ function* runConvertCliResultSteps(argv, files, stdinBytes, signal, analysis = {
       return { exitCode: 0, stdout: hist, stderr: "" };
     }
     const { format, path: outPath } = inferOutputFormat(outSpec, "png");
-    if (stack.length > 1 && (/%0?\d*d/.test(outPath) || !state.adjoin)) {
+    if (hasSceneOutputPattern(outPath) || stack.length > 1 && (!state.adjoin || outPath !== "-" && ["png", "jpeg", "bmp"].includes(format))) {
       for (let idx = 0; idx < stack.length; idx++) {
         if (++cooperativeWork % 64 === 0)
           yield;
-        const framePath = formatSceneOutputPath(outPath, idx);
-        const { data: frameBytes } = encodeImage(yield* prepareHueOutput(stack[idx], format), { format, ...state.samplingFactor === void 0 ? {} : { samplingFactor: state.samplingFactor }, chromaSubsampling: state.quality < 90 ? "4:2:0" : "4:4:4", quality: state.quality });
+        const framePath = formatSceneOutputPath(outPath, state.scene + idx);
+        const { data: frameBytes } = encodeImage(yield* prepareMagickOutput(stack[idx], format), { format, netpbmAscii: state.netpbmAscii ?? false, ...state.inputDepth === void 0 ? {} : { netpbmDepth: Math.min(16, state.inputDepth) }, endian: state.inputEndian, omitPngResolution: state.strip || state.omitPngResolution === true, ...state.samplingFactor === void 0 ? {} : { samplingFactor: state.samplingFactor }, chromaSubsampling: state.quality < 90 ? "4:2:0" : "4:4:4", quality: state.quality });
         files.set(framePath, frameBytes);
       }
       return { exitCode: 0, stdout: "", stderr: "" };
     }
-    let toEncode = yield* prepareHueOutput(finalImg, format);
+    let toEncode = stack.length > 1 && format === "miff" ? yield* prepareMiffPages(stack) : stack.length > 1 && format === "tiff" ? yield* prepareTiffPages(stack) : yield* prepareMagickOutput(finalImg, format);
     let encodePageHeight;
     if (stack.length > 1 && format === "gif") {
-      let fw = 0, fh = 0;
-      for (const frame of stack) {
-        fw = Math.max(fw, frame.width);
-        fh = Math.max(fh, frame.height);
-      }
-      const combined = new Uint8Array(fw * fh * stack.length * 4);
-      const delays = [];
-      const disposals = [];
-      for (let idx = 0; idx < stack.length; idx++) {
-        if (++cooperativeWork % 64 === 0)
-          yield;
-        const outputFrame = yield* prepareHueOutput(stack[idx], format);
-        disposals.push(typeof outputFrame.disposal === "number" ? outputFrame.disposal : 1);
-        delays.push(outputFrame.delay?.[stack[idx][magickInput]?.sceneIdx ?? 0] ?? 100);
-        for (let y = 0; y < outputFrame.height; y++) {
-          if (++cooperativeWork % 64 === 0) yield;
-          combined.set(outputFrame.data.subarray(y * outputFrame.width * 4, (y + 1) * outputFrame.width * 4), (idx * fw * fh + y * fw) * 4);
-        }
-      }
-      toEncode = {
-        ...yield* prepareHueOutput(stack[0], format),
-        width: fw,
-        height: fh * stack.length,
-        pages: stack.length,
-        pageHeight: fh,
-        delay: delays,
-        disposal: disposals,
-        gifFrames: stack.map((frame) => ({ width: frame.width, height: frame.height, x: frame.virtualCanvas?.x ?? 0, y: frame.virtualCanvas?.y ?? 0 })),
-        data: combined
-      };
-      encodePageHeight = fh;
+      toEncode = yield* prepareGifFrames(stack);
+      encodePageHeight = toEncode.pageHeight;
     }
     if (typeof globalThis.gc === "function") {
       try {
@@ -9447,6 +9909,10 @@ function* runConvertCliResultSteps(argv, files, stdinBytes, signal, analysis = {
     }
     const { data: encoded } = encodeImage(toEncode, {
       format,
+      netpbmAscii: state.netpbmAscii ?? false,
+      ...state.inputDepth === void 0 ? {} : { netpbmDepth: Math.min(16, state.inputDepth) },
+      endian: state.inputEndian,
+      omitPngResolution: state.strip || state.omitPngResolution === true,
       ...state.samplingFactor === void 0 ? {} : { samplingFactor: state.samplingFactor },
       chromaSubsampling: state.quality < 90 ? "4:2:0" : "4:4:4",
       quality: state.quality,
@@ -9483,7 +9949,7 @@ async function transformStoredMagickRaster(image, backend, steps, signal, dimens
     signal.throwIfAborted();
     const request = next.value;
     if (!request) {
-      await yieldTurn11(signal);
+      await yieldTurn12(signal);
       await checkpoint?.();
       next = steps.next();
     } else if (request.kind === "write") {
@@ -9515,7 +9981,7 @@ async function morphStoredMagickImage(image, backend, plan, signal) {
       const position = backend.storage.allocate(size);
       const a = images[step.a], b = images[step.b];
       for (let offset = 0; offset < size; offset += 16384) {
-        await yieldTurn11(signal);
+        await yieldTurn12(signal);
         const length = Math.min(16384, size - offset);
         const left = new Uint8Array(await backend.storage.read(a.position + offset, length));
         const bytes = await drainSteps(subtractMagickPixelSteps(left, await backend.storage.read(b.position + offset, length), image.hasAlpha), signal);
@@ -9567,7 +10033,7 @@ async function transformStoredMagickCoordinates(image, backend, token, geometry,
   let work = 0;
   for (const y of ys) for (let row = 0; row < y.length; row++) for (const x of xs) {
     for (let offset = 0; offset < x.length; offset += 4096) {
-      if (work++ % 64 === 0) await yieldTurn11(signal);
+      if (work++ % 64 === 0) await yieldTurn12(signal);
       const length = Math.min(4096, x.length - offset) * 4;
       const sourceX = Math.min(w - 1, x.source + offset);
       const sourceLength = Math.min(length, (w - sourceX) * 4);
@@ -9597,7 +10063,7 @@ async function compositeStoredMagick(base, overlay, backend, signal, left, top,
   let hasAlpha = base.hasAlpha || !generic && !compositeMode.delegated && !compositeMode.preservesAlpha;
   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 yieldTurn11(signal);
+    await yieldTurn12(signal);
     await backend.storage.write(position + start, await backend.storage.read(base.position + start, Math.min(16384, base.width * base.height * 4 - start)));
   }
   const maskDestination = !generic && ["dstin", "destin", "srcin", "in", "srcout", "out", "dstatop", "destatop"].includes(compositeMode.name);
@@ -9606,7 +10072,7 @@ async function compositeStoredMagick(base, overlay, backend, signal, left, top,
   const bottom = tile || extendSource ? base.height : Math.min(base.height, top + overlay.height);
   for (let y = extendSource ? 0 : Math.max(0, top); y < bottom; y++) {
     for (let x = extendSource ? 0 : Math.max(0, left); x < right; ) {
-      await yieldTurn11(signal);
+      await yieldTurn12(signal);
       const sourceX = tile ? x % overlay.width : Math.max(0, Math.min(overlay.width - 1, x - left));
       const sourceY = tile ? y % overlay.height : Math.max(0, Math.min(overlay.height - 1, y - top));
       const repeatEdge = extendSource && !tile && (x < left || x >= left + overlay.width);
@@ -9645,24 +10111,37 @@ async function compositeStoredMagick(base, overlay, backend, signal, left, top,
   }
   return { ...base, position, hasAlpha, channels: hasAlpha ? base.channels : base.channels <= 2 ? 1 : 3 };
 }
+function applyMagickProfile(image, name, profile) {
+  if (profile) {
+    if (profile.length < 128 || String.fromCharCode(...profile.subarray(36, 40)) !== "acsp") throw new Error(`invalid ICC profile '${name}'`);
+    if (image.icc && (image.icc.length !== profile.length || image.icc.some((byte2, index) => byte2 !== profile[index]))) throw new Error("ICC color conversion is unsupported");
+    return { ...image, icc: profile };
+  }
+  if (["icc", "icm", "*"].includes(name.toLowerCase())) {
+    const { icc: ignored, ...rest } = image;
+    return rest;
+  }
+  return image;
+}
 async function tryConvertFiles(argv, input, stdinBytes, signal) {
-  const analysis = { text: "", warnings: "" };
+  const analysis = { text: "", warnings: "", bytes: [] };
   const result = await tryConvertFilesResult(argv, input, stdinBytes, signal, analysis);
-  return result ? { ...result, stdout: analysis.text + result.stdout, stderr: analysis.warnings + result.stderr } : void 0;
+  return result ? combineConvertOutput(result, analysis) : void 0;
 }
 async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis) {
   if (!input.filesystem.capabilities || !input.filesystem.open || !input.filesystem.removeFileConditional) return;
-  const outSpec = argv.at(-1);
+  let outSpec = argv.at(-1) ?? "";
   const optionArgs = argv.slice(0, argv.indexOf("--") < 0 ? argv.length : argv.indexOf("--"));
   if (!outSpec || tryHandleMagickListOption(argv) || optionArgs.some((token) => ["--help", "-help", "-h", "--version", "-version"].includes(token))) {
     await probeImageArguments(argv, input, stdinBytes, signal);
     return drainSteps(runConvertCliSteps(argv, /* @__PURE__ */ new Map(), stdinBytes, signal), signal);
   }
   let output;
-  await yieldTurn11(signal);
+  await yieldTurn12(signal);
   let state = createDefaultState();
   const tokens = argv.slice(0, -1), scopes = [];
   const steps = [];
+  const registers = /* @__PURE__ */ new Map();
   const stackStep = (runStack) => {
     steps.push({ runStack });
   };
@@ -9670,7 +10149,7 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
   try {
     output = inferOutputFormat(outSpec, "png");
     for (let i = 0; i < tokens.length; i++) {
-      if (i && i % 64 === 0) await yieldTurn11(signal);
+      if (i && i % 64 === 0) await yieldTurn12(signal);
       const token = tokens[i];
       if (token === "") continue;
       if (!operandsOnly && token === "-sampling-factor") {
@@ -9726,20 +10205,20 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
             const length = source.length;
             if (token.endsWith("clone") && length === 0) throw new Error(`UnableToCloneImage ${token}`);
             for (let repeat = 0; repeat < count; repeat++) for (const index of parseMagickIndexSpec(spec, length, "clone")) {
-              await yieldTurn11(signal);
+              await yieldTurn12(signal);
               await stack.push(await source.get(index));
             }
           } else if (token.endsWith("delete")) await stack.remove(parseMagickIndexSpec(spec, stack.length, "delete"));
           else if (token === "-reverse") {
             for (let n = 0; n < Math.floor(stack.length / 2); n++) {
-              await yieldTurn11(signal);
+              await yieldTurn12(signal);
               await stack.swap(n, stack.length - 1 - n);
             }
           } else if (token.endsWith("insert")) {
             const raw = token === "+insert" ? 0 : Number(spec), target = raw < 0 ? stack.length - 1 + raw : raw;
             if (!Number.isInteger(target) || target < 0 || target >= stack.length || raw < 0 && target === 0) throw new Error(`invalid image index ${token}`);
             for (let n = stack.length - 1; n > target; n--) {
-              await yieldTurn11(signal);
+              await yieldTurn12(signal);
               await stack.swap(n, n - 1);
             }
           } else {
@@ -9791,7 +10270,7 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
               const a = await stack.get(index), b = await stack.get(index + 1);
               await result.push(a);
               for (let step = 1; step <= count; step++) {
-                await yieldTurn11(signal);
+                await yieldTurn12(signal);
                 const fraction = step / (count + 1), width = Math.max(1, Math.round(a.width * (1 - fraction) + b.width * fraction)), height = Math.max(1, Math.round(a.height * (1 - fraction) + b.height * fraction));
                 await result.push(await transformStoredMagickRaster(a, backend, morphPixelSteps(a, b, width, height, fraction), signal, { ...a, width, height }, [a, b]));
               }
@@ -9819,6 +10298,22 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
         });
         continue;
       }
+      if (!operandsOnly && token === "-orient") {
+        const orientation = state.orientation = parseMagickOrientation(tokens[++i] ?? "");
+        steps.push(async (image) => image ? { ...image, orientation } : void 0);
+        continue;
+      }
+      if (!operandsOnly && token === "-units") {
+        const units = state.units = parseMagickUnits(tokens[++i] ?? "");
+        steps.push(async (image) => image ? applyMagickUnits(image, units) : void 0);
+        continue;
+      }
+      if (!operandsOnly && token === "-density") {
+        const value = tokens[++i] ?? "72";
+        state.density = Math.max(1, Math.round(parseMagickGeometry(value).width ?? 72));
+        steps.push(async (image) => image ? applyMagickDensity(image, value) : void 0);
+        continue;
+      }
       if (!operandsOnly && token === "-set" && tokens[i + 1]?.toLowerCase() === "delay") {
         const delay = Number(tokens[i + 2] ?? 0) * 10;
         steps.push(async (image) => image ? {
@@ -9836,6 +10331,25 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
         i += 2;
         continue;
       }
+      if (!operandsOnly && token === "-set" && !tokens[i + 1]?.toLowerCase().startsWith("option:") && !tokens[i + 1]?.toLowerCase().startsWith("filename:") && !tokens[i + 1]?.toLowerCase().startsWith("connected-components:")) {
+        const key = tokens[++i] ?? "", value = tokens[++i] ?? "";
+        steps.push(async (image, backend) => {
+          if (!image) return;
+          const expanded = await formatRetainedIdentify(value, image, image[magickInput] ?? {}, async () => ({ image, storage: backend.storage }), signal);
+          return key.toLowerCase() === "density" ? applyMagickDensity(image, expanded) : { ...image, properties: { ...image.properties, [key]: expanded } };
+        });
+        continue;
+      }
+      if (!operandsOnly && token === "+set") {
+        const key = tokens[++i] ?? "";
+        steps.push(async (image) => {
+          if (!image) return;
+          const properties = { ...image.properties };
+          delete properties[key];
+          return { ...image, properties };
+        });
+        continue;
+      }
       const setting = operandsOnly ? void 0 : applyMagickReadSetting(tokens, state, i);
       if (setting !== void 0) {
         i = setting;
@@ -9893,7 +10407,7 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
           if (!image) return;
           const histogram = Array.from({ length: analysisOperation.luminance ? 5 : 4 }, (_, channel) => new Float64Array(channel === 4 || analysisOperation.highDepth && image.storedData16 ? 65536 : 256)), size = image.width * image.height * 4;
           for (let offset = 0; offset < size; offset += 16384) {
-            if (offset % 1048576 === 0) await yieldTurn11(signal);
+            if (offset % 1048576 === 0) await yieldTurn12(signal);
             const original = analysisOperation.highDepth ? image.storedData16 : void 0;
             const bytes = await backend.storage.read((original?.position ?? image.position) + offset * (original ? 2 : 1), Math.min(16384, size - offset) * (original ? 2 : 1));
             await drainSteps(accumulateMagickHistogram(original ? new Uint16Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 2) : bytes, histogram), signal);
@@ -9911,7 +10425,7 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
           const layout = smushLayoutSteps(images, token === "-smush", gap, settings.gravity);
           let next = layout.next();
           while (!next.done) {
-            await yieldTurn11(signal);
+            await yieldTurn12(signal);
             const request = next.value;
             next = layout.next(await backend.storage.read(images[request.index].position + request.position, request.length));
           }
@@ -9957,7 +10471,7 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
           if (append && stack.length === 1) return stack;
           let width = 0, height = 0;
           for (let n = 0; n < (flatten ? 1 : stack.length); n++) {
-            await yieldTurn11(signal);
+            await yieldTurn12(signal);
             const frame = await stack.get(n);
             width = append && !vertical ? width + frame.width : Math.max(width, frame.width);
             height = append && vertical ? height + frame.height : Math.max(height, frame.height);
@@ -9971,7 +10485,7 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
               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 yieldTurn11(signal);
+                  await yieldTurn12(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);
                 }
@@ -10019,7 +10533,7 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
             let next = bounds.next();
             while (!next.done) {
               if (!next.value) {
-                await yieldTurn11(signal);
+                await yieldTurn12(signal);
                 next = bounds.next();
               } else {
                 const { image, position, length } = next.value;
@@ -10054,6 +10568,11 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
         });
         continue;
       }
+      if (!operandsOnly && token === "-scene") {
+        state.scene = Number(tokens[++i]);
+        if (!Number.isSafeInteger(state.scene) || state.scene < 0) throw new Error("invalid scene number");
+        continue;
+      }
       if (!operandsOnly && (token === "+adjoin" || token === "-adjoin")) {
         state.adjoin = token === "-adjoin";
         continue;
@@ -10066,8 +10585,31 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
         state.gravity = "northwest";
         continue;
       }
+      if (!operandsOnly && (token === "-profile" || token === "+profile")) {
+        const name = tokens[++i];
+        if (!name) throw new Error(`missing argument '${token}'`);
+        stackStep(async (stack, backend) => {
+          const profile = token === "-profile" ? await backend.read(name, async (source) => {
+            const bytes = new Uint8Array(source.size);
+            for (let offset = 0; offset < source.size; offset += 16384) {
+              await yieldTurn12(signal);
+              bytes.set(await source.read(offset, Math.min(16384, source.size - offset), { signal }), offset);
+            }
+            return bytes;
+          }) : void 0;
+          if (token === "-profile" && !profile) throw new Error(`unable to open profile '${name}'`);
+          for (let index = 0; index < stack.length; index++) await stack.set(index, applyMagickProfile(await stack.get(index), name, profile));
+          return stack;
+        });
+        continue;
+      }
       if (!operandsOnly && token === "-strip") {
         state.strip = true;
+        steps.push(async (image) => {
+          if (!image) return image;
+          const { icc: ignored, properties: ignoredProperties, ...rest } = image;
+          return rest;
+        });
         continue;
       }
       if (!operandsOnly && token === "+repage") {
@@ -10084,17 +10626,35 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
         continue;
       }
       if (!operandsOnly && (token === "-write" || token === "+write")) {
-        const path = tokens[++i] ?? "", quality = state.quality, samplingFactor = state.samplingFactor, adjoin = state.adjoin;
+        if (i + 1 >= tokens.length) {
+          stackStep(async () => {
+            throw new Error(`missing argument '${token}'`);
+          });
+          break;
+        }
+        const path = expandFilenameProperties(tokens[++i] ?? "", state), endian = state.inputEndian, quality = state.quality, omitPngResolution = state.strip || state.omitPngResolution === true, samplingFactor = state.samplingFactor, netpbmAscii = state.netpbmAscii ?? false, netpbmDepth = state.inputDepth === void 0 ? void 0 : Math.min(16, state.inputDepth), adjoin = state.adjoin, scene = state.scene, loop = state.loop, optimizeLayers = state.optimizeLayers;
         stackStep(async (stack, backend) => {
+          if (stack.length === 0) throw new Error(`no images for write '${token}'`);
           const image = await stack.get(stack.length - 1);
-          if (image && path && path.toLowerCase() !== "null:") {
+          if (path.slice(0, 4).toLowerCase() === "mpr:") {
+            const saved = new StoredImageStack(backend.storage, signal, stack);
+            for (let index = 0; index < stack.length; index++) {
+              await yieldTurn12(signal);
+              await saved.push(await stack.get(index));
+            }
+            registers.set(path.slice(4), saved);
+          } else if (image && path && path.toLowerCase() !== "null:") {
             const output2 = inferOutputFormat(path, image.format);
-            if (stack.length > 1 && (hasSceneOutputPattern(output2.path) || !adjoin)) {
+            if (hasSceneOutputPattern(output2.path) || stack.length > 1 && (!adjoin || output2.path !== "-" && ["png", "jpeg", "bmp"].includes(output2.format))) {
               for (let index = 0; index < stack.length; index++) {
-                await yieldTurn11(signal);
-                await backend.stage(await prepareStoredHueOutput(await stack.get(index), output2.format, backend, signal), formatSceneOutputPath(output2.path, index), { format: output2.format, ...samplingFactor === void 0 ? {} : { samplingFactor }, chromaSubsampling: quality < 90 ? "4:2:0" : "4:4:4", quality });
+                await yieldTurn12(signal);
+                await backend.stage(await prepareStoredMagickOutput(await stack.get(index), output2.format, backend, signal), formatSceneOutputPath(output2.path, scene + index), { format: output2.format, endian, omitPngResolution, netpbmAscii, ...netpbmDepth === void 0 ? {} : { netpbmDepth }, ...samplingFactor === void 0 ? {} : { samplingFactor }, chromaSubsampling: quality < 90 ? "4:2:0" : "4:4:4", quality });
               }
-            } else await backend.stage(await prepareStoredHueOutput(image, output2.format, backend, signal), output2.path, { format: output2.format, ...samplingFactor === void 0 ? {} : { samplingFactor }, chromaSubsampling: quality < 90 ? "4:2:0" : "4:4:4", quality });
+            } else {
+              const frames = stack.length > 1 && output2.format === "miff" ? prepareStoredMiffPages(stack, image, backend, signal) : stack.length > 1 && output2.format === "tiff" ? prepareStoredTiffPages(stack, image, backend, signal) : stack.length > 1 && output2.format === "gif" ? await prepareStoredGifFrames(stack, backend, signal) : await prepareStoredMagickOutput(image, output2.format, backend, signal);
+              const bytes = await backend.stage(frames, output2.path, { format: output2.format, ...stack.length > 1 && output2.format === "gif" ? { pageHeight: frames.pageHeight } : {}, endian, omitPngResolution, netpbmAscii, ...netpbmDepth === void 0 ? {} : { netpbmDepth }, ...samplingFactor === void 0 ? {} : { samplingFactor }, chromaSubsampling: quality < 90 ? "4:2:0" : "4:4:4", quality, ...loop === void 0 ? {} : { loop }, ...optimizeLayers ? { optimizeFrames: true } : {} });
+              if (bytes) analysis.bytes.push(bytes);
+            }
           }
           return stack;
         });
@@ -10137,7 +10697,7 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
           if (!image) return;
           for (const step of magickDrawSteps(image, drawing, settings)) {
             if (!step) {
-              await yieldTurn11(signal);
+              await yieldTurn12(signal);
               continue;
             }
             if ((image.space === "b-w" || image.space === "grey16") && !(step.kind === "floodfill" && step.alphaOnly))
@@ -10253,6 +10813,14 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
       } else if (!operandsOnly && ["-roll", "-splice", "-chop"].includes(token)) {
         const geometry = tokens[++i] ?? (token === "-roll" ? "+0+0" : "0x0"), captured = { ...state };
         steps.push(async (image, backend) => image ? transformStoredMagickCoordinates(image, backend, token, geometry, captured, signal) : void 0);
+      } else if (!operandsOnly && token === "-resample") {
+        const value = tokens[++i] ?? "72", kernel = state.kernel;
+        steps.push(async (image, backend) => {
+          if (!image) return;
+          const options = magickResizeOptions(image, magickResampleGeometry(image, value), kernel);
+          const resized = options ? await resizeStoredMagickImage(image, backend, options, signal) : image;
+          return applyMagickDensity(resized, value);
+        });
       } else if (!operandsOnly && ["-resize", "-scale", "-sample", "-thumbnail"].includes(token)) {
         const geometry = tokens[++i] ?? "100%", kernel = token === "-sample" ? "nearest" : state.kernel, thumbnail = token === "-thumbnail";
         steps.push(async (image, backend) => {
@@ -10296,7 +10864,7 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
           for (let n = 0; n < stack.length; n++) {
             const image = await stack.get(n);
             for (const area of magickCropAreas(image, geometry, gravity)) {
-              await yieldTurn11(signal);
+              await yieldTurn12(signal);
               if (area === null) {
                 analysis.warnings += `magick: geometry does not contain image '${geometry}'
 `;
@@ -10381,19 +10949,34 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
           };
         });
       } else {
-        if (!operandsOnly && (token.startsWith("-") && token !== "-" || token.startsWith("+"))) throw new Error(`unrecognized option '${token}'`);
+        if (!operandsOnly && (token.startsWith("-") && token !== "-" || token.startsWith("+"))) {
+          stackStep(async () => {
+            throw new Error(`unrecognized option '${token}'`);
+          });
+          break;
+        }
         if (!operandsOnly && (token === "(" || token === ")")) continue;
         const captured = { ...state }, literal = operandsOnly, maxDecodeDimension = inferMaxDecodeDimensionFromUpcomingTokens(tokens, i + 1);
         stackStep(async (stack, backend) => {
+          if (token.slice(0, 4).toLowerCase() === "mpr:") {
+            const saved = registers.get(token.slice(4));
+            if (!saved) throw new Error(`unable to open image '${token}'`);
+            for (let index = 0; index < saved.length; index++) {
+              await yieldTurn12(signal);
+              await stack.push(await saved.get(index));
+            }
+            return stack;
+          }
           const base = stack.length === 1 ? await stack.get(0) : void 0, lower = token.toLowerCase();
           const merge = !literal && (lower.startsWith("label:") || lower.startsWith("caption:")) && base && captured.hasSize && base.width === captured.sizeWidth && base.height === captured.sizeHeight && Object.values(captured.background).every((value) => value === 255);
           const settings = merge ? { ...captured, background: { r: 0, g: 0, b: 0, a: 0 } } : captured;
-          await parseStoredCompareInput(token, settings, backend, signal, { visit: async (image) => {
+          const loaded = await parseStoredCompareInput(token, settings, backend, signal, { visit: async (image) => {
             if (merge) {
               const composed = await compositeStoredMagick(base, image, backend, signal, 0, 0, "over");
               await stack.set(0, { ...composed, hasAlpha: base.hasAlpha, channels: base.channels });
             } else await stack.push(image);
           }, ...maxDecodeDimension === void 0 ? {} : { maxDecodeDimension } });
+          if (!loaded) throw new Error(`unable to open image '${token}'`);
           return stack;
         });
       }
@@ -10434,8 +11017,10 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
       return { exitCode: 1, stdout: "", stderr: `magick: no images defined '${outSpec}'
 ` };
     }
-    await yieldTurn11(signal);
-    if (outSpec.toLowerCase() === "null:") {
+    await yieldTurn12(signal);
+    outSpec = expandFilenameProperties(outSpec, state);
+    output = inferOutputFormat(outSpec, "png");
+    if (outSpec.toLowerCase() === "null:" || outSpec.toLowerCase().startsWith("mpr:")) {
       await backend.publishPending();
       return { exitCode: 0, stdout: "", stderr: "" };
     }
@@ -10444,7 +11029,7 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
       async function* information() {
         let last = "";
         for (let index = 0; index < stack.length; index++) {
-          await yieldTurn11(signal);
+          await yieldTurn12(signal);
           const frame = await stack.get(index);
           if (index && !state.formatStr) yield "\n";
           const text = state.formatStr ? await formatRetainedIdentify(state.formatStr, frame, { ...frame[magickInput], sceneIdx: index, sceneCount: stack.length, quality: state.quality }, async () => ({ image: frame, storage: backend.storage }), signal) : `${frame.width}x${frame.height} ${frame.magickColorspace ?? "sRGB"} 8-bit`;
@@ -10468,60 +11053,24 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
       await backend.publishPending();
       return { exitCode: 0, stdout, stderr: "" };
     }
-    if (stack.length > 1 && (hasSceneOutputPattern(output.path) || !state.adjoin)) {
+    if (hasSceneOutputPattern(output.path) || stack.length > 1 && (!state.adjoin || output.path !== "-" && ["png", "jpeg", "bmp"].includes(output.format))) {
       for (let index = 0; index < stack.length; index++) {
-        await yieldTurn11(signal);
-        await backend.stage(await prepareStoredHueOutput(await stack.get(index), output.format, backend, signal), formatSceneOutputPath(output.path, index), { format: output.format, ...state.samplingFactor === void 0 ? {} : { samplingFactor: state.samplingFactor }, chromaSubsampling: state.quality < 90 ? "4:2:0" : "4:4:4", quality: state.quality });
+        await yieldTurn12(signal);
+        await backend.stage(await prepareStoredMagickOutput(await stack.get(index), output.format, backend, signal), formatSceneOutputPath(output.path, state.scene + index), { format: output.format, netpbmAscii: state.netpbmAscii ?? false, ...state.inputDepth === void 0 ? {} : { netpbmDepth: Math.min(16, state.inputDepth) }, endian: state.inputEndian, omitPngResolution: state.strip || state.omitPngResolution === true, ...state.samplingFactor === void 0 ? {} : { samplingFactor: state.samplingFactor }, chromaSubsampling: state.quality < 90 ? "4:2:0" : "4:4:4", quality: state.quality });
       }
       await backend.publishPending();
       return { exitCode: 0, stdout: "", stderr: "" };
     }
+    if (stack.length > 1 && output.format === "miff") image = prepareStoredMiffPages(stack, image, backend, signal);
+    if (stack.length > 1 && output.format === "tiff") image = prepareStoredTiffPages(stack, image, backend, signal);
     let pageHeight;
     if (stack.length > 1 && output.format === "gif") {
-      const first = await prepareStoredHueOutput(await stack.get(0), output.format, backend, signal);
-      let width = first.width, height = first.height;
-      for (let index = 1; index < stack.length; index++) {
-        const frame = await stack.get(index);
-        width = Math.max(width, frame.width);
-        height = Math.max(height, frame.height);
-      }
-      const size = width * height * 4, position = backend.storage.allocate(size * stack.length);
-      for (let index = 0; index < stack.length; index++) {
-        const frame = await prepareStoredHueOutput(await stack.get(index), output.format, backend, signal);
-        for (let y = 0; y < height; y++) for (let x = 0; x < width; x += 4096) {
-          await yieldTurn11(signal);
-          const count = Math.min(4096, width - x), bytes = new Uint8Array(count * 4);
-          if (y < frame.height && x < frame.width) bytes.set(await backend.storage.read(frame.position + (y * frame.width + x) * 4, Math.min(count, frame.width - x) * 4));
-          await backend.storage.write(position + index * size + (y * width + x) * 4, bytes);
-        }
-      }
-      pageHeight = height;
-      const { storedData16: ignored, ...metadata } = first;
-      image = {
-        ...metadata,
-        position,
-        width,
-        height: height * stack.length,
-        pages: stack.length,
-        pageHeight,
-        storedGifFrame: { async at(index) {
-          const frame = await stack.get(index);
-          return { width: frame.width, height: frame.height, x: frame.virtualCanvas?.x ?? 0, y: frame.virtualCanvas?.y ?? 0 };
-        } },
-        storedDisposal: { length: stack.length, async at(index) {
-          const frame = await stack.get(index);
-          return typeof frame.disposal === "number" ? frame.disposal : 1;
-        } },
-        storedDelay: { length: stack.length, async at(index) {
-          const frame = await stack.get(index);
-          const scene2 = frame[magickInput]?.sceneIdx ?? 0;
-          return await frame.storedDelay?.at(scene2, { signal }) ?? frame.delay?.[scene2] ?? 100;
-        } }
-      };
+      image = await prepareStoredGifFrames(stack, backend, signal);
+      pageHeight = image.pageHeight;
     }
     const scene = pageHeight === void 0 ? (await stack.get(0))[magickInput]?.sceneIdx ?? 0 : 0;
     const delay = pageHeight === void 0 ? await image.storedDelay?.at(scene, { signal }) ?? image.delay?.[scene] : void 0;
-    const stdoutBytes = await backend.publish(await prepareStoredHueOutput(image, output.format, backend, signal), output.path, { format: output.format, ...state.samplingFactor === void 0 ? {} : { samplingFactor: state.samplingFactor }, chromaSubsampling: state.quality < 90 ? "4:2:0" : "4:4:4", quality: state.quality, ...pageHeight === void 0 ? {} : { pageHeight }, ...delay === void 0 ? {} : { delay }, ...state.loop === void 0 ? {} : { loop: state.loop }, ...state.optimizeLayers ? { optimizeFrames: true } : {} });
+    const stdoutBytes = await backend.publish(await prepareStoredMagickOutput(image, output.format, backend, signal), output.path, { format: output.format, netpbmAscii: state.netpbmAscii ?? false, ...state.inputDepth === void 0 ? {} : { netpbmDepth: Math.min(16, state.inputDepth) }, endian: state.inputEndian, omitPngResolution: state.strip || state.omitPngResolution === true, ...state.samplingFactor === void 0 ? {} : { samplingFactor: state.samplingFactor }, chromaSubsampling: state.quality < 90 ? "4:2:0" : "4:4:4", quality: state.quality, ...pageHeight === void 0 ? {} : { pageHeight }, ...delay === void 0 ? {} : { delay }, ...state.loop === void 0 ? {} : { loop: state.loop }, ...state.optimizeLayers ? { optimizeFrames: true } : {} });
     return { exitCode: 0, stdout: "", stderr: "", ...stdoutBytes ? { stdoutBytes } : {} };
   });
 }
@@ -10553,6 +11102,7 @@ function* parseMogrifySteps(argv) {
   const readSettings = [];
   const targets = [];
   const flagsWithOneArg = /* @__PURE__ */ new Set([
+    "-resample",
     "-resize",
     "-scale",
     "-sample",
@@ -10598,12 +11148,15 @@ function* parseMogrifySteps(argv) {
     "-liquid-rescale",
     "-adaptive-resize",
     "-define",
+    "+set",
     "-write",
     "+write",
     "-compose",
     "-geometry",
     "-size",
     "-depth",
+    "-compress",
+    "-endian",
     "-units",
     "-interlace",
     "-sampling-factor",
@@ -10657,7 +11210,7 @@ function* parseMogrifySteps(argv) {
       }
     } else if (t === "-evaluate" || t === "-function" || t === "-morphology" || t === "-statistic" || t === "-set" || t === "-distort" || t === "+distort") {
       opTokens.push(t, argv[++i] ?? "", argv[++i] ?? "");
-    } else if (["-density", "-background", "-fuzz", "-filter", "-size"].includes(t)) {
+    } else if (["-density", "-background", "-fuzz", "-filter", "-size", "-comment", "-label"].includes(t)) {
       readSettings.push(t, argv[++i] ?? "");
     } else if (flagsWithOneArg.has(t)) {
       opTokens.push(t, argv[++i] ?? "");
@@ -10770,13 +11323,13 @@ async function probeImageArguments(argv, files, stdinBytes, active) {
   await withImageInputs(files, stdinBytes, active, async (read) => {
     const inspect = async (source) => {
       for (let position = 0; position < source.size; position += 16384) {
-        await yieldTurn11(active);
+        await yieldTurn12(active);
         await source.read(position, Math.min(16384, source.size - position), { signal: active });
       }
     };
     let operandsOnly = false;
     for (let index = 0; index < argv.length; index++) {
-      await yieldTurn11(active);
+      await yieldTurn12(active);
       const token = argv[index];
       if (!operandsOnly && token === "--") {
         operandsOnly = true;
@@ -10827,6 +11380,19 @@ async function parseStoredCompareInput(token, state, backend, signal, readOption
     const pattern = await parseStoredCompareInput(baseToken.slice(5), state, backend, signal, { source: readOptions.source, lastPage: readOptions.lastPage === true });
     if (!pattern) return;
     image = await tile(pattern);
+  } else if (lower.startsWith("rgb:")) {
+    if (!state.hasSize) throw new Error("must specify image size for RGB input");
+    const path = baseToken.slice(4);
+    const consume = async (source) => {
+      const raw = rawRgbInput(state.sizeWidth, state.sizeHeight, state.inputDepth ?? 16, state.inputEndian ?? "lsb", source.size);
+      return parseStoredCompareInput(`ppm:${token.slice(4)}`, state, backend, signal, { ...readOptions, source: { size: raw.size, async read(position, length) {
+        const steps = raw.read(position, length);
+        let next = steps.next();
+        while (!next.done) next = steps.next(await source.read(next.value.position, next.value.length, { signal }));
+        return next.value;
+      } } });
+    };
+    return readOptions.source === null ? void 0 : readOptions.source ? consume(readOptions.source) : backend.read(path, consume);
   } else if (lower.startsWith("xc:") || lower.startsWith("canvas:") || lower === "null:") {
     const color = lower === "null:" ? { r: 0, g: 0, b: 0, a: 0 } : parseColor(baseToken.slice(baseToken.indexOf(":") + 1) || "white"), width = lower === "null:" ? 1 : state.sizeWidth, height = lower === "null:" ? 1 : state.sizeHeight;
     image = { ...await createStoredCanvas(width, height, color, backend, signal), hasAlpha: color.a < 255 };
@@ -10836,7 +11402,7 @@ async function parseStoredCompareInput(token, state, backend, signal, readOption
     const [first, last] = baseToken.slice(baseToken.indexOf(":") + 1).split("-"), a = parseColor(checker ? "white" : first || "#ffffff"), b = parseColor(checker ? "black" : last || "#000000");
     const cx = (width - 1) / 2, cy = (height - 1) / 2, radius = Math.max(1, Math.hypot(cx, cy));
     for (let start = 0; start < width * height; start += 4096) {
-      if (start % 262144 === 0) await yieldTurn11(signal);
+      if (start % 262144 === 0) await yieldTurn12(signal);
       const count = Math.min(4096, width * height - start), bytes = new Uint8Array(count * 4);
       for (let i = 0; i < count; i++) {
         const x = (start + i) % width, y = Math.floor((start + i) / width), offset = i * 4;
@@ -10898,7 +11464,7 @@ async function parseStoredCompareInput(token, state, backend, signal, readOption
     const width = state.sizeWidth, height = state.sizeHeight, position = backend.storage.allocate(width * height * 4);
     let cachedPosition = -1, cached = new Uint8Array();
     for (let start = 0; start < width * height; start += 4096) {
-      if (start % 262144 === 0) await yieldTurn11(signal);
+      if (start % 262144 === 0) await yieldTurn12(signal);
       const count = Math.min(4096, width * height - start), bytes = new Uint8Array(count * 4);
       for (let offset = 0; offset < count; ) {
         const x = (start + offset) % width, y = Math.floor((start + offset) / width), px = x % pattern.width, py = y % pattern.height, blockX = Math.floor(px / 4096) * 4096;
@@ -10916,6 +11482,15 @@ async function parseStoredCompareInput(token, state, backend, signal, readOption
     return { position, width, height, format: "png", channels: 4, depth: "uchar", space: "srgb", density: 72, hasAlpha: pattern.hasAlpha };
   }
   async function finish(image2) {
+    if (state.orientation !== void 0) image2 = { ...image2, orientation: state.orientation };
+    if (state.units !== void 0) image2 = applyMagickUnits(image2, state.units);
+    for (const key of ["comment", "label"]) {
+      const value = state[key];
+      if (value !== void 0) {
+        const expanded = await formatRetainedIdentify(value, image2, { filePath: baseToken }, async () => ({ image: image2, storage: backend.storage }), signal);
+        image2 = { ...image2, properties: { ...image2.properties, [key]: expanded } };
+      }
+    }
     if (state.delay !== void 0) {
       const delay = state.delay;
       image2 = { ...image2, storedDelay: { length: image2.storedDelay?.length ?? image2.delay?.length ?? 1, async at() {
@@ -11640,7 +12215,7 @@ async function runMontageFiles(argv, input, stdinBytes, signal) {
       } };
     };
     for (let index = 0; index < paths.length; index++) {
-      await yieldTurn11(signal);
+      await yieldTurn12(signal);
       const token = paths[index];
       let path2 = parseInputToken(token.toLowerCase().startsWith("tile:") ? token.slice(5) : token).baseToken;
       const colon = path2.indexOf(":");
@@ -11648,7 +12223,7 @@ async function runMontageFiles(argv, input, stdinBytes, signal) {
       await backend.read(path2, async (source2) => {
         const position = backend.storage.allocate(source2.size);
         for (let start = 0; start < source2.size; start += 16384) {
-          await yieldTurn11(signal);
+          await yieldTurn12(signal);
           await backend.storage.write(position + start, await source2.read(start, Math.min(16384, source2.size - start), { signal }));
         }
         await sources.set(BigInt(index * 5), BigInt(position));
@@ -11678,7 +12253,7 @@ async function runMontageFiles(argv, input, stdinBytes, signal) {
         await sources.set(BigInt(index * 5 + 3), BigInt(height));
         let directPng = metadata.format === "png" && !metadata.isProgressive && prefix[24] === 8 && (prefix[25] === 2 || prefix[25] === 6), idat = false;
         if (directPng) for (let offset = 8; offset + 8 <= source.size; ) {
-          await yieldTurn11(signal);
+          await yieldTurn12(signal);
           const header = await source.read(offset, 8), size = new DataView(header.buffer, header.byteOffset, 4).getUint32(0, false);
           if (offset + 8 + size > source.size) break;
           const name = String.fromCharCode(...header.subarray(4));
@@ -11742,7 +12317,7 @@ async function runMontageFiles(argv, input, stdinBytes, signal) {
       canvasWidth = canvasHeight = 0;
       let rowWidth = 0, rowHeight = 0;
       for (let index = 0; index < Math.min(n, cols * rows); index++) {
-        await yieldTurn11(signal);
+        await yieldTurn12(signal);
         const image = fast ? void 0 : await images.get(index);
         const width = image ? image.width : Number(await sources.get(BigInt(index * 5 + 2)));
         const height = image ? image.height : Number(await sources.get(BigInt(index * 5 + 3)));
@@ -11760,7 +12335,7 @@ async function runMontageFiles(argv, input, stdinBytes, signal) {
     let canvas = await createStoredCanvas(Math.max(1, canvasWidth), Math.max(1, canvasHeight), state.background, backend, signal);
     let anyTransparent = state.background.a < 255 || borderW > 0 && state.borderColor.a < 255;
     for (let index = 0; index < n; index++) {
-      await yieldTurn11(signal);
+      await yieldTurn12(signal);
       const col = index % cols, row = Math.floor(index / cols);
       if (row >= rows) break;
       let image, directPng = false;
@@ -11795,7 +12370,7 @@ async function runMontageFiles(argv, input, stdinBytes, signal) {
       const x = (variableCells ? tileX : col * slotW) + (concatenate ? borderW : 0) + padX + offset.left, y = (variableCells ? tileY : row * slotH) + (concatenate ? borderW : 0) + padY + offset.top;
       tileX += width + padX * 2;
       if (!anyTransparent) for (let start = 0; start < image.width * image.height * 4; start += 16384) {
-        await yieldTurn11(signal);
+        await yieldTurn12(signal);
         const bytes = await backend.storage.read(image.position + start, Math.min(16384, image.width * image.height * 4 - start));
         for (let k = 3; k < bytes.length; k += 4) if (bytes[k] < 255) {
           anyTransparent = true;
@@ -11887,7 +12462,7 @@ async function runBufferedImageFiles(argv, input, runner, stdinBytes, signal) {
   const hasOutputOperand = runner !== runIdentifyCli && !(runner === runMagickCli && argv[0] === "identify");
   let operandsOnly = false;
   for (const [index, token] of argv.entries()) {
-    if (++cooperativeWork % 64 === 0) await yieldTurn11(context.signal);
+    if (++cooperativeWork % 64 === 0) await yieldTurn12(context.signal);
     if (!operandsOnly && token === "--") {
       operandsOnly = true;
       continue;
@@ -11922,7 +12497,7 @@ async function runBufferedImageFiles(argv, input, runner, stdinBytes, signal) {
     const chunks = [];
     let total = 0;
     for await (const chunk of readBytes2(context.stdin, signal)) {
-      if (++cooperativeWork % 64 === 0) await yieldTurn11(context.signal);
+      if (++cooperativeWork % 64 === 0) await yieldTurn12(context.signal);
       chargeInput(chunk.byteLength);
       chunks.push(chunk);
       total += chunk.byteLength;
@@ -11930,7 +12505,7 @@ async function runBufferedImageFiles(argv, input, runner, stdinBytes, signal) {
     stdinBytes = new Uint8Array(total);
     let off = 0;
     for (const chunk of chunks) {
-      if (++cooperativeWork % 64 === 0) await yieldTurn11(context.signal);
+      if (++cooperativeWork % 64 === 0) await yieldTurn12(context.signal);
       stdinBytes.set(chunk, off);
       off += chunk.byteLength;
     }
@@ -11950,10 +12525,17 @@ async function runBufferedImageFiles(argv, input, runner, stdinBytes, signal) {
     delivered = { ...result, stdout: "" };
   }
   for (const [key, val] of vfsFiles.entries()) {
-    if (++cooperativeWork % 64 === 0) await yieldTurn11(context.signal);
+    if (++cooperativeWork % 64 === 0) await yieldTurn12(context.signal);
     if (existingSnap.get(key) !== val) {
       const abs = resolvePath3(context.cwd, key);
-      await writeFileOutput2(context, val, (data) => context.fs.writeFile(abs, data, { signal }));
+      try {
+        await writeFileOutput2(context, val, (data) => context.fs.writeFile(abs, data, { signal }));
+      } catch (error) {
+        signal.throwIfAborted();
+        if (error instanceof FsError4 && ["ENOENT", "ENOTDIR"].includes(error.code))
+          throw new FsError4(error.code, { syscall: "write", path: key, cause: error });
+        throw error;
+      }
     }
   }
   vfsFiles.clear();
@@ -12016,6 +12598,12 @@ async function executeVfsMagickTool(context, runner, maxInputBytes) {
       await writeBytes2(stdout.output, new TextEncoder().encode(res.stdout), invocation.signal);
     }
     return { exitCode: res.exitCode };
+  } catch (error) {
+    invocation.signal.throwIfAborted();
+    if (!(error instanceof FsError4) || !["ENOENT", "ENOTDIR"].includes(error.code)) throw error;
+    await writeBytes2(context.stderr, new TextEncoder().encode(`magick: ${error.message}
+`), invocation.signal);
+    return { exitCode: 1 };
   } finally {
     await invocation.close();
   }