@poe-platform/safe-bash 0.1.834 → 0.1.836

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

@@ -1,5 +1,215 @@
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
+// packages/safe-bash-command-imagemagick/src/connected-components.ts
+import { yieldTurn as yieldTurn2 } from "../safe-bash-contracts/yield.js";
+
+// packages/safe-bash-command-imagemagick/src/raster-backing.ts
+import { yieldTurn } from "../safe-bash-contracts/yield.js";
+var RasterBackingCache = class {
+  constructor(storage, signal) {
+    this.storage = storage;
+    this.signal = signal;
+  }
+  storage;
+  signal;
+  pages = /* @__PURE__ */ new Map();
+  work = 0;
+  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 yieldTurn(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 yieldTurn(this.signal);
+    const start = Math.floor(offset / 4096) * 4096, key = region.position + ":" + start;
+    let page = this.pages.get(key);
+    if (page) {
+      this.pages.delete(key);
+      this.pages.set(key, page);
+      return page;
+    }
+    if (this.pages.size === 32) {
+      const oldest = this.pages.entries().next().value;
+      if (oldest[1].dirty) await this.storage.write(oldest[1].position, oldest[1].bytes, { signal: this.signal });
+      this.pages.delete(oldest[0]);
+    }
+    const length = Math.min(4096, region.length - start), borrowed = await this.storage.read(region.position + start, length, { signal: this.signal });
+    if (borrowed.length !== length) throw new Error("Truncated raster backing");
+    const bytes = new Uint8Array(borrowed);
+    page = { position: region.position + start, bytes, view: new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), dirty: false };
+    this.pages.set(key, page);
+    return page;
+  }
+  async byte(region, offset) {
+    return (await this.page(region, offset)).bytes[offset % 4096];
+  }
+  async mark(region, offset) {
+    const page = await this.page(region, offset);
+    page.bytes[offset % 4096] = 1;
+    page.dirty = true;
+  }
+  async uint32(region, offset) {
+    return (await this.page(region, offset)).view.getUint32(offset % 4096, true);
+  }
+  async setUint32(region, offset, value) {
+    const page = await this.page(region, offset);
+    page.view.setUint32(offset % 4096, value, true);
+    page.dirty = true;
+  }
+  async float32(region, offset) {
+    return (await this.page(region, offset)).view.getFloat32(offset % 4096, true);
+  }
+  async setFloat32(region, offset, value) {
+    const page = await this.page(region, offset);
+    page.view.setFloat32(offset % 4096, value, true);
+    page.dirty = true;
+  }
+  async flush() {
+    for (const page of this.pages.values()) {
+      this.signal.throwIfAborted();
+      if (page.dirty) {
+        await this.storage.write(page.position, page.bytes, { signal: this.signal });
+        page.dirty = false;
+      }
+    }
+  }
+};
+
+// packages/safe-bash-command-imagemagick/src/connected-components.ts
+function* labelSteps(width, height, connectivity) {
+  const components = [];
+  for (let seed = 0; seed < width * height; seed++) {
+    if (seed % 1024 === 0) yield;
+    if (yield { region: "labels", index: seed }) continue;
+    if (components.length === 65536) throw new Error("connected-components: too many objects (maximum 65536)");
+    const id = components.length, color = yield { region: "pixels", index: seed };
+    const component = { id, area: 0, x: 0, y: 0, left: width, top: height, right: 0, bottom: 0, color: [0, 0, 0, 0] };
+    let head = 0, tail = 1;
+    yield { region: "labels", index: seed, value: id + 1 };
+    yield { region: "queue", index: 0, value: seed };
+    while (head < tail) {
+      if (head % 1024 === 0) yield;
+      const current = yield { region: "queue", index: head++ }, x = current % width, y = Math.floor(current / width);
+      const pixel = yield { region: "pixels", index: current };
+      component.area++;
+      component.x += x;
+      component.y += y;
+      component.left = Math.min(component.left, x);
+      component.right = Math.max(component.right, x);
+      component.top = Math.min(component.top, y);
+      component.bottom = Math.max(component.bottom, y);
+      for (let channel = 0; channel < 4; channel++) component.color[channel] += pixel >>> channel * 8 & 255;
+      for (let dy = -1; dy <= 1; dy++) for (let dx = -1; dx <= 1; dx++) {
+        if (!dx && !dy || connectivity === 4 && dx && dy || x + dx < 0 || x + dx >= width || y + dy < 0 || y + dy >= height) continue;
+        const next = (y + dy) * width + x + dx;
+        if (yield { region: "labels", index: next }) continue;
+        const neighbor = yield { region: "pixels", index: next };
+        if (neighbor !== color && (neighbor >>> 24 !== 0 || color >>> 24 !== 0)) continue;
+        yield { region: "labels", index: next, value: id + 1 };
+        yield { region: "queue", index: tail++, value: next };
+      }
+    }
+    components.push(component);
+  }
+  return components;
+}
+function* reportSteps(components) {
+  let sorted = components.slice();
+  for (let span = 1; span < sorted.length; span *= 2) {
+    const next = [];
+    for (let start = 0; start < sorted.length; start += span * 2) {
+      let left = start, right = Math.min(start + span, sorted.length);
+      const middle = right, end = Math.min(start + span * 2, sorted.length);
+      while (left < middle || right < end) {
+        if (next.length % 1024 === 0) yield;
+        next.push(right === end || left < middle && sorted[left].area >= sorted[right].area ? sorted[left++] : sorted[right++]);
+      }
+    }
+    sorted = next;
+  }
+  let text = "Objects (id: bounding-box centroid area mean-color):\n";
+  for (const c of sorted) {
+    if (c.id % 1024 === 0) yield;
+    const channels = c.color.slice(0, 3).map((value) => Number((value / c.area).toPrecision(6)));
+    const color = c.color[3] < c.area * 255 ? `srgba(${channels.join(",")},${Number((c.color[3] / c.area / 255).toPrecision(6))})` : `srgb(${channels.join(",")})`;
+    text += `  ${c.id}: ${c.right - c.left + 1}x${c.bottom - c.top + 1}+${c.left}+${c.top} ${(c.x / c.area).toFixed(1)},${(c.y / c.area).toFixed(1)} ${c.area} ${color}
+`;
+  }
+  return text;
+}
+function* connectedComponentsSteps(image, connectivity, verbose) {
+  const count = image.width * image.height, labels = new Uint32Array(count), queue = new Uint32Array(count), pixels = new DataView(image.data.buffer, image.data.byteOffset, image.data.byteLength);
+  const steps = labelSteps(image.width, image.height, connectivity);
+  let next = steps.next();
+  while (!next.done) {
+    const request = next.value;
+    if (!request) {
+      yield;
+      next = steps.next(0);
+      continue;
+    }
+    const { region, index, value } = request;
+    if (region === "pixels") next = steps.next(pixels.getUint32(index * 4, true));
+    else {
+      const data2 = region === "labels" ? labels : queue;
+      if (value !== void 0) data2[index] = value;
+      next = steps.next(data2[index]);
+    }
+  }
+  const text = verbose ? yield* reportSteps(next.value) : "", data = new Uint8Array(count * 4);
+  for (let i = 0; i < count; i++) {
+    if (i % 1024 === 0) yield;
+    const value = Math.round((labels[i] - 1) / 257);
+    data.set([value, value, value, 255], i * 4);
+  }
+  return { image: { ...image, data, hasAlpha: false, space: "srgb" }, text };
+}
+async function connectedComponentsStored(image, storage, connectivity, verbose, signal) {
+  const size = image.width * image.height * 4, cache = new RasterBackingCache(storage, signal);
+  const regions = { pixels: { position: image.position, length: size }, labels: await cache.allocate(size), queue: await cache.allocate(size) };
+  const steps = labelSteps(image.width, image.height, connectivity);
+  let next = steps.next();
+  while (!next.done) {
+    const request = next.value;
+    if (!request) {
+      await yieldTurn2(signal);
+      next = steps.next(0);
+      continue;
+    }
+    const region = regions[request.region], offset = request.index * 4;
+    if (request.value !== void 0) {
+      await cache.setUint32(region, offset, request.value);
+      next = steps.next(0);
+    } else next = steps.next(await cache.uint32(region, offset));
+  }
+  let text = "";
+  if (verbose) {
+    const report = reportSteps(next.value);
+    let part = report.next();
+    while (!part.done) {
+      await yieldTurn2(signal);
+      part = report.next();
+    }
+    text = part.value;
+  }
+  await cache.flush();
+  const position = storage.allocate(size);
+  for (let offset = 0; offset < size; offset += 4096) {
+    await yieldTurn2(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);
+      bytes.set([value, value, value, 255], i);
+    }
+    await storage.write(position + offset, bytes, { signal });
+  }
+  return { image: { ...image, position, hasAlpha: false, space: "srgb" }, text };
+}
+
 // packages/safe-bash-command-imagemagick/src/sequence-kernel.ts
 var byte = (value) => Math.max(0, Math.min(255, Math.round(value)));
 function* clutPixelSteps(size, lut, mask) {
@@ -250,7 +460,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 } from "../safe-bash-contracts/yield.js";
+import { yieldTurn as yieldTurn3 } 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)})`;
@@ -264,7 +474,7 @@ async function* storedPixelEnumeration(image, storage, signal) {
 `;
   const size = image.width * image.height * 4;
   for (let start = 0; start < size; start += 16384) {
-    await yieldTurn(signal);
+    await yieldTurn3(signal);
     const bytes = await storage.read(image.position + start, Math.min(16384, size - start));
     for (let offset = 0; offset < bytes.length; offset += 4) {
       const pixel = (start + offset) / 4;
@@ -276,7 +486,7 @@ async function* storedHistogram(image, storage, signal) {
   const counts = new IntegerTable(storage, 512), order = new IntegerTable(storage, 128), size = image.width * image.height * 4;
   let unique = 0;
   for (let start = 0; start < size; start += 16384) {
-    await yieldTurn(signal);
+    await yieldTurn3(signal);
     const bytes = await storage.read(image.position + start, Math.min(16384, size - start));
     for (let offset = 0; offset < bytes.length; offset += 4) {
       const key = BigInt((bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0), count = await counts.get(key);
@@ -285,7 +495,7 @@ async function* storedHistogram(image, storage, signal) {
     }
   }
   for (let index = 0; index < unique; index++) {
-    if (index % 128 === 0) await yieldTurn(signal);
+    if (index % 128 === 0) await yieldTurn3(signal);
     const key = await order.get(BigInt(index));
     yield histogramLine(Number(key), Number(await counts.get(key))) + "\n";
   }
@@ -327,7 +537,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 yieldTurn2 } from "../safe-bash-contracts/yield.js";
+import { yieldTurn as yieldTurn4 } from "../safe-bash-contracts/yield.js";
 var magickInput = /* @__PURE__ */ Symbol("magickInput");
 var StoredImageStack = class {
   constructor(storage, signal, parent) {
@@ -359,7 +569,7 @@ var StoredImageStack = class {
     if (source && !delays) {
       delays = { position: this.storage.allocate(source.length * 9), length: source.length };
       for (let start = 0; start < source.length; start += 512) {
-        await yieldTurn2(this.signal);
+        await yieldTurn4(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];
@@ -376,7 +586,7 @@ var StoredImageStack = class {
     const text = JSON.stringify(record), encoder = new TextEncoder(), position = this.storage.allocate(8);
     let size = 0;
     for (let offset = 0; offset < text.length; ) {
-      await yieldTurn2(this.signal);
+      await yieldTurn4(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;
@@ -399,7 +609,7 @@ var StoredImageStack = class {
     const decoder = new TextDecoder();
     let text = "";
     for (let offset = 0; offset < size; offset += 4096) {
-      await yieldTurn2(this.signal);
+      await yieldTurn4(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());
@@ -448,12 +658,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 yieldTurn2(this.signal);
+      if (++work % 128 === 0) await yieldTurn4(this.signal);
       await removed.set(BigInt(index), 1n);
     }
     let next = 0;
     for (let index = 0; index < this.length; index++) {
-      if (index % 128 === 0) await yieldTurn2(this.signal);
+      if (index % 128 === 0) await yieldTurn4(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++;
@@ -463,89 +673,11 @@ var StoredImageStack = class {
 };
 
 // packages/safe-bash-command-imagemagick/src/remap.ts
-import { yieldTurn as yieldTurn4 } from "../safe-bash-contracts/yield.js";
-
-// packages/safe-bash-command-imagemagick/src/raster-backing.ts
-import { yieldTurn as yieldTurn3 } from "../safe-bash-contracts/yield.js";
-var RasterBackingCache = class {
-  constructor(storage, signal) {
-    this.storage = storage;
-    this.signal = signal;
-  }
-  storage;
-  signal;
-  pages = /* @__PURE__ */ new Map();
-  work = 0;
-  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 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 yieldTurn3(this.signal);
-    const start = Math.floor(offset / 4096) * 4096, key = region.position + ":" + start;
-    let page = this.pages.get(key);
-    if (page) {
-      this.pages.delete(key);
-      this.pages.set(key, page);
-      return page;
-    }
-    if (this.pages.size === 32) {
-      const oldest = this.pages.entries().next().value;
-      if (oldest[1].dirty) await this.storage.write(oldest[1].position, oldest[1].bytes, { signal: this.signal });
-      this.pages.delete(oldest[0]);
-    }
-    const length = Math.min(4096, region.length - start), borrowed = await this.storage.read(region.position + start, length, { signal: this.signal });
-    if (borrowed.length !== length) throw new Error("Truncated raster backing");
-    const bytes = new Uint8Array(borrowed);
-    page = { position: region.position + start, bytes, view: new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), dirty: false };
-    this.pages.set(key, page);
-    return page;
-  }
-  async byte(region, offset) {
-    return (await this.page(region, offset)).bytes[offset % 4096];
-  }
-  async mark(region, offset) {
-    const page = await this.page(region, offset);
-    page.bytes[offset % 4096] = 1;
-    page.dirty = true;
-  }
-  async uint32(region, offset) {
-    return (await this.page(region, offset)).view.getUint32(offset % 4096, true);
-  }
-  async setUint32(region, offset, value) {
-    const page = await this.page(region, offset);
-    page.view.setUint32(offset % 4096, value, true);
-    page.dirty = true;
-  }
-  async float32(region, offset) {
-    return (await this.page(region, offset)).view.getFloat32(offset % 4096, true);
-  }
-  async setFloat32(region, offset, value) {
-    const page = await this.page(region, offset);
-    page.view.setFloat32(offset % 4096, value, true);
-    page.dirty = true;
-  }
-  async flush() {
-    for (const page of this.pages.values()) {
-      this.signal.throwIfAborted();
-      if (page.dirty) {
-        await this.storage.write(page.position, page.bytes, { signal: this.signal });
-        page.dirty = false;
-      }
-    }
-  }
-};
-
-// packages/safe-bash-command-imagemagick/src/remap.ts
+import { yieldTurn as yieldTurn5 } 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 yieldTurn4(signal);
+    await yieldTurn5(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) {
@@ -560,7 +692,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 * 12), length: count * 12 } : void 0;
   if (errors) for (let start = 0; start < count; start += 1024) {
-    await yieldTurn4(signal);
+    await yieldTurn5(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 * 12), view = new DataView(bytes.buffer);
@@ -569,7 +701,7 @@ async function remapStoredImage(image, paletteImage, storage, dither, signal) {
   }
   const position = storage.allocate(count * 4);
   for (let start = 0; start < count; start += 1024) {
-    await yieldTurn4(signal);
+    await yieldTurn5(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++) {
@@ -609,12 +741,15 @@ async function remapStoredImage(image, paletteImage, storage, dither, signal) {
 }
 
 // packages/safe-bash-command-imagemagick/src/floodfill.ts
-import { yieldTurn as yieldTurn5 } from "../safe-bash-contracts/yield.js";
-async function floodfillStoredImage(image, storage, seedX, seedY, target, replacement, fuzz, signal) {
+import { yieldTurn as yieldTurn6 } 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;
+}
+async function floodfillStoredImage(image, storage, seedX, seedY, target, replacement, fuzz, signal, alphaOnly = false) {
   const count = image.width * image.height, source = { position: image.position, length: count * 4 }, cache = new RasterBackingCache(storage, signal);
   const start = seedY * image.width + seedX, seed = await cache.uint32(source, start * 4);
   const r = target ? target.r : seed & 255, g = target ? target.g : seed >>> 8 & 255, b = target ? target.b : seed >>> 16 & 255;
-  const matches = (pixel) => Math.max(Math.abs((pixel & 255) - r), Math.abs((pixel >>> 8 & 255) - g), Math.abs((pixel >>> 16 & 255) - b)) <= fuzz;
+  const matches = (pixel) => alphaOnly ? matchesAlphaFloodfill(pixel & 255, pixel >>> 8 & 255, pixel >>> 16 & 255, pixel >>> 24, r, g, b, seed >>> 24, fuzz) : Math.max(Math.abs((pixel & 255) - r), Math.abs((pixel >>> 8 & 255) - g), Math.abs((pixel >>> 16 & 255) - b)) <= fuzz;
   if (!matches(seed)) return image;
   const visited = await cache.allocate(count), stack = await cache.allocate(count * 4);
   let tail = 1;
@@ -631,14 +766,16 @@ 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 yieldTurn5(signal);
+    await yieldTurn6(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");
     for (let i = 0; i < length; i++) if (flags[i]) {
-      pixels[i * 4] = replacement.r;
-      pixels[i * 4 + 1] = replacement.g;
-      pixels[i * 4 + 2] = replacement.b;
+      if (!alphaOnly) {
+        pixels[i * 4] = replacement.r;
+        pixels[i * 4 + 1] = replacement.g;
+        pixels[i * 4 + 2] = replacement.b;
+      }
       pixels[i * 4 + 3] = replacement.a;
     }
     await storage.write(position + start2 * 4, pixels, { signal });
@@ -816,7 +953,7 @@ function* convolvePixelSteps(image, kernel, bias) {
 // 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 yieldTurn6 } from "../safe-bash-contracts/yield.js";
+import { yieldTurn as yieldTurn7 } from "../safe-bash-contracts/yield.js";
 var EncodedSnapshots = class {
   constructor(storage, signal) {
     this.storage = storage;
@@ -846,7 +983,7 @@ var EncodedSnapshots = class {
     };
     try {
       while (true) {
-        await yieldTurn6(this.signal);
+        await yieldTurn7(this.signal);
         const next = await encoder.next();
         if (next.done) {
           if (!next.value) throw new Error("Image encoding did not finish");
@@ -858,7 +995,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 yieldTurn6(this.signal);
+            await yieldTurn7(this.signal);
             await this.storage.write(position + 8 + start, bytes.subarray(start, start + 4096));
           }
           await this.buckets.set(hash, BigInt(position));
@@ -897,7 +1034,7 @@ var EncodedSnapshots = class {
     const decoder = new TextDecoder();
     let text = "";
     for (let start = 0; start < size; start += 4096) {
-      await yieldTurn6(this.signal);
+      await yieldTurn7(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());
@@ -907,7 +1044,7 @@ var EncodedSnapshots = class {
   async find(path, hash) {
     let position = Number(await this.buckets.get(hash) ?? -1n);
     while (position >= 0) {
-      await yieldTurn6(this.signal);
+      await yieldTurn7(this.signal);
       const record = await this.record(position);
       if (record.path === path) return record;
       position = record.next ?? -1;
@@ -971,7 +1108,7 @@ 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 yieldTurn7 } from "../safe-bash-contracts/yield.js";
+import { yieldTurn as yieldTurn8 } from "../safe-bash-contracts/yield.js";
 var CompareInputFailure = class extends Error {
   constructor(reason) {
     super("Comparison input failed");
@@ -996,7 +1133,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 yieldTurn7(signal);
+        await yieldTurn8(signal);
       await storage.write(position + offset, data.subarray(offset, offset + 16384));
     }
     return { ...metadata, position };
@@ -1037,7 +1174,7 @@ async function withCompareFiles(input, stdinBytes, signal, run) {
         }
         const encoded = snapshot ? (async function* () {
           for (let position = 0; position < snapshot.source.size; position += 16384) {
-            await yieldTurn7(signal);
+            await yieldTurn8(signal);
             yield new Uint8Array(await snapshot.source.read(position, Math.min(16384, snapshot.source.size - position), io));
           }
         })() : encodeStoredImage2(image, storage, signal, encoding), chunks = [];
@@ -1106,7 +1243,7 @@ async function withCompareFiles(input, stdinBytes, signal, run) {
               try {
                 let next = iterator.next();
                 while (!next.done) {
-                  await yieldTurn7(signal);
+                  await yieldTurn8(signal);
                   let configured = next.value, image;
                   try {
                     image = bytes ? await retain(decodeImage(bytes, configured)) : await decodeFileImage(checked, storage, fs, cwd, signal, configured);
@@ -1438,7 +1575,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 yieldTurn8, drainCooperativeSteps as drainSteps } from "../safe-bash-contracts/yield.js";
+import { yieldTurn as yieldTurn9, 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 {
@@ -1836,6 +1973,7 @@ function createDefaultState() {
     quality: 92,
     density: 72,
     fuzz: 10,
+    alphaFuzz: 0,
     kernel: "lanczos3",
     compose: "over",
     composeRaw: "Over",
@@ -1955,7 +2093,7 @@ function* createRoseImageSteps() {
     data
   };
 }
-function* applyMagickFloodfillSteps(img, geomStr, targetColor, replacement, fuzz, signal) {
+function* applyMagickFloodfillSteps(img, geomStr, targetColor, replacement, fuzz, signal, alphaOnly = false) {
   let cooperativeWork = 0;
   const g = parseMagickGeometry(geomStr);
   const w = img.width;
@@ -1969,6 +2107,7 @@ function* applyMagickFloodfillSteps(img, geomStr, targetColor, replacement, fuzz
   const refB = targetColor ? targetColor.b : out[seedOff + 2];
   const matchesRef = (pIdx) => {
     const off = pIdx * 4;
+    if (alphaOnly) return matchesAlphaFloodfill(out[off], out[off + 1], out[off + 2], out[off + 3], refR, refG, refB, img.data[seedOff + 3], fuzz);
     return Math.max(
       Math.abs(out[off] - refR),
       Math.abs(out[off + 1] - refG),
@@ -1988,9 +2127,11 @@ function* applyMagickFloodfillSteps(img, geomStr, targetColor, replacement, fuzz
       yield;
     const cur = queue[head++];
     const off = cur * 4;
-    out[off] = replacement.r;
-    out[off + 1] = replacement.g;
-    out[off + 2] = replacement.b;
+    if (!alphaOnly) {
+      out[off] = replacement.r;
+      out[off + 1] = replacement.g;
+      out[off + 2] = replacement.b;
+    }
     out[off + 3] = replacement.a;
     const cx = cur % w;
     const cy = Math.floor(cur / w);
@@ -4095,7 +4236,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 yieldTurn8(signal);
+    await yieldTurn9(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;
@@ -4207,14 +4348,14 @@ function* magickDrawSteps(img, drawCmd, state) {
       stroke = rgbaToCss(parseColor(tokens[i++] ?? "#000000"));
     } else if (cmd === "stroke-width" || cmd === "strokewidth") {
       strokeWidth = Math.max(0, num());
-    } else if (cmd === "color") {
+    } else if (cmd === "color" || cmd === "alpha") {
       const x = num(), y = num(), method = tokens[i++]?.toLowerCase();
-      if (method !== "floodfill" || !Number.isFinite(x) || !Number.isFinite(y)) throw new Error("Color drawing requires finite coordinates and the floodfill method");
+      if (method !== "floodfill" || !Number.isFinite(x) || !Number.isFinite(y)) throw new Error(`${cmd} drawing requires finite coordinates and the floodfill method`);
       if (svgElements.length > 0) {
         yield { kind: "svg", svg: `<svg xmlns="http://www.w3.org/2000/svg" width="${img.width}" height="${img.height}">${svgElements.join("")}</svg>` };
         svgElements.length = 0;
       }
-      yield { kind: "floodfill", x: Math.max(0, Math.min(img.width - 1, Math.round(x))), y: Math.max(0, Math.min(img.height - 1, Math.round(y))), color: parseColor(fill) };
+      yield { kind: "floodfill", x: Math.max(0, Math.min(img.width - 1, Math.round(x))), y: Math.max(0, Math.min(img.height - 1, Math.round(y))), color: parseColor(fill), alphaOnly: cmd === "alpha" };
     } else if (cmd === "rectangle") {
       const x0 = num();
       const y0 = num();
@@ -4764,7 +4905,7 @@ async function drainIdentifySteps(steps, signal) {
     while (!next.done) {
       try {
         if (next.value) await next.value.run();
-        else await yieldTurn8(signal);
+        else await yieldTurn9(signal);
         next = steps.next();
       } catch (error) {
         next = steps.throw(error);
@@ -4961,9 +5102,15 @@ function* applyMagickLookup(image, lookup) {
   }
   return { ...image, data };
 }
+function parseConnectedComponents(tokens, state, start) {
+  const value = tokens[start + 1];
+  if (tokens[start] !== "-connected-components") throw new Error(`Unsupported option: ${tokens[start]}`);
+  if (value !== "4" && value !== "8") throw new Error("connected-components: connectivity must be 4 or 8");
+  if (state.alphaFuzz !== 0) throw new Error("connected-components: nonzero fuzz is unsupported");
+  return Number(value);
+}
 function parseMagickAnalysisOperation(tokens, state, start) {
   const token = tokens[start];
-  if (token === "-connected-components") throw new Error("Unsupported option: -connected-components");
   if (!["-auto-level", "-auto-gamma", "-normalize", "-contrast-stretch", "-linear-stretch", "-equalize"].includes(token ?? "")) return;
   let end = start;
   const argument = token === "-normalize" ? "2%x1%" : token === "-contrast-stretch" || token === "-linear-stretch" ? tokens[++end] ?? "0%x0%" : "";
@@ -5252,7 +5399,7 @@ async function transformStoredMagickPixels(image, backend, operation, signal) {
   const size = image.width * image.height * 4, position = backend.storage.allocate(size);
   let result = image;
   for (let offset = 0; offset < size; offset += 16384) {
-    if (offset % 1048576 === 0) await yieldTurn8(signal);
+    if (offset % 1048576 === 0) await yieldTurn9(signal);
     const data = await backend.storage.read(image.position + offset, Math.min(16384, size - offset));
     const transformed = await drainSteps(operation.apply({ ...image, width: data.length / 4, height: 1, data }), signal);
     const { data: pixels, data16: ignored, ...metadata } = transformed;
@@ -5300,6 +5447,7 @@ function applyMagickReadSetting(tokens, state, start) {
     state.density = Math.max(1, Math.round(g.width ?? 72));
   } else if (t === "-fuzz") {
     const rawFuzz = tokens[++i] ?? "10";
+    state.alphaFuzz = rawFuzz.endsWith("%") ? parseFloat(rawFuzz) * 255 / 100 : parseFloat(rawFuzz) / 257;
     state.fuzz = rawFuzz.endsWith("%") ? Math.round(parseFloat(rawFuzz) / 100 * 255) : Math.round(parseFloat(rawFuzz));
   } else if (t === "-filter") {
     state.kernel = parseKernel(tokens[++i] ?? "lanczos");
@@ -5309,18 +5457,24 @@ function applyMagickReadSetting(tokens, state, start) {
     state.compose = parseCompose(cRaw);
   } else if (t === "-define") {
     const defStr = tokens[++i] ?? "";
+    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}`);
+      state.connectedVerbose = value === "true";
+    }
     const m = /^compose:args=(.*)$/i.exec(defStr);
     if (m)
       state.composeArgs = m[1];
   } else if (t === "-set") {
     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 === "option:compose:args")
       state.composeArgs = v;
   } else return void 0;
   return i;
 }
-function* evaluatePipelineTokensSteps(tokens, files, state, parentStack = [], stdinBytes, signal) {
+function* evaluatePipelineTokensSteps(tokens, files, state, parentStack = [], stdinBytes, signal, analysis = { text: "" }) {
   let cooperativeWork = 63;
   let stack = [];
   let operandsOnly = false;
@@ -5354,7 +5508,7 @@ function* evaluatePipelineTokensSteps(tokens, files, state, parentStack = [], st
       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);
+      const subResult = yield* evaluatePipelineTokensSteps(subTokens, files, subState, stack, stdinBytes, signal, analysis);
       stack.push(...subResult);
       i = j;
       continue;
@@ -5365,6 +5519,13 @@ function* evaluatePipelineTokensSteps(tokens, files, state, parentStack = [], st
     const analysisOperation = setting === void 0 && !pixelOperation ? parseMagickAnalysisOperation(tokens, state, i) : void 0;
     if (setting !== void 0) {
       i = setting;
+    } else if (t === "-connected-components" || t === "+connected-components") {
+      const connectivity = parseConnectedComponents(tokens, state, i++);
+      stack = yield* mapSteps(stack, function* (image) {
+        const result = yield* connectedComponentsSteps(image, connectivity, state.connectedVerbose ?? false);
+        analysis.text += result.text;
+        return result.image;
+      });
     } else if (analysisOperation) {
       i = analysisOperation.end;
       stack = yield* mapSteps(stack, function* (image) {
@@ -5709,7 +5870,7 @@ function* evaluatePipelineTokensSteps(tokens, files, state, parentStack = [], st
             continue;
           }
           if (step.kind === "shape") im = yield* applyMagickRasterSteps(im, drawShapePixelSteps(im, step), signal);
-          else if (step.kind === "floodfill") im = yield* applyMagickFloodfillSteps(im, `+${step.x}+${step.y}`, void 0, step.color, state.fuzz, signal);
+          else if (step.kind === "floodfill") im = yield* applyMagickFloodfillSteps(im, `+${step.x}+${step.y}`, void 0, step.color, step.alphaOnly ? state.alphaFuzz : state.fuzz, signal, step.alphaOnly);
           else {
             const overlay = decodeImage3(new TextEncoder().encode(step.svg), { density: state.density });
             im = yield* applyMagickRasterSteps(im, drawOverlayPixelSteps(im, overlay), signal, im, [im, overlay]);
@@ -5879,6 +6040,11 @@ function* evaluatePipelineTokensSteps(tokens, files, state, parentStack = [], st
   return stack;
 }
 function* runConvertCliSteps(argv, files, stdinBytes, signal) {
+  const analysis = { text: "" };
+  const result = yield* runConvertCliResultSteps(argv, files, stdinBytes, signal, analysis);
+  return { ...result, stdout: analysis.text + result.stdout };
+}
+function* runConvertCliResultSteps(argv, files, stdinBytes, signal, analysis = { text: "" }) {
   const listRes = tryHandleMagickListOption(argv);
   if (listRes) return listRes;
   let cooperativeWork = 63;
@@ -5901,7 +6067,7 @@ function* runConvertCliSteps(argv, files, stdinBytes, signal) {
   const pipelineTokens = argv.slice(0, -1);
   const state = createDefaultState();
   try {
-    const stack = yield* evaluatePipelineTokensSteps(pipelineTokens, files, state, [], stdinBytes, signal);
+    const stack = yield* evaluatePipelineTokensSteps(pipelineTokens, files, state, [], stdinBytes, signal, analysis);
     if (stack.length === 0) {
       return {
         exitCode: 1,
@@ -5912,6 +6078,7 @@ function* runConvertCliSteps(argv, files, stdinBytes, signal) {
     }
     const finalImg = stack[stack.length - 1];
     const outLower = outSpec.toLowerCase();
+    if (outLower === "null:") return { exitCode: 0, stdout: "", stderr: "" };
     if (outLower === "info:" || outLower === "info:-") {
       const formatted = [];
       for (const [idx, im] of stack.entries()) {
@@ -6020,7 +6187,7 @@ async function transformStoredMagickRaster(image, backend, steps, signal, dimens
     signal.throwIfAborted();
     const request = next.value;
     if (!request) {
-      await yieldTurn8(signal);
+      await yieldTurn9(signal);
       await checkpoint?.();
       next = steps.next();
     } else if (request.kind === "write") {
@@ -6051,7 +6218,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 yieldTurn8(signal);
+        await yieldTurn9(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)), signal);
@@ -6100,7 +6267,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 yieldTurn8(signal);
+      if (work++ % 64 === 0) await yieldTurn9(signal);
       const length = Math.min(4096, x.length - offset) * 4;
       const bytes = await backend.storage.read(image.position + ((y.source + row) * w + x.source + offset) * 4, length);
       await backend.storage.write(position + ((y.target + row) * width + x.target + offset) * 4, bytes);
@@ -6112,12 +6279,12 @@ async function compositeStoredMagick(base, overlay, backend, signal, left, top,
   let hasAlpha = base.hasAlpha || !generic && !magickCompositeMode(mode).delegated;
   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 yieldTurn8(signal);
+    await yieldTurn9(signal);
     await backend.storage.write(position + start, await backend.storage.read(base.position + start, Math.min(16384, base.width * base.height * 4 - start)));
   }
   for (let y = Math.max(0, top); y < Math.min(base.height, top + overlay.height); y++) {
     for (let x = Math.max(0, left); x < Math.min(base.width, left + overlay.width); x += 4096) {
-      await yieldTurn8(signal);
+      await yieldTurn9(signal);
       const count = Math.min(4096, Math.min(base.width, left + overlay.width) - x), destination = (y * base.width + x) * 4;
       const dst = { ...base, width: count, height: 1, data: new Uint8Array(await backend.storage.read(position + destination, count * 4)) };
       const src = { ...overlay, width: count, height: 1, data: new Uint8Array(await backend.storage.read(overlay.position + ((y - top) * overlay.width + x - left) * 4, count * 4)) };
@@ -6142,6 +6309,11 @@ async function compositeStoredMagick(base, overlay, backend, signal, left, top,
   return { ...base, position, hasAlpha };
 }
 async function tryConvertFiles(argv, input, stdinBytes, signal) {
+  const analysis = { text: "" };
+  const result = await tryConvertFilesResult(argv, input, stdinBytes, signal, analysis);
+  return result ? { ...result, stdout: analysis.text + result.stdout } : 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);
   const optionArgs = argv.slice(0, argv.indexOf("--") < 0 ? argv.length : argv.indexOf("--"));
@@ -6150,7 +6322,7 @@ async function tryConvertFiles(argv, input, stdinBytes, signal) {
     return drainSteps(runConvertCliSteps(argv, /* @__PURE__ */ new Map(), stdinBytes, signal), signal);
   }
   const output = inferOutputFormat(outSpec, "png");
-  await yieldTurn8(signal);
+  await yieldTurn9(signal);
   let state = createDefaultState();
   const tokens = argv.slice(0, -1), scopes = [];
   const steps = [];
@@ -6167,7 +6339,7 @@ async function tryConvertFiles(argv, input, stdinBytes, signal) {
   };
   try {
     for (let i = 0; i < tokens.length; i++) {
-      if (i && i % 64 === 0) await yieldTurn8(signal);
+      if (i && i % 64 === 0) await yieldTurn9(signal);
       const token = tokens[i];
       if (token === "") continue;
       if (!operandsOnly && token === "--") {
@@ -6210,19 +6382,19 @@ async function tryConvertFiles(argv, input, stdinBytes, signal) {
           if (token.endsWith("clone") || token.endsWith("duplicate")) {
             const source = stack.length ? stack : parents.at(-1) ?? stack, length = source.length;
             for (let repeat = 0; repeat < count; repeat++) for (const index of parseMagickIndexSpec(spec, length)) {
-              await yieldTurn8(signal);
+              await yieldTurn9(signal);
               await stack.push(await source.get(index));
             }
           } else if (token.endsWith("delete")) await stack.remove(parseMagickIndexSpec(spec, stack.length));
           else if (token === "-reverse") {
             for (let n = 0; n < Math.floor(stack.length / 2); n++) {
-              await yieldTurn8(signal);
+              await yieldTurn9(signal);
               await stack.swap(n, stack.length - 1 - n);
             }
           } else if (token.endsWith("insert")) {
             const raw = token === "+insert" ? 0 : Number(spec), target = raw < 0 ? Math.max(0, stack.length + raw) : Math.min(stack.length - 1, Math.max(0, raw));
             for (let n = stack.length - 1; n > target; n--) {
-              await yieldTurn8(signal);
+              await yieldTurn9(signal);
               await stack.swap(n, n - 1);
             }
           } else {
@@ -6271,7 +6443,7 @@ async function tryConvertFiles(argv, input, stdinBytes, signal) {
               const a = await stack.get(index), b = await stack.get(index + 1);
               await result.push(a);
               for (let step = 1; step <= count; step++) {
-                await yieldTurn8(signal);
+                await yieldTurn9(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));
                 const first = await resize(a, width, height), last = await resize(b, width, height);
                 await result.push(await transformStoredMagickRaster(first, backend, interpolatePixelSteps(width * height * 4, fraction), signal, first, [first, last]));
@@ -6311,6 +6483,17 @@ async function tryConvertFiles(argv, input, stdinBytes, signal) {
         steps.push(async (image, backend) => image ? transformStoredMagickPixels(image, backend, pixelOperation, signal) : void 0);
         continue;
       }
+      if (!operandsOnly && (token === "-connected-components" || token === "+connected-components")) {
+        const connectivity = parseConnectedComponents(tokens, state, i++), verbose = state.connectedVerbose ?? false;
+        steps.push(async (image, backend) => {
+          if (!image) return;
+          const result = await connectedComponentsStored(image, backend.storage, connectivity, verbose, signal);
+          if (input.stdout) await writeIdentifyText(input.stdout, result.text, signal);
+          else analysis.text += result.text;
+          return result.image;
+        });
+        continue;
+      }
       const analysisOperation = operandsOnly ? void 0 : parseMagickAnalysisOperation(tokens, state, i);
       if (analysisOperation) {
         i = analysisOperation.end;
@@ -6318,7 +6501,7 @@ async function tryConvertFiles(argv, input, stdinBytes, signal) {
           if (!image) return;
           const histogram = Array.from({ length: 4 }, () => new Float64Array(256)), size = image.width * image.height * 4;
           for (let offset = 0; offset < size; offset += 16384) {
-            if (offset % 1048576 === 0) await yieldTurn8(signal);
+            if (offset % 1048576 === 0) await yieldTurn9(signal);
             await drainSteps(accumulateMagickHistogram(await backend.storage.read(image.position + offset, Math.min(16384, size - offset)), histogram), signal);
           }
           const lookup = analysisOperation.lookup(histogram, image);
@@ -6352,7 +6535,7 @@ async function tryConvertFiles(argv, input, stdinBytes, signal) {
           if (append && stack.length === 1) return stack;
           let width = 0, height = 0;
           for (let n = 0; n < stack.length; n++) {
-            await yieldTurn8(signal);
+            await yieldTurn9(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);
@@ -6420,7 +6603,7 @@ async function tryConvertFiles(argv, input, stdinBytes, signal) {
             const output2 = inferOutputFormat(path, image.format);
             if (stack.length > 1 && (hasSceneOutputPattern(output2.path) || !adjoin)) {
               for (let index = 0; index < stack.length; index++) {
-                await yieldTurn8(signal);
+                await yieldTurn9(signal);
                 await backend.stage(await stack.get(index), formatSceneOutputPath(output2.path, index), { format: output2.format, quality });
               }
             } else await backend.stage(image, output2.path, { format: output2.format, quality });
@@ -6466,11 +6649,11 @@ async function tryConvertFiles(argv, input, stdinBytes, signal) {
           if (!image) return;
           for (const step of magickDrawSteps(image, drawing, settings)) {
             if (!step) {
-              await yieldTurn8(signal);
+              await yieldTurn9(signal);
               continue;
             }
             if (step.kind === "shape") image = await transformStoredMagickRaster(image, backend, drawShapePixelSteps(image, step), signal);
-            else if (step.kind === "floodfill") image = await floodfillStoredImage(image, backend.storage, step.x, step.y, void 0, step.color, settings.fuzz, signal);
+            else if (step.kind === "floodfill") image = await floodfillStoredImage(image, backend.storage, step.x, step.y, void 0, step.color, step.alphaOnly ? settings.alphaFuzz : settings.fuzz, signal, step.alphaOnly);
             else {
               const overlay = await decodeStoredMagickSvg(step.svg, settings.density, backend, signal);
               image = await transformStoredMagickRaster(image, backend, drawOverlayPixelSteps(image, overlay), signal, image, [image, overlay]);
@@ -6675,13 +6858,17 @@ async function tryConvertFiles(argv, input, stdinBytes, signal) {
       return { exitCode: 1, stdout: "", stderr: `magick: no images defined '${outSpec}'
 ` };
     }
-    await yieldTurn8(signal);
+    await yieldTurn9(signal);
+    if (outSpec.toLowerCase() === "null:") {
+      await backend.publishPending();
+      return { exitCode: 0, stdout: "", stderr: "" };
+    }
     const lower = outSpec.toLowerCase(), info = lower === "info:" || lower === "info:-";
     if (info || lower.startsWith("txt:") || lower.startsWith("histogram:")) {
       async function* information() {
         let last = "";
         for (let index = 0; index < stack.length; index++) {
-          await yieldTurn8(signal);
+          await yieldTurn9(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} sRGB 8-bit`;
@@ -6707,7 +6894,7 @@ async function tryConvertFiles(argv, input, stdinBytes, signal) {
     }
     if (stack.length > 1 && (hasSceneOutputPattern(output.path) || !state.adjoin)) {
       for (let index = 0; index < stack.length; index++) {
-        await yieldTurn8(signal);
+        await yieldTurn9(signal);
         await backend.stage(await stack.get(index), formatSceneOutputPath(output.path, index), { format: output.format, quality: state.quality });
       }
       await backend.publishPending();
@@ -6723,7 +6910,7 @@ async function tryConvertFiles(argv, input, stdinBytes, signal) {
           frame = await transformStoredImage(frame, backend.storage, { kind: "resize", ...resize }, signal);
         }
         for (let offset = 0; offset < size; offset += 16384) {
-          await yieldTurn8(signal);
+          await yieldTurn9(signal);
           await backend.storage.write(position + index * size + offset, await backend.storage.read(frame.position + offset, Math.min(16384, size - offset)));
         }
       }
@@ -6971,13 +7158,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 yieldTurn8(active);
+        await yieldTurn9(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 yieldTurn8(active);
+      await yieldTurn9(active);
       const token = argv[index];
       if (!operandsOnly && token === "--") {
         operandsOnly = true;
@@ -7037,7 +7224,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 yieldTurn8(signal);
+      if (start % 262144 === 0) await yieldTurn9(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;
@@ -7099,7 +7286,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 yieldTurn8(signal);
+      if (start % 262144 === 0) await yieldTurn9(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;
@@ -7660,7 +7847,7 @@ async function runMontageFiles(argv, input, stdinBytes, signal) {
       } };
     };
     for (let index = 0; index < paths.length; index++) {
-      await yieldTurn8(signal);
+      await yieldTurn9(signal);
       const token = paths[index];
       let path2 = parseInputToken(token.toLowerCase().startsWith("tile:") ? token.slice(5) : token).baseToken;
       const colon = path2.indexOf(":");
@@ -7668,7 +7855,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 yieldTurn8(signal);
+          await yieldTurn9(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));
@@ -7698,7 +7885,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 yieldTurn8(signal);
+          await yieldTurn9(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));
@@ -7752,7 +7939,7 @@ async function runMontageFiles(argv, input, stdinBytes, signal) {
     let canvas = await createStoredCanvas(Math.max(1, cols * slotW), Math.max(1, rows * slotH), state.background, backend, signal);
     let anyTransparent = state.background.a < 255 || borderW > 0 && state.borderColor.a < 255;
     for (let index = 0; index < n; index++) {
-      await yieldTurn8(signal);
+      await yieldTurn9(signal);
       const col = index % cols, row = Math.floor(index / cols);
       if (row >= rows) break;
       let image, directPng = false;
@@ -7775,13 +7962,13 @@ async function runMontageFiles(argv, input, stdinBytes, signal) {
       if (fast && borderW > 0 && state.borderColor.a > 0) {
         const border = await createStoredCanvas(width, height, state.borderColor, backend, signal), empty = new Uint8Array(16384);
         for (let row2 = borderW; row2 < height - borderW; row2++) for (let start = borderW; start < width - borderW; start += 4096) {
-          await yieldTurn8(signal);
+          await yieldTurn9(signal);
           await backend.storage.write(border.position + (row2 * width + start) * 4, empty.subarray(0, Math.min(4096, width - borderW - start) * 4));
         }
         canvas = await compositeStoredMagick(canvas, border, backend, signal, x, y, "over", void 0, false, true, true);
       }
       if (!anyTransparent) for (let start = 0; start < image.width * image.height * 4; start += 16384) {
-        await yieldTurn8(signal);
+        await yieldTurn9(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;
@@ -7867,7 +8054,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 yieldTurn8(context.signal);
+    if (++cooperativeWork % 64 === 0) await yieldTurn9(context.signal);
     if (!operandsOnly && token === "--") {
       operandsOnly = true;
       continue;
@@ -7902,7 +8089,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 yieldTurn8(context.signal);
+      if (++cooperativeWork % 64 === 0) await yieldTurn9(context.signal);
       chargeInput(chunk.byteLength);
       chunks.push(chunk);
       total += chunk.byteLength;
@@ -7910,7 +8097,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 yieldTurn8(context.signal);
+      if (++cooperativeWork % 64 === 0) await yieldTurn9(context.signal);
       stdinBytes.set(chunk, off);
       off += chunk.byteLength;
     }
@@ -7930,7 +8117,7 @@ async function runBufferedImageFiles(argv, input, runner, stdinBytes, signal) {
     delivered = { ...result, stdout: "" };
   }
   for (const [key, val] of vfsFiles.entries()) {
-    if (++cooperativeWork % 64 === 0) await yieldTurn8(context.signal);
+    if (++cooperativeWork % 64 === 0) await yieldTurn9(context.signal);
     if (existingSnap.get(key) !== val) {
       const abs = resolvePath3(context.cwd, key);
       await writeFileOutput2(context, val, (data) => context.fs.writeFile(abs, data, { signal }));