@poe-platform/safe-bash 0.1.787 → 0.1.789

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

@@ -36,6 +36,8 @@ import {
 
 // packages/safe-bash-command-imagemagick/dist/index.js
 init_buffer();
+import { yieldTurn, drainCooperativeSteps as drainSteps } from "../safe-bash-contracts/yield.js";
+import { InputByteBudget } from "../safe-bash-contracts/io.js";
 import { writeFileOutput } from "../safe-bash-contracts/filesystem-output-budget.js";
 import {
   commandRuntimeIdentity,
@@ -445,7 +447,8 @@ function createDefaultState() {
     channelExplicit: false
   };
 }
-function applyMagickMorphology4Ch(img, methodRaw, kernelSpec) {
+function* applyMagickMorphology4ChSteps(img, methodRaw, kernelSpec, signal) {
+  let cooperativeWork = 0;
   const m = methodRaw.toLowerCase();
   let rx = 1;
   let ry = 1;
@@ -504,13 +507,23 @@ function applyMagickMorphology4Ch(img, methodRaw, kernelSpec) {
     const out = new Uint8Array(img.data.length);
     const win = [];
     for (let y = 0; y < h; y++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       for (let x = 0; x < w; x++) {
+        if (++cooperativeWork % 65536 === 0)
+          yield;
         const dstOff = (y * w + x) * 4;
         for (let c = 0; c < 4; c++) {
+          if (++cooperativeWork % 65536 === 0)
+            yield;
           win.length = 0;
           for (let dy = -ry; dy <= ry; dy++) {
+            if (++cooperativeWork % 65536 === 0)
+              yield;
             const sy = Math.max(0, Math.min(h - 1, y + dy));
             for (let dx = -rx; dx <= rx; dx++) {
+              if (++cooperativeWork % 65536 === 0)
+                yield;
               const sx = Math.max(0, Math.min(w - 1, x + dx));
               win.push(img.data[(sy * w + sx) * 4 + c]);
             }
@@ -552,7 +565,8 @@ function createRoseImage() {
     data
   };
 }
-function applyMagickFloodfill(img, geomStr, targetColor, replacement, fuzz) {
+function* applyMagickFloodfillSteps(img, geomStr, targetColor, replacement, fuzz, signal) {
+  let cooperativeWork = 0;
   const g = parseMagickGeometry(geomStr);
   const w = img.width;
   const h = img.height;
@@ -580,6 +594,8 @@ function applyMagickFloodfill(img, geomStr, targetColor, replacement, fuzz) {
   queue[tail++] = startIdx;
   visited[startIdx] = 1;
   while (head < tail) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     const cur = queue[head++];
     const off = cur * 4;
     out[off] = replacement.r;
@@ -595,6 +611,8 @@ function applyMagickFloodfill(img, geomStr, targetColor, replacement, fuzz) {
       cy + 1 < h ? cur + w : -1
     ];
     for (const nb of neighbors) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       if (nb >= 0 && visited[nb] === 0 && matchesRef(nb)) {
         visited[nb] = 1;
         queue[tail++] = nb;
@@ -603,7 +621,8 @@ function applyMagickFloodfill(img, geomStr, targetColor, replacement, fuzz) {
   }
   return { ...img, data: out, hasAlpha: true };
 }
-function applyMagickEvaluateSequence(stack, opRaw) {
+function* applyMagickEvaluateSequenceSteps(stack, opRaw, signal) {
+  let cooperativeWork = 0;
   if (stack.length === 0) {
     throw new Error("evaluate-sequence requires at least one image");
   }
@@ -611,25 +630,28 @@ function applyMagickEvaluateSequence(stack, opRaw) {
   const base = stack[0];
   const w = base.width;
   const h = base.height;
-  const normalized = stack.map(
-    (im) => im.width === w && im.height === h ? im : applyMagickResize(im, `${w}x${h}!`, "bilinear")
-  );
+  const normalized = stack.map((im) => im.width === w && im.height === h ? im : applyMagickResize(im, `${w}x${h}!`, "bilinear"));
   const n = normalized.length;
   const out = new Uint8Array(w * h * 4);
   const op = opRaw.toLowerCase().replace(/[-_]/g, "");
   const vals = new Float64Array(n);
   for (let i = 0; i < out.length; i++) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     if ((i & 3) === 3) {
       out[i] = base.data[i];
       continue;
     }
     for (let k = 0; k < n; k++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       vals[k] = normalized[k].data[i];
     }
     let res = vals[0];
     if (op === "mean" || op === "average") {
       let s = 0;
-      for (let k = 0; k < n; k++) s += vals[k];
+      for (let k = 0; k < n; k++)
+        s += vals[k];
       res = s / n;
     } else if (op === "median") {
       const baseOff = i & ~3;
@@ -647,33 +669,47 @@ function applyMagickEvaluateSequence(stack, opRaw) {
       res = Math.max(...vals);
     } else if (op === "add") {
       let s = 0;
-      for (let k = 0; k < n; k++) s += vals[k];
+      for (let k = 0; k < n; k++)
+        s += vals[k];
       res = s;
     } else if (op === "multiply") {
       let p = 1;
-      for (let k = 0; k < n; k++) p *= vals[k] / 255;
+      for (let k = 0; k < n; k++)
+        p *= vals[k] / 255;
       res = p * 255;
     }
     out[i] = clampByteVal(res);
   }
   return { ...base, data: out };
 }
-function applyMagickCustomConvolve(img, spec) {
+function* applyMagickCustomConvolveSteps(img, spec, signal) {
+  let cooperativeWork = 0;
   const afterColon = spec.includes(":") ? spec.slice(spec.indexOf(":") + 1) : spec;
   const coeffs = afterColon.trim().split(/[\s,]+/).filter((s) => s.length > 0).map(Number).filter((n) => Number.isFinite(n));
-  if (coeffs.length === 0) return img;
+  if (coeffs.length === 0)
+    return img;
   const side = Math.max(1, Math.round(Math.sqrt(coeffs.length)));
   const half = Math.floor(side / 2);
   const w = img.width;
   const h = img.height;
   const out = new Uint8Array(img.data);
   for (let y = 0; y < h; y++) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     for (let x = 0; x < w; x++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       for (let c = 0; c < 3; c++) {
+        if (++cooperativeWork % 65536 === 0)
+          yield;
         let sum = 0;
         for (let ky = 0; ky < side; ky++) {
+          if (++cooperativeWork % 65536 === 0)
+            yield;
           const sy = Math.max(0, Math.min(h - 1, y + ky - half));
           for (let kx = 0; kx < side; kx++) {
+            if (++cooperativeWork % 65536 === 0)
+              yield;
             const sx = Math.max(0, Math.min(w - 1, x + kx - half));
             const weight = coeffs[ky * side + kx] ?? 0;
             sum += img.data[(sy * w + sx) * 4 + c] * weight;
@@ -685,51 +721,66 @@ function applyMagickCustomConvolve(img, spec) {
   }
   return { ...img, data: out };
 }
-function applyMagickColorMatrix(img, spec) {
+function* applyMagickColorMatrixSteps(img, spec, signal) {
+  let cooperativeWork = 0;
   const afterColon = spec.includes(":") ? spec.slice(spec.indexOf(":") + 1) : spec;
   const m = afterColon.trim().split(/[\s,]+/).filter((s) => s.length > 0).map(Number);
-  if (m.length < 9) return img;
+  if (m.length < 9)
+    return img;
   const out = new Uint8Array(img.data);
   const cols = m.length >= 16 ? Math.round(Math.sqrt(m.length)) : 3;
   for (let i = 0; i < out.length; i += 4) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     const r = out[i];
     const g = out[i + 1];
     const b = out[i + 2];
     out[i] = clampByteVal((m[0] ?? 1) * r + (m[1] ?? 0) * g + (m[2] ?? 0) * b);
     out[i + 1] = clampByteVal((m[cols] ?? 0) * r + (m[cols + 1] ?? 1) * g + (m[cols + 2] ?? 0) * b);
-    out[i + 2] = clampByteVal(
-      (m[cols * 2] ?? 0) * r + (m[cols * 2 + 1] ?? 0) * g + (m[cols * 2 + 2] ?? 1) * b
-    );
+    out[i + 2] = clampByteVal((m[cols * 2] ?? 0) * r + (m[cols * 2 + 1] ?? 0) * g + (m[cols * 2 + 2] ?? 1) * b);
   }
   return { ...img, data: out };
 }
-function applyMagickEqualize(img) {
+function* applyMagickEqualizeSteps(img, signal) {
+  let cooperativeWork = 0;
   const out = new Uint8Array(img.data);
   const totalPixels = Math.max(1, img.width * img.height);
   for (let c = 0; c < 3; c++) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     const hist = new Uint32Array(256);
     for (let i = c; i < out.length; i += 4) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       hist[out[i]]++;
     }
     const lut = new Uint8Array(256);
     let cdf = 0;
     let cdfMin = 0;
     for (let v = 0; v < 256; v++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       cdf += hist[v];
-      if (cdfMin === 0 && cdf > 0) cdfMin = cdf;
+      if (cdfMin === 0 && cdf > 0)
+        cdfMin = cdf;
       const denom = Math.max(1, totalPixels - cdfMin);
       lut[v] = clampByteVal((cdf - cdfMin) / denom * 255);
     }
     for (let i = c; i < out.length; i += 4) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       out[i] = lut[out[i]];
     }
   }
   return { ...img, data: out };
 }
-function applyMagickRemap(img, palImg, dither) {
+function* applyMagickRemapSteps(img, palImg, dither, signal) {
+  let cooperativeWork = 0;
   const palette = [];
   const seen = /* @__PURE__ */ new Set();
   for (let i = 0; i < palImg.data.length; i += 4) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     const r = palImg.data[i];
     const g = palImg.data[i + 1];
     const b = palImg.data[i + 2];
@@ -737,16 +788,22 @@ function applyMagickRemap(img, palImg, dither) {
     if (!seen.has(key)) {
       seen.add(key);
       palette.push({ r, g, b });
-      if (palette.length >= 256) break;
+      if (palette.length >= 256)
+        break;
     }
   }
-  if (palette.length === 0) return img;
+  if (palette.length === 0)
+    return img;
   const w = img.width;
   const h = img.height;
   const buf = new Float32Array(img.data);
   const out = new Uint8Array(img.data);
   for (let y = 0; y < h; y++) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     for (let x = 0; x < w; x++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       const idx = (y * w + x) * 4;
       const oldR = Math.max(0, Math.min(255, buf[idx]));
       const oldG = Math.max(0, Math.min(255, buf[idx + 1]));
@@ -754,6 +811,8 @@ function applyMagickRemap(img, palImg, dither) {
       let best = palette[0];
       let bestDist = Infinity;
       for (const p of palette) {
+        if (++cooperativeWork % 65536 === 0)
+          yield;
         const d = (oldR - p.r) ** 2 + (oldG - p.g) ** 2 + (oldB - p.b) ** 2;
         if (d < bestDist) {
           bestDist = d;
@@ -768,7 +827,8 @@ function applyMagickRemap(img, palImg, dither) {
         const errG = oldG - best.g;
         const errB = oldB - best.b;
         const spread = (nx, ny, wgt) => {
-          if (nx < 0 || nx >= w || ny < 0 || ny >= h) return;
+          if (nx < 0 || nx >= w || ny < 0 || ny >= h)
+            return;
           const nIdx = (ny * w + nx) * 4;
           buf[nIdx] = buf[nIdx] + errR * wgt;
           buf[nIdx + 1] = buf[nIdx + 1] + errG * wgt;
@@ -909,7 +969,8 @@ function createCheckerboardImage(width, height) {
     data
   };
 }
-function applyMagickSplice(img, geomStr, bg, gravity = "northwest") {
+function* applyMagickSpliceSteps(img, geomStr, bg, gravity = "northwest", signal) {
+  let cooperativeWork = 0;
   const g = parseMagickGeometry(geomStr);
   const sw = Math.max(0, Math.round(g.width ?? 0));
   const sh = Math.max(0, Math.round(g.height ?? 0));
@@ -922,7 +983,11 @@ function applyMagickSplice(img, geomStr, bg, gravity = "northwest") {
   const outH = img.height + sh;
   const out = new Uint8Array(outW * outH * 4);
   for (let y = 0; y < outH; y++) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     for (let x = 0; x < outW; x++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       const dstIdx = (y * outW + x) * 4;
       if (x >= sx && x < sx + sw || y >= sy && y < sy + sh) {
         out[dstIdx] = bg.r;
@@ -942,7 +1007,8 @@ function applyMagickSplice(img, geomStr, bg, gravity = "northwest") {
   }
   return { ...img, width: outW, height: outH, data: out, hasAlpha: true };
 }
-function applyMagickChop(img, geomStr, gravity = "northwest") {
+function* applyMagickChopSteps(img, geomStr, gravity = "northwest", signal) {
+  let cooperativeWork = 0;
   const g = parseMagickGeometry(geomStr);
   const cw = Math.max(0, Math.round(g.width ?? 0));
   const ch = Math.max(0, Math.round(g.height ?? 0));
@@ -963,8 +1029,12 @@ function applyMagickChop(img, geomStr, gravity = "northwest") {
   const outH = img.height - choppedH;
   const out = new Uint8Array(outW * outH * 4);
   for (let y = 0; y < outH; y++) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     const srcY = y < cy0 ? y : Math.min(img.height - 1, y + choppedH);
     for (let x = 0; x < outW; x++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       const srcX = x < cx0 ? x : Math.min(img.width - 1, x + choppedW);
       const dstIdx = (y * outW + x) * 4;
       const srcIdx = (srcY * img.width + srcX) * 4;
@@ -976,7 +1046,8 @@ function applyMagickChop(img, geomStr, gravity = "northwest") {
   }
   return { ...img, width: outW, height: outH, data: out };
 }
-function applyMagickRoll(img, geomStr) {
+function* applyMagickRollSteps(img, geomStr, signal) {
+  let cooperativeWork = 0;
   const g = parseMagickGeometry(geomStr);
   const rx = Math.round(g.x || g.width || 0);
   const ry = Math.round(g.y || g.height || 0);
@@ -984,8 +1055,12 @@ function applyMagickRoll(img, geomStr) {
   const h = img.height;
   const out = new Uint8Array(img.data.length);
   for (let y = 0; y < h; y++) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     const sy = ((y - ry) % h + h) % h;
     for (let x = 0; x < w; x++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       const sx = ((x - rx) % w + w) % w;
       const dstIdx = (y * w + x) * 4;
       const srcIdx = (sy * w + sx) * 4;
@@ -997,15 +1072,21 @@ function applyMagickRoll(img, geomStr) {
   }
   return { ...img, data: out };
 }
-function applyMagickMorph(stack, countRaw) {
+function* applyMagickMorphSteps(stack, countRaw, signal) {
+  let cooperativeWork = 0;
   const count = Math.max(0, Math.round(countRaw));
-  if (stack.length < 2 || count === 0) return [...stack];
+  if (stack.length < 2 || count === 0)
+    return [...stack];
   const out = [];
   for (let idx = 0; idx < stack.length - 1; idx++) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     const a = stack[idx];
     const b = stack[idx + 1];
     out.push(a);
     for (let step = 1; step <= count; step++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       const t = step / (count + 1);
       const w = Math.max(1, Math.round(a.width * (1 - t) + b.width * t));
       const h = Math.max(1, Math.round(a.height * (1 - t) + b.height * t));
@@ -1013,6 +1094,8 @@ function applyMagickMorph(stack, countRaw) {
       const rb = b.width === w && b.height === h ? b : applyMagickResize(b, `${w}x${h}!`, "bilinear");
       const data = new Uint8Array(w * h * 4);
       for (let p = 0; p < data.length; p++) {
+        if (++cooperativeWork % 65536 === 0)
+          yield;
         data[p] = clampByteVal(ra.data[p] * (1 - t) + rb.data[p] * t);
       }
       out.push({ ...ra, width: w, height: h, data });
@@ -1060,9 +1143,12 @@ function clampByteVal(n) {
   if (!Number.isFinite(n)) return 0;
   return Math.max(0, Math.min(255, Math.round(n)));
 }
-function applyMagickOpaque(img, target, replacement, fuzz, invert) {
+function* applyMagickOpaqueSteps(img, target, replacement, fuzz, invert, signal) {
+  let cooperativeWork = 0;
   const out = new Uint8Array(img.data);
   for (let i = 0; i < out.length; i += 4) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     const dr = Math.abs(out[i] - target.r);
     const dg = Math.abs(out[i + 1] - target.g);
     const db = Math.abs(out[i + 2] - target.b);
@@ -1076,9 +1162,12 @@ function applyMagickOpaque(img, target, replacement, fuzz, invert) {
   }
   return { ...img, data: out, hasAlpha: true };
 }
-function applyMagickTransparent(img, target, fuzz, invert) {
+function* applyMagickTransparentSteps(img, target, fuzz, invert, signal) {
+  let cooperativeWork = 0;
   const out = new Uint8Array(img.data);
   for (let i = 0; i < out.length; i += 4) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     const dr = Math.abs(out[i] - target.r);
     const dg = Math.abs(out[i + 1] - target.g);
     const db = Math.abs(out[i + 2] - target.b);
@@ -1089,7 +1178,8 @@ function applyMagickTransparent(img, target, fuzz, invert) {
   }
   return { ...img, data: out, hasAlpha: true };
 }
-function applyMagickEvaluate(img, opRaw, valStr, channels) {
+function* applyMagickEvaluateSteps(img, opRaw, valStr, channels, signal) {
+  let cooperativeWork = 0;
   const op = opRaw.toLowerCase().replace(/[-_]/g, "");
   const isPct = valStr.trim().endsWith("%");
   const rawNum = parseFloat(valStr);
@@ -1098,8 +1188,13 @@ function applyMagickEvaluate(img, opRaw, valStr, channels) {
   const out = new Uint8Array(img.data);
   const mask = [channels.r, channels.g, channels.b, channels.a];
   for (let i = 0; i < out.length; i += 4) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     for (let c = 0; c < 4; c++) {
-      if (!mask[c]) continue;
+      if (++cooperativeWork % 65536 === 0)
+        yield;
+      if (!mask[c])
+        continue;
       const cur = out[i + c];
       let next = cur;
       switch (op) {
@@ -1177,14 +1272,20 @@ function applyMagickEvaluate(img, opRaw, valStr, channels) {
   }
   return { ...img, data: out };
 }
-function applyMagickFunction(img, funcRaw, paramsRaw, channels) {
+function* applyMagickFunctionSteps(img, funcRaw, paramsRaw, channels, signal) {
+  let cooperativeWork = 0;
   const fn = funcRaw.toLowerCase();
   const params = paramsRaw.split(",").map((s) => Number(s.trim()));
   const out = new Uint8Array(img.data);
   const mask = [channels.r, channels.g, channels.b, channels.a];
   for (let i = 0; i < out.length; i += 4) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     for (let c = 0; c < 4; c++) {
-      if (!mask[c]) continue;
+      if (++cooperativeWork % 65536 === 0)
+        yield;
+      if (!mask[c])
+        continue;
       const x = out[i + c] / 255;
       let y = x;
       if (fn === "polynomial") {
@@ -1214,14 +1315,20 @@ function applyMagickFunction(img, funcRaw, paramsRaw, channels) {
   }
   return { ...img, data: out };
 }
-function applyMagickClut(baseImg, lutImg, channels) {
+function* applyMagickClutSteps(baseImg, lutImg, channels, signal) {
+  let cooperativeWork = 0;
   const out = new Uint8Array(baseImg.data);
   const horiz = lutImg.width >= lutImg.height;
   const len = Math.max(1, horiz ? lutImg.width : lutImg.height);
   const mask = [channels.r, channels.g, channels.b, channels.a];
   for (let i = 0; i < out.length; i += 4) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     for (let c = 0; c < 4; c++) {
-      if (!mask[c]) continue;
+      if (++cooperativeWork % 65536 === 0)
+        yield;
+      if (!mask[c])
+        continue;
       const t = out[i + c] / 255;
       const pos = Math.max(0, Math.min(len - 1, Math.round(t * (len - 1))));
       const lx = horiz ? pos : 0;
@@ -1614,17 +1721,25 @@ function compileSingleFxExpr(src) {
   }
   return parseTernary();
 }
-function applyMagickFx(stack, exprStr, channels) {
+function* applyMagickFxSteps(stack, exprStr, channels, signal) {
+  let cooperativeWork = 0;
   const base = stack[0];
   const out = new Uint8Array(base.data);
   const evalFn = compileFxExpression(exprStr);
   const mask = [channels.r, channels.g, channels.b, channels.a];
   const vars = /* @__PURE__ */ new Map();
   for (let y = 0; y < base.height; y++) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     for (let x = 0; x < base.width; x++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       const idx = (y * base.width + x) * 4;
       for (let c = 0; c < 4; c++) {
-        if (!mask[c]) continue;
+        if (++cooperativeWork % 65536 === 0)
+          yield;
+        if (!mask[c])
+          continue;
         vars.clear();
         const val = evalFn({
           stack,
@@ -1665,7 +1780,8 @@ function sampleBilinear(img, sx, sy, bg, out, outOff) {
     out[outOff + c] = clampByteVal(v0 * (1 - fy) + v1 * fy);
   }
 }
-function applyMagickShear(img, geomStr, bg) {
+function* applyMagickShearSteps(img, geomStr, bg, signal) {
+  let cooperativeWork = 0;
   const g = parseMagickGeometry(geomStr);
   const degX = g.width ?? 0;
   const degY = g.height ?? 0;
@@ -1680,7 +1796,11 @@ function applyMagickShear(img, geomStr, bg) {
   const cyDst = (outH - 1) / 2;
   const det = 1 - tanX * tanY || 1;
   for (let y = 0; y < outH; y++) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     for (let x = 0; x < outW; x++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       const dx = x - cxDst;
       const dy = y - cyDst;
       const sx = cxSrc + (dx - tanX * dy) / det;
@@ -1714,7 +1834,8 @@ function solveLinearSystem(A, b) {
   }
   return M.map((row) => row[n]);
 }
-function applyMagickDistort(img, methodRaw, argsRaw, bg) {
+function* applyMagickDistortSteps(img, methodRaw, argsRaw, bg, signal) {
+  let cooperativeWork = 0;
   const method = methodRaw.toLowerCase().replace(/[-_]/g, "");
   const nums = argsRaw.trim().split(/[\s,]+/).filter((s) => s.length > 0).map(Number);
   const w = img.width;
@@ -1768,7 +1889,11 @@ function applyMagickDistort(img, methodRaw, argsRaw, bg) {
     const cosA = Math.cos(rad);
     const sinA = Math.sin(rad);
     for (let y = 0; y < h; y++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       for (let x = 0; x < w; x++) {
+        if (++cooperativeWork % 65536 === 0)
+          yield;
         const dx = x - nx;
         const dy = y - ny;
         const sx = cx + (dx * cosA + dy * sinA) / scaleX;
@@ -1786,6 +1911,8 @@ function applyMagickDistort(img, methodRaw, argsRaw, bg) {
       const A = [];
       const bVec = [];
       for (let p = 0; p < 4; p++) {
+        if (++cooperativeWork % 65536 === 0)
+          yield;
         const sx = nums[p * 4];
         const sy = nums[p * 4 + 1];
         const dx = nums[p * 4 + 2];
@@ -1802,7 +1929,11 @@ function applyMagickDistort(img, methodRaw, argsRaw, bg) {
     }
     const [c0, c1, c2, c3, c4, c5, c6, c7] = hCoeff;
     for (let y = 0; y < h; y++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       for (let x = 0; x < w; x++) {
+        if (++cooperativeWork % 65536 === 0)
+          yield;
         const denom = c6 * x + c7 * y + 1 || 1e-9;
         const sx = (c0 * x + c1 * y + c2) / denom;
         const sy = (c3 * x + c4 * y + c5) / denom;
@@ -1816,6 +1947,8 @@ function applyMagickDistort(img, methodRaw, argsRaw, bg) {
     const bx = [];
     const by = [];
     for (let p = 0; p < 3; p++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       const sx = nums[p * 4];
       const sy = nums[p * 4 + 1];
       const dx = nums[p * 4 + 2];
@@ -1827,7 +1960,11 @@ function applyMagickDistort(img, methodRaw, argsRaw, bg) {
     const rx = solveLinearSystem(A, bx);
     const ry = solveLinearSystem(A, by);
     for (let y = 0; y < h; y++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       for (let x = 0; x < w; x++) {
+        if (++cooperativeWork % 65536 === 0)
+          yield;
         const sx = rx[0] * x + rx[1] * y + rx[2];
         const sy = ry[0] * x + ry[1] * y + ry[2];
         sampleBilinear(img, sx, sy, bg, out, (y * w + x) * 4);
@@ -1844,7 +1981,11 @@ function applyMagickDistort(img, methodRaw, argsRaw, bg) {
     const cy = nums[5] ?? (h - 1) / 2;
     const rNorm = Math.min(w, h) / 2;
     for (let y = 0; y < h; y++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       for (let x = 0; x < w; x++) {
+        if (++cooperativeWork % 65536 === 0)
+          yield;
         const dx = (x - cx) / rNorm;
         const dy = (y - cy) / rNorm;
         const r = Math.hypot(dx, dy);
@@ -1858,7 +1999,8 @@ function applyMagickDistort(img, methodRaw, argsRaw, bg) {
   }
   return img;
 }
-function applyMagickSwirl(img, degrees, bg) {
+function* applyMagickSwirlSteps(img, degrees, bg, signal) {
+  let cooperativeWork = 0;
   const w = img.width;
   const h = img.height;
   const out = new Uint8Array(w * h * 4);
@@ -1867,7 +2009,11 @@ function applyMagickSwirl(img, degrees, bg) {
   const maxR = Math.max(cx, cy, 1);
   const radTotal = degrees * Math.PI / 180;
   for (let y = 0; y < h; y++) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     for (let x = 0; x < w; x++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       const dx = x - cx;
       const dy = y - cy;
       const r = Math.hypot(dx, dy);
@@ -1886,7 +2032,8 @@ function applyMagickSwirl(img, degrees, bg) {
   }
   return { ...img, data: out };
 }
-function applyMagickImplode(img, amount, bg) {
+function* applyMagickImplodeSteps(img, amount, bg, signal) {
+  let cooperativeWork = 0;
   const w = img.width;
   const h = img.height;
   const out = new Uint8Array(w * h * 4);
@@ -1896,7 +2043,11 @@ function applyMagickImplode(img, amount, bg) {
   const clamped = Math.max(-0.95, Math.min(0.95, amount));
   const exp = 1 / (1 - clamped);
   for (let y = 0; y < h; y++) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     for (let x = 0; x < w; x++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       const dx = x - cx;
       const dy = y - cy;
       const r = Math.hypot(dx, dy);
@@ -1911,7 +2062,8 @@ function applyMagickImplode(img, amount, bg) {
   }
   return { ...img, data: out };
 }
-function applyMagickWave(img, geomStr, bg) {
+function* applyMagickWaveSteps(img, geomStr, bg, signal) {
+  let cooperativeWork = 0;
   const g = parseMagickGeometry(geomStr);
   const amp = g.width ?? 5;
   const waveLen = Math.max(1, g.height ?? 50);
@@ -1921,14 +2073,19 @@ function applyMagickWave(img, geomStr, bg) {
   const out = new Uint8Array(outW * outH * 4);
   const yPad = Math.abs(amp);
   for (let y = 0; y < outH; y++) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     for (let x = 0; x < outW; x++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       const sy = y - yPad - amp * Math.sin(2 * Math.PI * x / waveLen);
       sampleBilinear(img, x, sy, bg, out, (y * outW + x) * 4);
     }
   }
   return { ...img, width: outW, height: outH, data: out, hasAlpha: true };
 }
-function applyMagickShadow(img, geomStr, shadowColor) {
+function* applyMagickShadowSteps(img, geomStr, shadowColor, signal) {
+  let cooperativeWork = 0;
   const g = parseMagickGeometry(geomStr);
   const opacity = Math.max(0, Math.min(100, g.width ?? 80)) / 100;
   const sigma = Math.max(0.5, g.height ?? 3);
@@ -1939,10 +2096,15 @@ function applyMagickShadow(img, geomStr, shadowColor) {
   const offX = pad + Math.round(g.x);
   const offY = pad + Math.round(g.y);
   for (let y = 0; y < img.height; y++) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     for (let x = 0; x < img.width; x++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       const dx = x + offX;
       const dy = y + offY;
-      if (dx < 0 || dy < 0 || dx >= outW || dy >= outH) continue;
+      if (dx < 0 || dy < 0 || dx >= outW || dy >= outH)
+        continue;
       const srcA = img.data[(y * img.width + x) * 4 + 3];
       const dstIdx = (dy * outW + dx) * 4;
       data[dstIdx] = shadowColor.r;
@@ -1960,14 +2122,19 @@ function applyMagickShadow(img, geomStr, shadowColor) {
   };
   return blurImage(shadowBase, sigma);
 }
-function applyMagickVignette(img, _geomStr, bg) {
+function* applyMagickVignetteSteps(img, _geomStr, bg, signal) {
+  let cooperativeWork = 0;
   const w = img.width;
   const h = img.height;
   const out = new Uint8Array(img.data);
   const cx = (w - 1) / 2;
   const cy = (h - 1) / 2;
   for (let y = 0; y < h; y++) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     for (let x = 0; x < w; x++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       const nx = (x - cx) / Math.max(1, cx);
       const ny = (y - cy) / Math.max(1, cy);
       const d = Math.hypot(nx, ny);
@@ -1980,11 +2147,14 @@ function applyMagickVignette(img, _geomStr, bg) {
   }
   return { ...img, data: out };
 }
-function applyMagickSepiaTone(img, threshStr) {
+function* applyMagickSepiaToneSteps(img, threshStr, signal) {
+  let cooperativeWork = 0;
   const raw = parseFloat(threshStr);
   const strength = Math.max(0, Math.min(1, (threshStr.endsWith("%") ? raw : raw / 255) / 100 || 0.8));
   const out = new Uint8Array(img.data);
   for (let i = 0; i < out.length; i += 4) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     const r = out[i];
     const g = out[i + 1];
     const b = out[i + 2];
@@ -1997,40 +2167,60 @@ function applyMagickSepiaTone(img, threshStr) {
   }
   return { ...img, data: out };
 }
-function applyMagickSolarize(img, threshStr) {
+function* applyMagickSolarizeSteps(img, threshStr, signal) {
+  let cooperativeWork = 0;
   const raw = parseFloat(threshStr);
   const thresh = threshStr.endsWith("%") ? raw / 100 * 255 : raw;
   const out = new Uint8Array(img.data);
   for (let i = 0; i < out.length; i += 4) {
-    if (out[i] > thresh) out[i] = 255 - out[i];
-    if (out[i + 1] > thresh) out[i + 1] = 255 - out[i + 1];
-    if (out[i + 2] > thresh) out[i + 2] = 255 - out[i + 2];
+    if (++cooperativeWork % 65536 === 0)
+      yield;
+    if (out[i] > thresh)
+      out[i] = 255 - out[i];
+    if (out[i + 1] > thresh)
+      out[i + 1] = 255 - out[i + 1];
+    if (out[i + 2] > thresh)
+      out[i + 2] = 255 - out[i + 2];
   }
   return { ...img, data: out };
 }
-function applyMagickPosterize(img, levelsRaw) {
+function* applyMagickPosterizeSteps(img, levelsRaw, signal) {
+  let cooperativeWork = 0;
   const levels = Math.max(2, Math.min(256, Math.round(levelsRaw)));
   const step = 255 / (levels - 1);
   const out = new Uint8Array(img.data);
   for (let i = 0; i < out.length; i += 4) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     out[i] = clampByteVal(Math.round(out[i] / 255 * (levels - 1)) * step);
     out[i + 1] = clampByteVal(Math.round(out[i + 1] / 255 * (levels - 1)) * step);
     out[i + 2] = clampByteVal(Math.round(out[i + 2] / 255 * (levels - 1)) * step);
   }
   return { ...img, data: out };
 }
-function applyMagickConvolve3x3(img, kernel, bias = 0) {
+function* applyMagickConvolve3x3Steps(img, kernel, bias = 0, signal) {
+  let cooperativeWork = 0;
   const w = img.width;
   const h = img.height;
   const out = new Uint8Array(img.data);
   for (let y = 0; y < h; y++) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     for (let x = 0; x < w; x++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       for (let c = 0; c < 3; c++) {
+        if (++cooperativeWork % 65536 === 0)
+          yield;
         let sum = bias;
         let kIdx = 0;
         for (let ky = -1; ky <= 1; ky++) {
+          if (++cooperativeWork % 65536 === 0)
+            yield;
           const sy = Math.max(0, Math.min(h - 1, y + ky));
           for (let kx = -1; kx <= 1; kx++) {
+            if (++cooperativeWork % 65536 === 0)
+              yield;
             const sx = Math.max(0, Math.min(w - 1, x + kx));
             sum += img.data[(sy * w + sx) * 4 + c] * kernel[kIdx++];
           }
@@ -2175,7 +2365,8 @@ function parseCompose(raw) {
       return "over";
   }
 }
-function applyMagickCompositeLayer(dst, src, modeRaw, left, top, composeArgs) {
+function* applyMagickCompositeLayerSteps(dst, src, modeRaw, left, top, composeArgs, signal) {
+  let cooperativeWork = 0;
   const norm = modeRaw.toLowerCase().replace(/[-_\s]/g, "");
   const out = new Uint8Array(dst.data);
   const dw = dst.width;
@@ -2183,11 +2374,17 @@ function applyMagickCompositeLayer(dst, src, modeRaw, left, top, composeArgs) {
   const sw = src.width;
   const sh = src.height;
   for (let sy = 0; sy < sh; sy++) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     const dy = top + sy;
-    if (dy < 0 || dy >= dh) continue;
+    if (dy < 0 || dy >= dh)
+      continue;
     for (let sx = 0; sx < sw; sx++) {
+      if (++cooperativeWork % 65536 === 0)
+        yield;
       const dx = left + sx;
-      if (dx < 0 || dx >= dw) continue;
+      if (dx < 0 || dx >= dw)
+        continue;
       const sIdx = (sy * sw + sx) * 4;
       const dIdx = (dy * dw + dx) * 4;
       const sr = src.data[sIdx];
@@ -2329,6 +2526,8 @@ function applyMagickCompositeLayer(dst, src, modeRaw, left, top, composeArgs) {
         const sChan = [sr / 255, sg / 255, sb / 255];
         const dChan = [dr / 255, dg / 255, db / 255];
         for (let c = 0; c < 3; c++) {
+          if (++cooperativeWork % 65536 === 0)
+            yield;
           const sc = sChan[c];
           const dc = dChan[c];
           if (norm === "darken") {
@@ -2342,9 +2541,12 @@ function applyMagickCompositeLayer(dst, src, modeRaw, left, top, composeArgs) {
             out[dIdx + c] = clampByteVal(comp * 255);
           } else {
             let f = 0;
-            if (norm === "multiply") f = sc * dc;
-            else if (norm === "screen") f = sc + dc - sc * dc;
-            else f = dc <= 0.5 ? 2 * sc * dc : 1 - 2 * (1 - sc) * (1 - dc);
+            if (norm === "multiply")
+              f = sc * dc;
+            else if (norm === "screen")
+              f = sc + dc - sc * dc;
+            else
+              f = dc <= 0.5 ? 2 * sc * dc : 1 - 2 * (1 - sc) * (1 - dc);
             const comp = f * sa * da + sc * sa * (1 - da) + dc * da * (1 - sa);
             const unpremul = gamma > 1e-6 && norm === "overlay" ? comp / gamma : comp;
             out[dIdx + c] = clampByteVal(unpremul * 255);
@@ -2365,7 +2567,8 @@ function applyMagickCompositeLayer(dst, src, modeRaw, left, top, composeArgs) {
     const sy0 = Math.max(0, -oy);
     const sx1 = Math.min(src.width, dst.width - ox);
     const sy1 = Math.min(src.height, dst.height - oy);
-    if (sx1 <= sx0 || sy1 <= sy0) return dst;
+    if (sx1 <= sx0 || sy1 <= sy0)
+      return dst;
     const clipped = extractImage(src, { left: sx0, top: sy0, width: sx1 - sx0, height: sy1 - sy0 });
     return compositeImage(dst, [rgbaToCompositeLayer(clipped, Math.max(0, ox), Math.max(0, oy), parseCompose(modeRaw))]);
   }
@@ -2537,7 +2740,8 @@ function applyMagickCropToStack(img, geomStr, gravity) {
     })
   ];
 }
-function applyMagickExtent(img, geomStr, state) {
+function* applyMagickExtentSteps(img, geomStr, state, signal) {
+  yield;
   const g = parseMagickGeometry(geomStr);
   const targetW = Math.max(1, Math.round(g.width ?? img.width));
   const targetH = Math.max(1, Math.round(g.height ?? img.height));
@@ -2562,7 +2766,9 @@ function applyMagickExtent(img, geomStr, state) {
   });
   return compositeImage(canvas, [rgbaToCompositeLayer(subImg, dstX0, dstY0, "over")]);
 }
-function applyMagickDraw(img, drawCmd, state) {
+function* applyMagickDrawSteps(img, drawCmd, state, signal) {
+  yield;
+  let cooperativeWork = 0;
   const svgElements = [];
   let fill = rgbaToCss(state.fill);
   let stroke = rgbaToCss(state.stroke);
@@ -2571,12 +2777,17 @@ function applyMagickDraw(img, drawCmd, state) {
   const tokens = [];
   let m;
   while ((m = tokenRe.exec(drawCmd)) !== null) {
-    if (m[0] === ",") continue;
+    if (++cooperativeWork % 65536 === 0)
+      yield;
+    if (m[0] === ",")
+      continue;
     tokens.push(m[1] ?? m[2] ?? m[3] ?? "");
   }
   let i = 0;
   const num = () => Number(tokens[i++] ?? 0);
   while (i < tokens.length) {
+    if (++cooperativeWork % 65536 === 0)
+      yield;
     const cmd = tokens[i++].toLowerCase();
     if (cmd === "fill") {
       fill = rgbaToCss(parseColor2(tokens[i++] ?? "#000000"));
@@ -2594,14 +2805,10 @@ function applyMagickDraw(img, drawCmd, state) {
       const rw = Math.max(1, Math.abs(x1 - x0) + 1);
       const rh = Math.max(1, Math.abs(y1 - y0) + 1);
       if (fill !== "none") {
-        svgElements.push(
-          `<rect x="${rx}" y="${ry}" width="${rw}" height="${rh}" fill="${fill}"/>`
-        );
+        svgElements.push(`<rect x="${rx}" y="${ry}" width="${rw}" height="${rh}" fill="${fill}"/>`);
       }
       if (stroke !== "none" && strokeWidth > 0) {
-        svgElements.push(
-          `<polygon points="${rx},${ry} ${rx + rw - 1},${ry} ${rx + rw - 1},${ry + rh - 1} ${rx},${ry + rh - 1}" fill="none" stroke="${stroke}" stroke-width="${strokeWidth}"/>`
-        );
+        svgElements.push(`<polygon points="${rx},${ry} ${rx + rw - 1},${ry} ${rx + rw - 1},${ry + rh - 1} ${rx},${ry + rh - 1}" fill="none" stroke="${stroke}" stroke-width="${strokeWidth}"/>`);
       }
     } else if (cmd === "roundrectangle") {
       const x0 = num();
@@ -2615,14 +2822,10 @@ function applyMagickDraw(img, drawCmd, state) {
       const rw = Math.max(1, Math.abs(x1 - x0) + 1);
       const rh = Math.max(1, Math.abs(y1 - y0) + 1);
       if (fill !== "none") {
-        svgElements.push(
-          `<rect x="${rx}" y="${ry}" width="${rw}" height="${rh}" rx="${wc}" ry="${hc}" fill="${fill}"/>`
-        );
+        svgElements.push(`<rect x="${rx}" y="${ry}" width="${rw}" height="${rh}" rx="${wc}" ry="${hc}" fill="${fill}"/>`);
       }
       if (stroke !== "none" && strokeWidth > 0) {
-        svgElements.push(
-          `<polygon points="${rx},${ry} ${rx + rw - 1},${ry} ${rx + rw - 1},${ry + rh - 1} ${rx},${ry + rh - 1}" fill="none" stroke="${stroke}" stroke-width="${strokeWidth}"/>`
-        );
+        svgElements.push(`<polygon points="${rx},${ry} ${rx + rw - 1},${ry} ${rx + rw - 1},${ry + rh - 1} ${rx},${ry + rh - 1}" fill="none" stroke="${stroke}" stroke-width="${strokeWidth}"/>`);
       }
     } else if (cmd === "circle") {
       const cx = num();
@@ -2630,9 +2833,7 @@ function applyMagickDraw(img, drawCmd, state) {
       const px = num();
       const py = num();
       const r = Math.max(1, Math.hypot(px - cx, py - cy));
-      svgElements.push(
-        `<circle cx="${cx}" cy="${cy}" r="${r}" fill="${fill}" stroke="${stroke}" stroke-width="${strokeWidth}"/>`
-      );
+      svgElements.push(`<circle cx="${cx}" cy="${cy}" r="${r}" fill="${fill}" stroke="${stroke}" stroke-width="${strokeWidth}"/>`);
     } else if (cmd === "ellipse") {
       const cx = num();
       const cy = num();
@@ -2640,18 +2841,14 @@ function applyMagickDraw(img, drawCmd, state) {
       const ry = num();
       num();
       num();
-      svgElements.push(
-        `<ellipse cx="${cx}" cy="${cy}" rx="${rx}" ry="${ry}" fill="${fill}" stroke="${stroke}" stroke-width="${strokeWidth}"/>`
-      );
+      svgElements.push(`<ellipse cx="${cx}" cy="${cy}" rx="${rx}" ry="${ry}" fill="${fill}" stroke="${stroke}" stroke-width="${strokeWidth}"/>`);
     } else if (cmd === "line") {
       const x0 = num();
       const y0 = num();
       const x1 = num();
       const y1 = num();
       const lineStroke = stroke === "none" ? fill : stroke;
-      svgElements.push(
-        `<line x1="${x0}" y1="${y0}" x2="${x1}" y2="${y1}" stroke="${lineStroke}" stroke-width="${Math.max(1, strokeWidth)}"/>`
-      );
+      svgElements.push(`<line x1="${x0}" y1="${y0}" x2="${x1}" y2="${y1}" stroke="${lineStroke}" stroke-width="${Math.max(1, strokeWidth)}"/>`);
     } else if (cmd === "point") {
       const x = num();
       const y = num();
@@ -2660,58 +2857,52 @@ function applyMagickDraw(img, drawCmd, state) {
       const x = num();
       const y = num();
       const txt = tokens[i++] ?? "";
-      svgElements.push(
-        `<text x="${x}" y="${y}" font-size="${state.pointsize}" fill="${fill}">${escapeXml(txt)}</text>`
-      );
+      svgElements.push(`<text x="${x}" y="${y}" font-size="${state.pointsize}" fill="${fill}">${escapeXml(txt)}</text>`);
     } else if (cmd === "polygon" || cmd === "polyline") {
       const pts = [];
       while (i < tokens.length && !Number.isNaN(Number(tokens[i]))) {
+        if (++cooperativeWork % 65536 === 0)
+          yield;
         const px = num();
         const py = num();
         pts.push(`${px},${py}`);
       }
       if (pts.length >= 2) {
         if (cmd === "polygon") {
-          svgElements.push(
-            `<polygon points="${pts.join(" ")}" fill="${fill}" stroke="${stroke}" stroke-width="${strokeWidth}"/>`
-          );
+          svgElements.push(`<polygon points="${pts.join(" ")}" fill="${fill}" stroke="${stroke}" stroke-width="${strokeWidth}"/>`);
         } else {
           const lineStroke = stroke === "none" ? fill : stroke;
-          svgElements.push(
-            `<polyline points="${pts.join(" ")}" fill="none" stroke="${lineStroke}" stroke-width="${Math.max(1, strokeWidth)}"/>`
-          );
+          svgElements.push(`<polyline points="${pts.join(" ")}" fill="none" stroke="${lineStroke}" stroke-width="${Math.max(1, strokeWidth)}"/>`);
         }
       }
     } else if (cmd === "bezier") {
       const pts = [];
       while (i < tokens.length && !Number.isNaN(Number(tokens[i]))) {
+        if (++cooperativeWork % 65536 === 0)
+          yield;
         pts.push({ x: num(), y: num() });
       }
       if (pts.length === 3) {
         const lineStroke = stroke === "none" ? fill : stroke;
-        svgElements.push(
-          `<path d="M ${pts[0].x} ${pts[0].y} Q ${pts[1].x} ${pts[1].y} ${pts[2].x} ${pts[2].y}" fill="none" stroke="${lineStroke}" stroke-width="${Math.max(1, strokeWidth)}"/>`
-        );
+        svgElements.push(`<path d="M ${pts[0].x} ${pts[0].y} Q ${pts[1].x} ${pts[1].y} ${pts[2].x} ${pts[2].y}" fill="none" stroke="${lineStroke}" stroke-width="${Math.max(1, strokeWidth)}"/>`);
       } else if (pts.length >= 4) {
         const lineStroke = stroke === "none" ? fill : stroke;
         const rest = pts.slice(1).map((p) => `${p.x} ${p.y}`).join(" ");
-        svgElements.push(
-          `<path d="M ${pts[0].x} ${pts[0].y} C ${rest}" fill="none" stroke="${lineStroke}" stroke-width="${Math.max(1, strokeWidth)}"/>`
-        );
+        svgElements.push(`<path d="M ${pts[0].x} ${pts[0].y} C ${rest}" fill="none" stroke="${lineStroke}" stroke-width="${Math.max(1, strokeWidth)}"/>`);
       }
     } else if (cmd === "path") {
       const d = tokens[i++] ?? "";
-      svgElements.push(
-        `<path d="${escapeXml(d)}" fill="${fill}" stroke="${stroke}" stroke-width="${strokeWidth}"/>`
-      );
+      svgElements.push(`<path d="${escapeXml(d)}" fill="${fill}" stroke="${stroke}" stroke-width="${strokeWidth}"/>`);
     }
   }
-  if (svgElements.length === 0) return img;
+  if (svgElements.length === 0)
+    return img;
   const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${img.width}" height="${img.height}">${svgElements.join("")}</svg>`;
   const overlay = decodeImage(new TextEncoder().encode(svg), { density: state.density });
   return compositeImage(img, [rgbaToCompositeLayer(overlay, 0, 0, "over")]);
 }
-function applyMagickAnnotate(img, offsetStr, text, state) {
+function* applyMagickAnnotateSteps(img, offsetStr, text, state, signal) {
+  yield;
   const g = parseMagickGeometry(offsetStr);
   const fontSize = Math.max(8, state.pointsize);
   const estW = Math.max(8, Math.ceil(text.length * fontSize * 0.6));
@@ -2929,14 +3120,14 @@ function formatIdentifyCustom(fmt, filePath, meta, byteLen, rawBytes) {
   }
   return out;
 }
-async function runIdentifyCli(argv, files, stdinBytes) {
-  return runIdentifyCliSync(argv, files, stdinBytes);
-}
-function runIdentifyCliSync(argv, files, stdinBytes) {
+function* runIdentifyCliSteps(argv, files, stdinBytes, signal) {
+  let cooperativeWork = 63;
   let verbose = false;
   let customFormat;
   const targets = [];
   for (let i = 0; i < argv.length; i++) {
+    if (++cooperativeWork % 64 === 0)
+      yield;
     const a = argv[i];
     if (a === "--help" || a === "-help" || a === "-h") {
       return {
@@ -2972,6 +3163,7 @@ function runIdentifyCliSync(argv, files, stdinBytes) {
   const errParts = [];
   let exitCode = 0;
   for (const inPath of targets) {
+    yield;
     const bracketMatch = /^(.*)\[(\d+)\]$/.exec(inPath);
     let baseInPath = bracketMatch ? bracketMatch[1] : inPath;
     const colon = baseInPath.indexOf(":");
@@ -2995,8 +3187,7 @@ function runIdentifyCliSync(argv, files, stdinBytes) {
         outParts.push(formatIdentifyCustom(customFormat, baseInPath, meta, bytes.byteLength, bytes));
       } else if (verbose) {
         const stats = computeImageStats(decodeImage(bytes, inputOptions));
-        outParts.push(
-          `Image: ${inPath}
+        outParts.push(`Image: ${inPath}
   Format: ${meta.format.toUpperCase()}
   Geometry: ${meta.width}x${meta.height}+0+0
   Resolution: ${meta.density}x${meta.density}
@@ -3006,13 +3197,10 @@ function runIdentifyCliSync(argv, files, stdinBytes) {
   Alpha: ${meta.hasAlpha ? "True" : "False"}
   Filesize: ${bytes.byteLength}B
   Entropy: ${stats.entropy.toFixed(4)}
-`
-        );
+`);
       } else {
-        outParts.push(
-          `${inPath} ${meta.format.toUpperCase()} ${meta.width}x${meta.height} ${meta.width}x${meta.height}+0+0 ${bitDepth}-bit ${spaceLabel} ${bytes.byteLength}B 0.000u 0:00.000
-`
-        );
+        outParts.push(`${inPath} ${meta.format.toUpperCase()} ${meta.width}x${meta.height} ${meta.width}x${meta.height}+0+0 ${bitDepth}-bit ${spaceLabel} ${bytes.byteLength}B 0.000u 0:00.000
+`);
       }
     } catch (err) {
       errParts.push(`identify: improper image header '${inPath}': ${err.message}
@@ -3026,6 +3214,17 @@ function runIdentifyCliSync(argv, files, stdinBytes) {
     stderr: errParts.join("")
   };
 }
+async function runIdentifyCli(argv, files, stdinBytes, signal) {
+  return drainSteps(runIdentifyCliSteps(argv, files, stdinBytes, signal), signal);
+}
+function runIdentifyCliSync(argv, files, stdinBytes, signal) {
+  const steps = runIdentifyCliSteps(argv, files, stdinBytes, signal);
+  let next = steps.next();
+  while (!next.done) {
+    next = steps.next();
+  }
+  return next.value;
+}
 function parseMagickIndexSpec(spec, length) {
   if (length <= 0) return [];
   const resolve = (n) => n < 0 ? Math.max(0, length + n) : Math.min(Math.max(0, n), length - 1);
@@ -3052,23 +3251,29 @@ function parseMagickIndexSpec(spec, length) {
   }
   return out;
 }
-function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinBytes) {
+function* evaluatePipelineTokensSteps(tokens, files, state, parentStack = [], stdinBytes, signal) {
+  let cooperativeWork = 63;
   let stack = [];
   let i = 0;
   while (i < tokens.length) {
+    yield;
     const t = tokens[i];
     if (t === "(") {
       let depth = 1;
       let j = i + 1;
       while (j < tokens.length && depth > 0) {
-        if (tokens[j] === "(") depth++;
-        else if (tokens[j] === ")") depth--;
+        if (++cooperativeWork % 65536 === 0)
+          yield;
+        if (tokens[j] === "(")
+          depth++;
+        else if (tokens[j] === ")")
+          depth--;
         j++;
       }
       const endIdx = depth === 0 ? j - 1 : j;
       const subTokens = tokens.slice(i + 1, endIdx);
       const subState = { ...state };
-      const subResult = evaluatePipelineTokens(subTokens, files, subState, stack, stdinBytes);
+      const subResult = yield* evaluatePipelineTokensSteps(subTokens, files, subState, stack, stdinBytes, signal);
       stack.push(...subResult);
       i = j;
       continue;
@@ -3113,11 +3318,13 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
     } else if (t === "-define") {
       const defStr = tokens[++i] ?? "";
       const m = /^compose:args=(.*)$/i.exec(defStr);
-      if (m) state.composeArgs = m[1];
+      if (m)
+        state.composeArgs = m[1];
     } else if (t === "-set") {
       const k = (tokens[++i] ?? "").toLowerCase();
       const v = tokens[++i] ?? "";
-      if (k === "option:compose:args") state.composeArgs = v;
+      if (k === "option:compose:args")
+        state.composeArgs = v;
     } else if (t === "-write" || t === "+write") {
       const writePath = tokens[++i] ?? "";
       if (stack.length > 0 && writePath && writePath.toLowerCase() !== "null:") {
@@ -3125,6 +3332,8 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
         const { format, path } = inferOutputFormat(writePath, top.format);
         if (stack.length > 1 && (/%0?\d*d/.test(path) || !state.adjoin)) {
           for (let idx = 0; idx < stack.length; idx++) {
+            if (++cooperativeWork % 65536 === 0)
+              yield;
             const framePath = formatSceneOutputPath(path, idx);
             const { data: frameBytes } = encodeImage(stack[idx], { format, quality: state.quality });
             files.set(framePath, frameBytes);
@@ -3151,16 +3360,22 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
     } else if (t === "-coalesce" || t === "-deconstruct") {
     } else if (t === "-splice") {
       const geom = tokens[++i] ?? "0x0";
-      stack = stack.map((im) => applyMagickSplice(im, geom, state.background, state.gravity));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickSpliceSteps(im, geom, state.background, state.gravity, signal);
+      });
     } else if (t === "-chop") {
       const geom = tokens[++i] ?? "0x0";
-      stack = stack.map((im) => applyMagickChop(im, geom, state.gravity));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickChopSteps(im, geom, state.gravity, signal);
+      });
     } else if (t === "-roll") {
       const geom = tokens[++i] ?? "+0+0";
-      stack = stack.map((im) => applyMagickRoll(im, geom));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickRollSteps(im, geom, signal);
+      });
     } else if (t === "-morph") {
       const count = Number(tokens[++i] ?? 1);
-      stack = applyMagickMorph(stack, count);
+      stack = yield* applyMagickMorphSteps(stack, count, signal);
     } else if (t === "-floodfill") {
       const geom = tokens[++i] ?? "+0+0";
       const nextTok = tokens[i + 1];
@@ -3172,25 +3387,35 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
         } catch {
         }
       }
-      stack = stack.map((im) => applyMagickFloodfill(im, geom, targetColor, state.fill, state.fuzz));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickFloodfillSteps(im, geom, targetColor, state.fill, state.fuzz, signal);
+      });
     } else if (t === "-evaluate-sequence") {
       const op = tokens[++i] ?? "Mean";
       if (stack.length > 0) {
-        stack = [applyMagickEvaluateSequence(stack, op)];
+        stack = [yield* applyMagickEvaluateSequenceSteps(stack, op, signal)];
       }
     } else if (t === "-convolve") {
       const kSpec = tokens[++i] ?? "1";
-      stack = stack.map((im) => applyMagickCustomConvolve(im, kSpec));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickCustomConvolveSteps(im, kSpec, signal);
+      });
     } else if (t === "-color-matrix" || t === "-recolor") {
       const mSpec = tokens[++i] ?? "1,0,0 0,1,0 0,0,1";
-      stack = stack.map((im) => applyMagickColorMatrix(im, mSpec));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickColorMatrixSteps(im, mSpec, signal);
+      });
     } else if (t === "-equalize") {
-      stack = stack.map((im) => applyMagickEqualize(im));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickEqualizeSteps(im, signal);
+      });
     } else if (t === "-remap") {
       const palSpec = tokens[++i] ?? "";
       const palImg = parseInputOperand(palSpec, files, state, stdinBytes);
       if (palImg) {
-        stack = stack.map((im) => applyMagickRemap(im, palImg, state.dither));
+        stack = yield* mapSteps(stack, function* (im) {
+          return yield* applyMagickRemapSteps(im, palImg, state.dither, signal);
+        });
       }
     } else if (t === "-channel") {
       state.channels = parseChannelMask(tokens[++i] ?? "rgb");
@@ -3201,61 +3426,91 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
     } else if (t === "-opaque" || t === "+opaque") {
       const targetColor = parseColor2(tokens[++i] ?? "#000000");
       const invert = t === "+opaque";
-      stack = stack.map((im) => applyMagickOpaque(im, targetColor, state.fill, state.fuzz, invert));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickOpaqueSteps(im, targetColor, state.fill, state.fuzz, invert, signal);
+      });
     } else if (t === "-transparent" || t === "+transparent") {
       const targetColor = parseColor2(tokens[++i] ?? "#ffffff");
       const invert = t === "+transparent";
-      stack = stack.map((im) => applyMagickTransparent(im, targetColor, state.fuzz, invert));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickTransparentSteps(im, targetColor, state.fuzz, invert, signal);
+      });
     } else if (t === "-evaluate") {
       const op = tokens[++i] ?? "Add";
       const val = tokens[++i] ?? "0";
-      stack = stack.map((im) => applyMagickEvaluate(im, op, val, state.channels));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickEvaluateSteps(im, op, val, state.channels, signal);
+      });
     } else if (t === "-function") {
       const fn = tokens[++i] ?? "Polynomial";
       const params = tokens[++i] ?? "1,0";
-      stack = stack.map((im) => applyMagickFunction(im, fn, params, state.channels));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickFunctionSteps(im, fn, params, state.channels, signal);
+      });
     } else if (t === "-clut" || t === "-hald-clut") {
       if (stack.length >= 2) {
         const lut = stack[stack.length - 1];
-        const mapped = stack.slice(0, -1).map((im) => applyMagickClut(im, lut, state.channels));
+        const mapped = yield* mapSteps(stack.slice(0, -1), function* (im) {
+          return yield* applyMagickClutSteps(im, lut, state.channels, signal);
+        });
         stack = mapped;
       }
     } else if (t === "-fx") {
       const expr = tokens[++i] ?? "u";
       if (stack.length > 0) {
-        stack = [applyMagickFx(stack, expr, state.channels)];
+        stack = [yield* applyMagickFxSteps(stack, expr, state.channels, signal)];
       }
     } else if (t === "-shear") {
       const geom = tokens[++i] ?? "0x0";
-      stack = stack.map((im) => applyMagickShear(im, geom, state.background));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickShearSteps(im, geom, state.background, signal);
+      });
     } else if (t === "-distort" || t === "+distort") {
       const method = tokens[++i] ?? "SRT";
       const args = tokens[++i] ?? "0";
-      stack = stack.map((im) => applyMagickDistort(im, method, args, state.background));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickDistortSteps(im, method, args, state.background, signal);
+      });
     } else if (t === "-swirl") {
       const deg = Number(tokens[++i] ?? 0);
-      stack = stack.map((im) => applyMagickSwirl(im, deg, state.background));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickSwirlSteps(im, deg, state.background, signal);
+      });
     } else if (t === "-implode") {
       const amt = Number(tokens[++i] ?? 0);
-      stack = stack.map((im) => applyMagickImplode(im, amt, state.background));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickImplodeSteps(im, amt, state.background, signal);
+      });
     } else if (t === "-wave") {
       const geom = tokens[++i] ?? "5x50";
-      stack = stack.map((im) => applyMagickWave(im, geom, state.background));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickWaveSteps(im, geom, state.background, signal);
+      });
     } else if (t === "-shadow") {
       const geom = tokens[++i] ?? "80x3+5+5";
-      stack = stack.map((im) => applyMagickShadow(im, geom, state.background));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickShadowSteps(im, geom, state.background, signal);
+      });
     } else if (t === "-vignette") {
       const geom = tokens[++i] ?? "0x2";
-      stack = stack.map((im) => applyMagickVignette(im, geom, state.background));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickVignetteSteps(im, geom, state.background, signal);
+      });
     } else if (t === "-sepia-tone") {
       const thresh = tokens[++i] ?? "80%";
-      stack = stack.map((im) => applyMagickSepiaTone(im, thresh));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickSepiaToneSteps(im, thresh, signal);
+      });
     } else if (t === "-solarize") {
       const thresh = tokens[++i] ?? "50%";
-      stack = stack.map((im) => applyMagickSolarize(im, thresh));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickSolarizeSteps(im, thresh, signal);
+      });
     } else if (t === "-posterize" || t === "-colors") {
       const lv = Number(tokens[++i] ?? 8);
-      stack = stack.map((im) => applyMagickPosterize(im, lv));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickPosterizeSteps(im, lv, signal);
+      });
     } else if (t === "-dither" || t === "+dither") {
       if (t === "+dither") {
         state.dither = false;
@@ -3265,22 +3520,22 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
       }
     } else if (t === "-edge" || t === "-canny") {
       i++;
-      stack = stack.map((im) => applyMagickConvolve3x3(im, [-1, -1, -1, -1, 8, -1, -1, -1, -1], 0));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickConvolve3x3Steps(im, [-1, -1, -1, -1, 8, -1, -1, -1, -1], 0, signal);
+      });
     } else if (t === "-emboss") {
       i++;
-      stack = stack.map((im) => applyMagickConvolve3x3(im, [-2, -1, 0, -1, 1, 1, 0, 1, 2], 128));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickConvolve3x3Steps(im, [-2, -1, 0, -1, 1, 1, 0, 1, 2], 128, signal);
+      });
     } else if (t === "-charcoal" || t === "-sketch") {
       i++;
-      stack = stack.map(
-        (im) => grayscaleImage(
-          negateImage(
-            applyMagickConvolve3x3(blurImage(im, 1), [-1, -1, -1, -1, 8, -1, -1, -1, -1], 0),
-            { alpha: false }
-          )
-        )
-      );
+      stack = yield* mapSteps(stack, function* (im) {
+        return grayscaleImage(negateImage(yield* applyMagickConvolve3x3Steps(blurImage(im, 1), [-1, -1, -1, -1, 8, -1, -1, -1, -1], 0, signal), { alpha: false }));
+      });
     } else if (t === "+repage" || t === "-repage") {
-      if (t === "-repage") i++;
+      if (t === "-repage")
+        i++;
     } else if (t === "-resize" || t === "-scale" || t === "-sample" || t === "-thumbnail") {
       const geom = tokens[++i] ?? "100%";
       const k = t === "-sample" ? "nearest" : state.kernel;
@@ -3289,26 +3544,28 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
       const geom = tokens[++i] ?? "100%";
       const nextStack = [];
       for (const im of stack) {
+        if (++cooperativeWork % 65536 === 0)
+          yield;
         nextStack.push(...applyMagickCropToStack(im, geom, state.gravity));
       }
       stack = nextStack;
     } else if (t === "-extent") {
       const geom = tokens[++i] ?? "100%";
-      stack = stack.map((im) => applyMagickExtent(im, geom, state));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickExtentSteps(im, geom, state, signal);
+      });
     } else if (t === "-border") {
       const g = parseMagickGeometry(tokens[++i] ?? "0x0");
       const bw = Math.max(0, Math.round(g.width ?? 0));
       const bh = Math.max(0, Math.round(g.height ?? bw));
-      stack = stack.map(
-        (im) => extendImage(im, {
-          top: bh,
-          bottom: bh,
-          left: bw,
-          right: bw,
-          background: state.borderColor,
-          extendWith: "background"
-        })
-      );
+      stack = stack.map((im) => extendImage(im, {
+        top: bh,
+        bottom: bh,
+        left: bw,
+        right: bw,
+        background: state.borderColor,
+        extendWith: "background"
+      }));
     } else if (t === "-shave") {
       const g = parseMagickGeometry(tokens[++i] ?? "0x0");
       const sw = Math.max(0, Math.round(g.width ?? 0));
@@ -3347,11 +3604,16 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
           const r = out[idx];
           const g = out[idx + 1];
           const b = out[idx + 2];
-          if (onlyGray && !(r === g && g === b)) continue;
-          if (ch.r) out[idx] = 255 - r;
-          if (ch.g) out[idx + 1] = 255 - g;
-          if (ch.b) out[idx + 2] = 255 - b;
-          if (ch.a) out[idx + 3] = 255 - out[idx + 3];
+          if (onlyGray && !(r === g && g === b))
+            continue;
+          if (ch.r)
+            out[idx] = 255 - r;
+          if (ch.g)
+            out[idx + 1] = 255 - g;
+          if (ch.b)
+            out[idx + 2] = 255 - b;
+          if (ch.a)
+            out[idx + 3] = 255 - out[idx + 3];
         }
         return { ...im, data: out };
       });
@@ -3388,8 +3650,10 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
         for (let idx = 0; idx < out.length; idx += 4) {
           for (let c = 0; c < 4; c++) {
             const v = out[idx + c];
-            if (v < mins[c]) mins[c] = v;
-            if (v > maxs[c]) maxs[c] = v;
+            if (v < mins[c])
+              mins[c] = v;
+            if (v > maxs[c])
+              maxs[c] = v;
           }
         }
         if (!indep) {
@@ -3401,7 +3665,8 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
         const active = [ch.r, ch.g, ch.b, ch.a];
         for (let idx = 0; idx < out.length; idx += 4) {
           for (let c = 0; c < 4; c++) {
-            if (!active[c]) continue;
+            if (!active[c])
+              continue;
             const range = maxs[c] - mins[c];
             if (range > 0) {
               out[idx + c] = clampByteVal((out[idx + c] - mins[c]) / range * 255);
@@ -3423,7 +3688,8 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
         const highTarget = isPct ? (100 - wVal) / 100 * nPix : nPix - wVal;
         for (let c = 0; c < 3; c++) {
           const hist = new Uint32Array(256);
-          for (let idx = c; idx < out.length; idx += 4) hist[out[idx]]++;
+          for (let idx = c; idx < out.length; idx += 4)
+            hist[out[idx]]++;
           let lowBin = 0;
           let acc = 0;
           for (let b = 0; b < 256; b++) {
@@ -3465,7 +3731,8 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
           for (let x = 0; x < im.width; x++) {
             const topLeft = y < bw || x < bw;
             const botRight = y >= im.height - bw || x >= im.width - bw;
-            if (!topLeft && !botRight) continue;
+            if (!topLeft && !botRight)
+              continue;
             const lighten = raised ? topLeft : botRight;
             const idx = (y * im.width + x) * 4;
             for (let c = 0; c < 3; c++) {
@@ -3479,16 +3746,14 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
       const g = parseMagickGeometry(tokens[++i] ?? "4x4");
       const fw = Math.max(0, Math.round(g.width ?? 4));
       const fh = Math.max(0, Math.round(g.height ?? fw));
-      stack = stack.map(
-        (im) => extendImage(im, {
-          top: fh,
-          bottom: fh,
-          left: fw,
-          right: fw,
-          background: state.borderColor,
-          extendWith: "background"
-        })
-      );
+      stack = stack.map((im) => extendImage(im, {
+        top: fh,
+        bottom: fh,
+        left: fw,
+        right: fw,
+        background: state.borderColor,
+        extendWith: "background"
+      }));
     } else if (t === "-deskew") {
       i++;
     } else if (t === "-auto-gamma") {
@@ -3497,7 +3762,8 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
         const numCh = im.hasAlpha ? 4 : 3;
         let sum = 0;
         for (let idx = 0; idx < out.length; idx += 4) {
-          for (let c = 0; c < numCh; c++) sum += out[idx + c];
+          for (let c = 0; c < numCh; c++)
+            sum += out[idx + c];
         }
         const mean = sum / Math.max(1, im.width * im.height * numCh * 255);
         if (mean > 0 && mean < 1) {
@@ -3535,7 +3801,8 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
       const parts = raw.split(",");
       const anyPct = raw.includes("%");
       const parsePt = (p, def) => {
-        if (!p || p.length === 0) return def;
+        if (!p || p.length === 0)
+          return def;
         if (p.endsWith("%") || anyPct) {
           return parseFloat(p) / 100 * 255;
         }
@@ -3607,14 +3874,20 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
         kernelSpec = tokens[++i];
       }
       if (method.includes("convolve") || method.includes("correlate")) {
-        stack = stack.map((im) => applyMagickCustomConvolve(im, kernelSpec));
+        stack = yield* mapSteps(stack, function* (im) {
+          return yield* applyMagickCustomConvolveSteps(im, kernelSpec, signal);
+        });
       } else {
-        stack = stack.map((im) => applyMagickMorphology4Ch(im, method, kernelSpec));
+        stack = yield* mapSteps(stack, function* (im) {
+          return yield* applyMagickMorphology4ChSteps(im, method, kernelSpec, signal);
+        });
       }
     } else if (t === "-statistic") {
       const statType = (tokens[++i] ?? "median").toLowerCase();
       const geom = tokens[++i] ?? "3x3";
-      stack = stack.map((im) => applyMagickMorphology4Ch(im, statType, geom));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickMorphology4ChSteps(im, statType, geom, signal);
+      });
     } else if (t === "-alpha") {
       const mode = (tokens[++i] ?? "on").toLowerCase();
       if (mode === "remove") {
@@ -3622,22 +3895,22 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
       } else if (mode === "off" || mode === "deactivate" || mode === "opaque") {
         stack = stack.map((im) => {
           const out = new Uint8Array(im.data);
-          for (let idx = 3; idx < out.length; idx += 4) out[idx] = 255;
+          for (let idx = 3; idx < out.length; idx += 4)
+            out[idx] = 255;
           return { ...im, data: out, hasAlpha: mode === "opaque" };
         });
       } else if (mode === "transparent") {
         stack = stack.map((im) => {
           const out = new Uint8Array(im.data);
-          for (let idx = 3; idx < out.length; idx += 4) out[idx] = 0;
+          for (let idx = 3; idx < out.length; idx += 4)
+            out[idx] = 0;
           return { ...im, data: out, hasAlpha: true };
         });
       } else if (mode === "copy" || mode === "shape") {
         stack = stack.map((im) => {
           const out = new Uint8Array(im.data);
           for (let idx = 0; idx < out.length; idx += 4) {
-            const inten = clampByteVal(
-              0.212656 * out[idx] + 0.715158 * out[idx + 1] + 0.072186 * out[idx + 2]
-            );
+            const inten = clampByteVal(0.212656 * out[idx] + 0.715158 * out[idx + 1] + 0.072186 * out[idx + 2]);
             if (mode === "shape") {
               out[idx] = state.background.r;
               out[idx + 1] = state.background.g;
@@ -3655,17 +3928,19 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
     } else if (t === "-separate") {
       const nextStack = [];
       for (const im of stack) {
+        if (++cooperativeWork % 65536 === 0)
+          yield;
         if (state.channelExplicit) {
-          if (state.channels.r) nextStack.push(extractChannelImage(im, 0));
-          if (state.channels.g) nextStack.push(extractChannelImage(im, 1));
-          if (state.channels.b) nextStack.push(extractChannelImage(im, 2));
-          if (state.channels.a) nextStack.push(extractChannelImage(ensureAlphaImage(im, 1), 3));
+          if (state.channels.r)
+            nextStack.push(extractChannelImage(im, 0));
+          if (state.channels.g)
+            nextStack.push(extractChannelImage(im, 1));
+          if (state.channels.b)
+            nextStack.push(extractChannelImage(im, 2));
+          if (state.channels.a)
+            nextStack.push(extractChannelImage(ensureAlphaImage(im, 1), 3));
         } else {
-          nextStack.push(
-            extractChannelImage(im, 0),
-            extractChannelImage(im, 1),
-            extractChannelImage(im, 2)
-          );
+          nextStack.push(extractChannelImage(im, 0), extractChannelImage(im, 1), extractChannelImage(im, 2));
           if (im.hasAlpha) {
             nextStack.push(extractChannelImage(ensureAlphaImage(im, 1), 3));
           }
@@ -3680,6 +3955,8 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
         const aIm = stack[3];
         const out = new Uint8Array(rIm.width * rIm.height * 4);
         for (let p = 0; p < out.length; p += 4) {
+          if (++cooperativeWork % 65536 === 0)
+            yield;
           out[p] = rIm.data[p];
           out[p + 1] = gIm.data[p];
           out[p + 2] = bIm.data[p];
@@ -3689,19 +3966,26 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
       }
     } else if (t === "-draw") {
       const drawSpec = tokens[++i] ?? "";
-      stack = stack.map((im) => applyMagickDraw(im, drawSpec, state));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickDrawSteps(im, drawSpec, state, signal);
+      });
     } else if (t === "-annotate") {
       const offsetOrText = tokens[++i] ?? "+0+0";
       const hasExplicitOffset = /^[+-]\d/.test(offsetOrText) || /^\d+x\d+/.test(offsetOrText);
       const offset = hasExplicitOffset ? offsetOrText : "+0+0";
       const text = hasExplicitOffset ? tokens[++i] ?? "" : offsetOrText;
-      stack = stack.map((im) => applyMagickAnnotate(im, offset, text, state));
+      stack = yield* mapSteps(stack, function* (im) {
+        return yield* applyMagickAnnotateSteps(im, offset, text, state, signal);
+      });
     } else if (t === "+clone" || t === "-clone") {
       const sourcePool = stack.length > 0 ? stack : parentStack;
       const spec = t === "+clone" ? "-1" : tokens[++i] ?? "-1";
       for (const idx of parseMagickIndexSpec(spec, sourcePool.length)) {
+        if (++cooperativeWork % 65536 === 0)
+          yield;
         const chosen = sourcePool[idx];
-        if (chosen) stack.push({ ...chosen, data: new Uint8Array(chosen.data) });
+        if (chosen)
+          stack.push({ ...chosen, data: new Uint8Array(chosen.data) });
       }
     } else if (t === "-duplicate" || t === "+duplicate") {
       let count = 1;
@@ -3722,9 +4006,14 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
       const sourcePool = stack.length > 0 ? stack : parentStack;
       const indices = parseMagickIndexSpec(idxSpec, sourcePool.length);
       for (let k = 0; k < count; k++) {
+        if (++cooperativeWork % 65536 === 0)
+          yield;
         for (const idx of indices) {
+          if (++cooperativeWork % 65536 === 0)
+            yield;
           const chosen = sourcePool[idx];
-          if (chosen) stack.push({ ...chosen, data: new Uint8Array(chosen.data) });
+          if (chosen)
+            stack.push({ ...chosen, data: new Uint8Array(chosen.data) });
         }
       }
     } else if (t === "+insert" || t === "-insert") {
@@ -3759,7 +4048,8 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
     } else if (t === "-append" || t === "+append") {
       stack = [appendStackImages(stack, t === "-append", state)];
     } else if (t === "-flatten" || t === "-mosaic" || t === "-layers" && ["flatten", "merge", "mosaic"].includes((tokens[i + 1] ?? "").toLowerCase())) {
-      if (t === "-layers") i++;
+      if (t === "-layers")
+        i++;
       if (stack.length > 0) {
         const maxW = Math.max(...stack.map((im) => im.width));
         const maxH = Math.max(...stack.map((im) => im.height));
@@ -3782,14 +4072,7 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
           gy = g.y;
         }
         const grav = resolveGravityOffset(base.width - overlay.width, base.height - overlay.height, state.gravity);
-        const composed = applyMagickCompositeLayer(
-          base,
-          overlay,
-          state.composeRaw,
-          grav.left + gx,
-          grav.top + gy,
-          state.composeArgs
-        );
+        const composed = yield* applyMagickCompositeLayerSteps(base, overlay, state.composeRaw, grav.left + gx, grav.top + gy, state.composeArgs, signal);
         stack = [composed, ...stack.slice(2)];
       }
     } else {
@@ -3802,10 +4085,8 @@ function evaluatePipelineTokens(tokens, files, state, parentStack = [], stdinByt
   }
   return stack;
 }
-async function runConvertCli(argv, files, stdinBytes) {
-  return runConvertCliSync(argv, files, stdinBytes);
-}
-function runConvertCliSync(argv, files, stdinBytes) {
+function* runConvertCliSteps(argv, files, stdinBytes, signal) {
+  let cooperativeWork = 63;
   if (argv.length === 0 || argv.includes("--help") || argv.includes("-help") || argv.includes("-h")) {
     return {
       exitCode: 0,
@@ -3824,7 +4105,7 @@ function runConvertCliSync(argv, files, stdinBytes) {
   const pipelineTokens = argv.slice(0, -1);
   const state = createDefaultState();
   try {
-    const stack = evaluatePipelineTokens(pipelineTokens, files, state, [], stdinBytes);
+    const stack = yield* evaluatePipelineTokensSteps(pipelineTokens, files, state, [], stdinBytes, signal);
     if (stack.length === 0) {
       return {
         exitCode: 1,
@@ -3860,6 +4141,8 @@ function runConvertCliSync(argv, files, stdinBytes) {
     const { format, path: outPath } = inferOutputFormat(outSpec, "png");
     if (stack.length > 1 && (/%0?\d*d/.test(outPath) || !state.adjoin)) {
       for (let idx = 0; idx < stack.length; idx++) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const framePath = formatSceneOutputPath(outPath, idx);
         const { data: frameBytes } = encodeImage(stack[idx], { format, quality: state.quality });
         files.set(framePath, frameBytes);
@@ -3873,6 +4156,8 @@ function runConvertCliSync(argv, files, stdinBytes) {
       const fh = stack[0].height;
       const combined = new Uint8Array(fw * fh * stack.length * 4);
       for (let idx = 0; idx < stack.length; idx++) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const frame = stack[idx].width === fw && stack[idx].height === fh ? stack[idx] : applyMagickResize(stack[idx], `${fw}x${fh}!`, state.kernel);
         combined.set(frame.data, idx * fw * fh * 4);
       }
@@ -3910,10 +4195,19 @@ function runConvertCliSync(argv, files, stdinBytes) {
     };
   }
 }
-async function runMogrifyCli(argv, files) {
-  return runMogrifyCliSync(argv, files);
+async function runConvertCli(argv, files, stdinBytes, signal) {
+  return drainSteps(runConvertCliSteps(argv, files, stdinBytes, signal), signal);
+}
+function runConvertCliSync(argv, files, stdinBytes, signal) {
+  const steps = runConvertCliSteps(argv, files, stdinBytes, signal);
+  let next = steps.next();
+  while (!next.done) {
+    next = steps.next();
+  }
+  return next.value;
 }
-function runMogrifyCliSync(argv, files) {
+function* runMogrifyCliSteps(argv, files, _stdinBytes, signal) {
+  let cooperativeWork = 63;
   let outFormatExt;
   let outDir;
   const opTokens = [];
@@ -4004,6 +4298,8 @@ function runMogrifyCliSync(argv, files) {
     "-sketch"
   ]);
   for (let i = 0; i < argv.length; i++) {
+    if (++cooperativeWork % 64 === 0)
+      yield;
     const t = argv[i];
     if (t === "-format") {
       outFormatExt = (argv[++i] ?? "png").replace(/^\./, "").toLowerCase();
@@ -4031,6 +4327,8 @@ function runMogrifyCliSync(argv, files) {
     }
   }
   for (const target of targets) {
+    if (++cooperativeWork % 64 === 0)
+      yield;
     if (!files.has(target)) {
       return {
         exitCode: 1,
@@ -4045,18 +4343,30 @@ function runMogrifyCliSync(argv, files) {
     const targetExt = outFormatExt ?? origExt;
     const destDir = outDir ? outDir.replace(/\/+$/, "") : target.slice(0, Math.max(0, target.lastIndexOf("/")));
     const destPath = outFormatExt || outDir ? `${destDir ? destDir + "/" : ""}${stem}.${targetExt}` : target;
-    const res = runConvertCliSync([...readSettings, target, ...opTokens, destPath], files);
-    if (res.exitCode !== 0) return res;
+    const res = yield* runConvertCliSteps([...readSettings, target, ...opTokens, destPath], files, void 0, signal);
+    if (res.exitCode !== 0)
+      return res;
   }
   return { exitCode: 0, stdout: "", stderr: "" };
 }
-async function runCompositeCli(argv, files, stdinBytes) {
-  return runCompositeCliSync(argv, files, stdinBytes);
+async function runMogrifyCli(argv, files, _stdinBytes, signal) {
+  return drainSteps(runMogrifyCliSteps(argv, files, _stdinBytes, signal), signal);
 }
-function runCompositeCliSync(argv, files, stdinBytes) {
+function runMogrifyCliSync(argv, files, _stdinBytes, signal) {
+  const steps = runMogrifyCliSteps(argv, files, _stdinBytes, signal);
+  let next = steps.next();
+  while (!next.done) {
+    next = steps.next();
+  }
+  return next.value;
+}
+function* runCompositeCliSteps(argv, files, stdinBytes, signal) {
+  let cooperativeWork = 63;
   const options = [];
   const operands = [];
   for (let i = 0; i < argv.length; i++) {
+    if (++cooperativeWork % 64 === 0)
+      yield;
     const t = argv[i];
     if (t === "-gravity" || t === "-geometry" || t === "-compose" || t === "-background" || t === "-quality" || t === "-define") {
       options.push(t, argv[++i] ?? "");
@@ -4080,7 +4390,18 @@ function runCompositeCliSync(argv, files, stdinBytes) {
   const overlay = operands[0];
   const base = operands[1];
   const out = operands[operands.length - 1];
-  return runConvertCliSync([base, overlay, ...options, "-composite", out], files, stdinBytes);
+  return yield* runConvertCliSteps([base, overlay, ...options, "-composite", out], files, stdinBytes, signal);
+}
+async function runCompositeCli(argv, files, stdinBytes, signal) {
+  return drainSteps(runCompositeCliSteps(argv, files, stdinBytes, signal), signal);
+}
+function runCompositeCliSync(argv, files, stdinBytes, signal) {
+  const steps = runCompositeCliSteps(argv, files, stdinBytes, signal);
+  let next = steps.next();
+  while (!next.done) {
+    next = steps.next();
+  }
+  return next.value;
 }
 function formatMetricNum(n) {
   if (!Number.isFinite(n)) return "inf";
@@ -4088,10 +4409,8 @@ function formatMetricNum(n) {
   const fixed = n.toFixed(6).replace(/\.?0+$/, "");
   return fixed === "-0" ? "0" : fixed;
 }
-async function runCompareCli(argv, files, stdinBytes) {
-  return runCompareCliSync(argv, files, stdinBytes);
-}
-function runCompareCliSync(argv, files, stdinBytes) {
+function* runCompareCliSteps(argv, files, stdinBytes, signal) {
+  let cooperativeWork = 63;
   const state = createDefaultState();
   state.fuzz = 0;
   let metric = "rmse";
@@ -4101,6 +4420,8 @@ function runCompareCliSync(argv, files, stdinBytes) {
   let dissimilarityThreshold;
   const operands = [];
   for (let i = 0; i < argv.length; i++) {
+    if (++cooperativeWork % 64 === 0)
+      yield;
     const t = argv[i];
     if (t === "--help" || t === "-help" || t === "-h") {
       return {
@@ -4119,7 +4440,8 @@ function runCompareCliSync(argv, files, stdinBytes) {
       lowlightColor = parseColor2(argv[++i] ?? "#ffffff");
     } else if (t === "-compose") {
       const cm = (argv[++i] ?? "over").toLowerCase();
-      if (cm === "src" || cm === "source" || cm === "copy") composeSrc = true;
+      if (cm === "src" || cm === "source" || cm === "copy")
+        composeSrc = true;
     } else if (t === "-dissimilarity-threshold") {
       dissimilarityThreshold = Number(argv[++i] ?? 1);
     } else if (t === "-density") {
@@ -4128,7 +4450,8 @@ function runCompareCliSync(argv, files, stdinBytes) {
     } else if (t === "-quality") {
       state.quality = Math.max(1, Math.min(100, Number(argv[++i] ?? 92)));
     } else if (t.startsWith("-") && t.length > 1) {
-      if (t === "-format" || t === "-alpha" || t === "-channel") i++;
+      if (t === "-format" || t === "-alpha" || t === "-channel")
+        i++;
     } else {
       operands.push(t);
     }
@@ -4185,7 +4508,11 @@ function runCompareCliSync(argv, files, stdinBytes) {
   let sumLumA = 0;
   let sumLumB = 0;
   for (let y = 0; y < height; y++) {
+    if (++cooperativeWork % 64 === 0)
+      yield;
     for (let x = 0; x < width; x++) {
+      if (++cooperativeWork % 64 === 0)
+        yield;
       const pIdx = y * width + x;
       const outOff = pIdx * 4;
       const inBoundsA = x < imgA.width && y < imgA.height;
@@ -4240,7 +4567,8 @@ function runCompareCliSync(argv, files, stdinBytes) {
         sumAbs += dr + dg + db;
         sumSq += dr * dr + dg * dg + db * db;
       }
-      if (maxDelta > maxAbs) maxAbs = maxDelta;
+      if (maxDelta > maxAbs)
+        maxAbs = maxDelta;
       const lA = (0.299 * rA + 0.587 * gA + 0.114 * bA) / 255;
       const lB = (0.299 * rB + 0.587 * gB + 0.114 * bB) / 255;
       lumA[pIdx] = lA;
@@ -4260,6 +4588,8 @@ function runCompareCliSync(argv, files, stdinBytes) {
   let varB = 0;
   let covAB = 0;
   for (let i = 0; i < totalPixels; i++) {
+    if (++cooperativeWork % 64 === 0)
+      yield;
     const dA = lumA[i] - muA;
     const dB = lumB[i] - muB;
     varA += dA * dA;
@@ -4337,10 +4667,19 @@ function runCompareCliSync(argv, files, stdinBytes) {
 `
   };
 }
-async function runMontageCli(argv, files, stdinBytes) {
-  return runMontageCliSync(argv, files, stdinBytes);
+async function runCompareCli(argv, files, stdinBytes, signal) {
+  return drainSteps(runCompareCliSteps(argv, files, stdinBytes, signal), signal);
 }
-function runMontageCliSync(argv, files, stdinBytes) {
+function runCompareCliSync(argv, files, stdinBytes, signal) {
+  const steps = runCompareCliSteps(argv, files, stdinBytes, signal);
+  let next = steps.next();
+  while (!next.done) {
+    next = steps.next();
+  }
+  return next.value;
+}
+function* runMontageCliSteps(argv, files, stdinBytes, signal) {
+  let cooperativeWork = 63;
   const state = createDefaultState();
   let tileCols;
   let tileRows;
@@ -4351,6 +4690,8 @@ function runMontageCliSync(argv, files, stdinBytes) {
   let borderW = 0;
   const operands = [];
   for (let i = 0; i < argv.length; i++) {
+    if (++cooperativeWork % 64 === 0)
+      yield;
     const t = argv[i];
     if (t === "-tile") {
       const g = parseMagickGeometry(argv[++i] ?? "2x2");
@@ -4391,6 +4732,7 @@ function runMontageCliSync(argv, files, stdinBytes) {
   const inPaths = operands.slice(0, -1);
   const images = [];
   for (const p of inPaths) {
+    yield;
     let loadedList;
     try {
       loadedList = parseInputOperands(p, files, state, stdinBytes);
@@ -4411,6 +4753,8 @@ function runMontageCliSync(argv, files, stdinBytes) {
       };
     }
     for (const loaded of loadedList) {
+      if (++cooperativeWork % 64 === 0)
+        yield;
       let thumb = loaded;
       if (cellW !== void 0 || cellH !== void 0) {
         const geomSpec = `${cellW ?? ""}${cellH !== void 0 ? "x" + cellH : ""}`;
@@ -4441,9 +4785,12 @@ function runMontageCliSync(argv, files, stdinBytes) {
   const canvas = createSolidRgbaImage(canvasW, canvasH, state.background);
   const layers = [];
   for (let idx = 0; idx < images.length; idx++) {
+    if (++cooperativeWork % 64 === 0)
+      yield;
     const col = idx % cols;
     const row = Math.floor(idx / cols);
-    if (row >= rows) break;
+    if (row >= rows)
+      break;
     const im = images[idx];
     const cellX = col * slotW + padX;
     const cellY = row * slotH + padY;
@@ -4459,32 +4806,52 @@ function runMontageCliSync(argv, files, stdinBytes) {
   files.set(outPath, encoded);
   return { exitCode: 0, stdout: "", stderr: "" };
 }
-async function runMagickCli(argv, files, stdinBytes) {
-  return runMagickCliSync(argv, files, stdinBytes);
+async function runMontageCli(argv, files, stdinBytes, signal) {
+  return drainSteps(runMontageCliSteps(argv, files, stdinBytes, signal), signal);
+}
+function runMontageCliSync(argv, files, stdinBytes, signal) {
+  const steps = runMontageCliSteps(argv, files, stdinBytes, signal);
+  let next = steps.next();
+  while (!next.done) {
+    next = steps.next();
+  }
+  return next.value;
 }
-function runMagickCliSync(argv, files, stdinBytes) {
+function* runMagickCliSteps(argv, files, stdinBytes, signal) {
   const sub = argv[0];
   if (sub === "identify") {
-    return runIdentifyCliSync(argv.slice(1), files, stdinBytes);
+    return yield* runIdentifyCliSteps(argv.slice(1), files, stdinBytes, signal);
   }
   if (sub === "mogrify") {
-    return runMogrifyCliSync(argv.slice(1), files);
+    return yield* runMogrifyCliSteps(argv.slice(1), files, void 0, signal);
   }
   if (sub === "composite") {
-    return runCompositeCliSync(argv.slice(1), files, stdinBytes);
+    return yield* runCompositeCliSteps(argv.slice(1), files, stdinBytes, signal);
   }
   if (sub === "montage") {
-    return runMontageCliSync(argv.slice(1), files, stdinBytes);
+    return yield* runMontageCliSteps(argv.slice(1), files, stdinBytes, signal);
   }
   if (sub === "compare") {
-    return runCompareCliSync(argv.slice(1), files, stdinBytes);
+    return yield* runCompareCliSteps(argv.slice(1), files, stdinBytes, signal);
   }
   if (sub === "convert") {
-    return runConvertCliSync(argv.slice(1), files, stdinBytes);
+    return yield* runConvertCliSteps(argv.slice(1), files, stdinBytes, signal);
   }
-  return runConvertCliSync(argv, files, stdinBytes);
+  return yield* runConvertCliSteps(argv, files, stdinBytes, signal);
+}
+async function runMagickCli(argv, files, stdinBytes, signal) {
+  return drainSteps(runMagickCliSteps(argv, files, stdinBytes, signal), signal);
+}
+function runMagickCliSync(argv, files, stdinBytes, signal) {
+  const steps = runMagickCliSteps(argv, files, stdinBytes, signal);
+  let next = steps.next();
+  while (!next.done) {
+    next = steps.next();
+  }
+  return next.value;
 }
 async function executeVfsMagickTool(context, runner) {
+  let cooperativeWork = 63;
   const invocation = createOutputOperation(context, { write: async () => {
   } });
   try {
@@ -4495,6 +4862,7 @@ async function executeVfsMagickTool(context, runner) {
     let needsStdin = false;
     const hasOutputOperand = runner !== runIdentifyCli && !(runner === runMagickCli && argv[0] === "identify");
     for (const [index, token] of argv.entries()) {
+      if (++cooperativeWork % 64 === 0) await yieldTurn(context.signal);
       if (token === "-" || token.endsWith(":-")) {
         if (!hasOutputOperand || index < argv.length - 1) needsStdin = true;
         continue;
@@ -4522,18 +4890,21 @@ async function executeVfsMagickTool(context, runner) {
       const chunks = [];
       let total = 0;
       for await (const chunk of readBytes(context.stdin, invocation.signal)) {
+        if (++cooperativeWork % 64 === 0) await yieldTurn(context.signal);
         chunks.push(chunk);
         total += chunk.byteLength;
       }
       stdinBytes = new Uint8Array(total);
       let off = 0;
       for (const chunk of chunks) {
+        if (++cooperativeWork % 64 === 0) await yieldTurn(context.signal);
         stdinBytes.set(chunk, off);
         off += chunk.byteLength;
       }
     }
+    context.inputBudget?.check(0);
     const existingSnap = new Map(vfsFiles);
-    const res = await runner(argv, vfsFiles, stdinBytes);
+    const res = await runner(argv, vfsFiles, stdinBytes, invocation.signal);
     if (res.stderr) {
       await writeBytes(context.stderr, new TextEncoder().encode(res.stderr), invocation.signal);
     }
@@ -4545,6 +4916,7 @@ async function executeVfsMagickTool(context, runner) {
       await writeBytes(stdout.output, new TextEncoder().encode(res.stdout), invocation.signal);
     }
     for (const [key, val] of vfsFiles.entries()) {
+      if (++cooperativeWork % 64 === 0) await yieldTurn(context.signal);
       if (existingSnap.get(key) !== val) {
         const abs = resolveVfsPath(key);
         const parentDir = abs.slice(0, abs.lastIndexOf("/")) || "/";
@@ -4560,79 +4932,100 @@ async function executeVfsMagickTool(context, runner) {
     await invocation.close();
   }
 }
-function createMagickCommand(_options = {}) {
+function createMagickCommand(options = {}) {
+  const maxInputBytes = InputByteBudget.limit(options.limits?.maxInputBytes);
   return Object.freeze({
     name: "magick",
     runtimeIdentity: commandRuntimeIdentity,
     description: "ImageMagick v7 image processor powered by @poe-code/image-ast",
     execute(context) {
-      return executeVfsMagickTool(context, runMagickCli);
+      return new InputByteBudget(maxInputBytes).run(context, async (context2) => {
+        return executeVfsMagickTool(context2, runMagickCli);
+      });
     }
   });
 }
 var magickCommand = createMagickCommand();
-function createConvertCommand(_options = {}) {
+function createConvertCommand(options = {}) {
+  const maxInputBytes = InputByteBudget.limit(options.limits?.maxInputBytes);
   return Object.freeze({
     name: "convert",
     runtimeIdentity: commandRuntimeIdentity,
     description: "ImageMagick convert pipeline powered by @poe-code/image-ast",
     execute(context) {
-      return executeVfsMagickTool(context, runConvertCli);
+      return new InputByteBudget(maxInputBytes).run(context, async (context2) => {
+        return executeVfsMagickTool(context2, runConvertCli);
+      });
     }
   });
 }
 var convertCommand = createConvertCommand();
-function createMogrifyCommand(_options = {}) {
+function createMogrifyCommand(options = {}) {
+  const maxInputBytes = InputByteBudget.limit(options.limits?.maxInputBytes);
   return Object.freeze({
     name: "mogrify",
     runtimeIdentity: commandRuntimeIdentity,
     description: "ImageMagick in-place batch image processor powered by @poe-code/image-ast",
     execute(context) {
-      return executeVfsMagickTool(context, (argv, files) => runMogrifyCli(argv, files));
+      return new InputByteBudget(maxInputBytes).run(context, async (context2) => {
+        return executeVfsMagickTool(context2, runMogrifyCli);
+      });
     }
   });
 }
 var mogrifyCommand = createMogrifyCommand();
-function createCompositeCommand(_options = {}) {
+function createCompositeCommand(options = {}) {
+  const maxInputBytes = InputByteBudget.limit(options.limits?.maxInputBytes);
   return Object.freeze({
     name: "composite",
     runtimeIdentity: commandRuntimeIdentity,
     description: "ImageMagick overlay composition tool powered by @poe-code/image-ast",
     execute(context) {
-      return executeVfsMagickTool(context, runCompositeCli);
+      return new InputByteBudget(maxInputBytes).run(context, async (context2) => {
+        return executeVfsMagickTool(context2, runCompositeCli);
+      });
     }
   });
 }
 var compositeCommand = createCompositeCommand();
-function createMontageCommand(_options = {}) {
+function createMontageCommand(options = {}) {
+  const maxInputBytes = InputByteBudget.limit(options.limits?.maxInputBytes);
   return Object.freeze({
     name: "montage",
     runtimeIdentity: commandRuntimeIdentity,
     description: "ImageMagick contact-sheet grid generator powered by @poe-code/image-ast",
     execute(context) {
-      return executeVfsMagickTool(context, runMontageCli);
+      return new InputByteBudget(maxInputBytes).run(context, async (context2) => {
+        return executeVfsMagickTool(context2, runMontageCli);
+      });
     }
   });
 }
 var montageCommand = createMontageCommand();
-function createIdentifyCommand(_options = {}) {
+function createIdentifyCommand(options = {}) {
+  const maxInputBytes = InputByteBudget.limit(options.limits?.maxInputBytes);
   return Object.freeze({
     name: "identify",
     runtimeIdentity: commandRuntimeIdentity,
     description: "ImageMagick image metadata inspector powered by @poe-code/image-ast",
     execute(context) {
-      return executeVfsMagickTool(context, runIdentifyCli);
+      return new InputByteBudget(maxInputBytes).run(context, async (context2) => {
+        return executeVfsMagickTool(context2, runIdentifyCli);
+      });
     }
   });
 }
 var identifyCommand = createIdentifyCommand();
-function createCompareCommand(_options = {}) {
+function createCompareCommand(options = {}) {
+  const maxInputBytes = InputByteBudget.limit(options.limits?.maxInputBytes);
   return Object.freeze({
     name: "compare",
     runtimeIdentity: commandRuntimeIdentity,
     description: "ImageMagick image comparison and diff generator powered by @poe-code/image-ast",
     execute(context) {
-      return executeVfsMagickTool(context, runCompareCli);
+      return new InputByteBudget(maxInputBytes).run(context, async (context2) => {
+        return executeVfsMagickTool(context2, runCompareCli);
+      });
     }
   });
 }
@@ -4663,6 +5056,11 @@ var imagemagickCommands = imagemagickPlugin;
 function createImagemagickCommands(options = {}) {
   return [createMagickCommand(options), createConvertCommand(options), createMogrifyCommand(options), createCompositeCommand(options), createMontageCommand(options), createIdentifyCommand(options), createCompareCommand(options)];
 }
+function* mapSteps(values, mapper) {
+  const result = [];
+  for (const value of values) result.push(yield* mapper(value));
+  return result;
+}
 export {
   compareCommand,
   compositeCommand,