@workglow/tasks 0.2.17 → 0.2.19

package/dist/electron.js

@@ -10,7 +10,7 @@ import { parseDataUri } from "@workglow/util/media";
 // src/task/image/imageCodecLimits.ts
 var MAX_DECODED_PIXELS = 1e8;
 var MAX_INPUT_BYTES_NODE = 64 * 1024 * 1024;
-var MAX_INPUT_BYTES_BROWSER = 8 * 1024 * 1024;
+var MAX_INPUT_BYTES_BROWSER = 32 * 1024 * 1024;
 var REJECTED_DECODE_MIME_TYPES = new Set([
   "image/svg+xml",
   "image/svg",
@@ -146,6 +146,605 @@ function createNodeImageRasterCodec() {
 // src/task/image/registerImageRasterCodec.node.ts
 registerImageRasterCodec(createNodeImageRasterCodec());
 
+// src/task/image/blur/blur.cpu.ts
+import { CpuImage, registerFilterOp } from "@workglow/util/media";
+function cpuBoxBlur(bin, radius) {
+  const { data: src, width, height, channels } = bin;
+  const kernelSize = radius * 2 + 1;
+  const tmp = new Uint8ClampedArray(src.length);
+  for (let y = 0;y < height; y++) {
+    for (let c = 0;c < channels; c++) {
+      let sum = 0;
+      for (let k = -radius;k <= radius; k++) {
+        const x = Math.max(0, Math.min(k, width - 1));
+        sum += src[(y * width + x) * channels + c];
+      }
+      tmp[y * width * channels + c] = sum / kernelSize + 0.5 | 0;
+      for (let x = 1;x < width; x++) {
+        const addX = Math.min(x + radius, width - 1);
+        const removeX = Math.max(x - radius - 1, 0);
+        sum += src[(y * width + addX) * channels + c] - src[(y * width + removeX) * channels + c];
+        tmp[(y * width + x) * channels + c] = sum / kernelSize + 0.5 | 0;
+      }
+    }
+  }
+  const dst = new Uint8ClampedArray(src.length);
+  for (let x = 0;x < width; x++) {
+    for (let c = 0;c < channels; c++) {
+      let sum = 0;
+      for (let k = -radius;k <= radius; k++) {
+        const y = Math.max(0, Math.min(k, height - 1));
+        sum += tmp[(y * width + x) * channels + c];
+      }
+      dst[x * channels + c] = sum / kernelSize + 0.5 | 0;
+      for (let y = 1;y < height; y++) {
+        const addY = Math.min(y + radius, height - 1);
+        const removeY = Math.max(y - radius - 1, 0);
+        sum += tmp[(addY * width + x) * channels + c] - tmp[(removeY * width + x) * channels + c];
+        dst[(y * width + x) * channels + c] = sum / kernelSize + 0.5 | 0;
+      }
+    }
+  }
+  return { data: dst, width, height, channels };
+}
+registerFilterOp("cpu", "blur", (image, { radius }) => {
+  return CpuImage.fromImageBinary(cpuBoxBlur(image.getBinary(), Math.max(1, radius | 0)));
+});
+
+// src/task/image/border/border.cpu.ts
+import { CpuImage as CpuImage2, registerFilterOp as registerFilterOp2, resolveColor } from "@workglow/util/media";
+function cpuBorder(bin, borderWidth, color) {
+  const { data: src, width: srcW, height: srcH, channels: srcCh } = bin;
+  const bw = borderWidth;
+  const resolved = resolveColor(color);
+  const outCh = 4;
+  const dstW = srcW + bw * 2;
+  const dstH = srcH + bw * 2;
+  const dst = new Uint8ClampedArray(dstW * dstH * outCh);
+  const r = resolved.r;
+  const g = resolved.g;
+  const b = resolved.b;
+  const a = resolved.a;
+  for (let i = 0;i < dst.length; i += outCh) {
+    dst[i] = r;
+    dst[i + 1] = g;
+    dst[i + 2] = b;
+    dst[i + 3] = a;
+  }
+  for (let y = 0;y < srcH; y++) {
+    for (let x = 0;x < srcW; x++) {
+      const srcIdx = (y * srcW + x) * srcCh;
+      const dstIdx = ((y + bw) * dstW + (x + bw)) * outCh;
+      dst[dstIdx] = src[srcIdx];
+      dst[dstIdx + 1] = srcCh >= 3 ? src[srcIdx + 1] : src[srcIdx];
+      dst[dstIdx + 2] = srcCh >= 3 ? src[srcIdx + 2] : src[srcIdx];
+      dst[dstIdx + 3] = srcCh === 4 ? src[srcIdx + 3] : 255;
+    }
+  }
+  return { data: dst, width: dstW, height: dstH, channels: outCh };
+}
+registerFilterOp2("cpu", "border", (image, { borderWidth, color }) => {
+  return CpuImage2.fromImageBinary(cpuBorder(image.getBinary(), borderWidth, color));
+});
+
+// src/task/image/brightness/brightness.cpu.ts
+import { CpuImage as CpuImage3, registerFilterOp as registerFilterOp3 } from "@workglow/util/media";
+function cpuBrightness(bin, amount) {
+  const { data: src, width, height, channels } = bin;
+  const dst = new Uint8ClampedArray(src.length);
+  if (channels === 4) {
+    for (let i = 0;i < src.length; i += 4) {
+      dst[i] = src[i] + amount;
+      dst[i + 1] = src[i + 1] + amount;
+      dst[i + 2] = src[i + 2] + amount;
+      dst[i + 3] = src[i + 3];
+    }
+  } else {
+    for (let i = 0;i < src.length; i++) {
+      dst[i] = src[i] + amount;
+    }
+  }
+  return { data: dst, width, height, channels };
+}
+registerFilterOp3("cpu", "brightness", (image, { amount }) => {
+  return CpuImage3.fromImageBinary(cpuBrightness(image.getBinary(), amount));
+});
+
+// src/task/image/contrast/contrast.cpu.ts
+import { CpuImage as CpuImage4, registerFilterOp as registerFilterOp4 } from "@workglow/util/media";
+function cpuContrast(bin, amount) {
+  const { data: src, width, height, channels } = bin;
+  const factor = 259 * (amount + 255) / (255 * (259 - amount));
+  const lut = new Uint8ClampedArray(256);
+  for (let i = 0;i < 256; i++) {
+    lut[i] = factor * (i - 128) + 128;
+  }
+  const dst = new Uint8ClampedArray(src.length);
+  if (channels === 4) {
+    for (let i = 0;i < src.length; i += 4) {
+      dst[i] = lut[src[i]];
+      dst[i + 1] = lut[src[i + 1]];
+      dst[i + 2] = lut[src[i + 2]];
+      dst[i + 3] = src[i + 3];
+    }
+  } else {
+    for (let i = 0;i < src.length; i++) {
+      dst[i] = lut[src[i]];
+    }
+  }
+  return { data: dst, width, height, channels };
+}
+registerFilterOp4("cpu", "contrast", (image, { amount }) => {
+  return CpuImage4.fromImageBinary(cpuContrast(image.getBinary(), amount));
+});
+
+// src/task/image/crop/crop.cpu.ts
+import { CpuImage as CpuImage5, registerFilterOp as registerFilterOp5 } from "@workglow/util/media";
+function cpuCrop(bin, left, top, width, height) {
+  const { data: src, width: srcW, height: srcH, channels } = bin;
+  if (srcW < 1 || srcH < 1) {
+    throw new RangeError("Cannot crop an empty image");
+  }
+  if (left < 0 || left >= srcW || top < 0 || top >= srcH) {
+    throw new RangeError("Crop origin is outside the source image bounds");
+  }
+  const w = Math.min(width, srcW - left);
+  const h = Math.min(height, srcH - top);
+  const dst = new Uint8ClampedArray(w * h * channels);
+  const rowBytes = w * channels;
+  for (let row = 0;row < h; row++) {
+    const srcOffset = ((top + row) * srcW + left) * channels;
+    const dstOffset = row * rowBytes;
+    dst.set(src.subarray(srcOffset, srcOffset + rowBytes), dstOffset);
+  }
+  return { data: dst, width: w, height: h, channels };
+}
+registerFilterOp5("cpu", "crop", (image, { left, top, width, height }) => {
+  return CpuImage5.fromImageBinary(cpuCrop(image.getBinary(), left, top, width, height));
+});
+
+// src/task/image/flip/flip.cpu.ts
+import { CpuImage as CpuImage6, registerFilterOp as registerFilterOp6 } from "@workglow/util/media";
+function cpuFlip(bin, direction) {
+  const { data: src, width, height, channels } = bin;
+  const dst = new Uint8ClampedArray(src.length);
+  const rowBytes = width * channels;
+  if (direction === "vertical") {
+    for (let y = 0;y < height; y++) {
+      const srcOffset = y * rowBytes;
+      const dstOffset = (height - 1 - y) * rowBytes;
+      dst.set(src.subarray(srcOffset, srcOffset + rowBytes), dstOffset);
+    }
+  } else {
+    for (let y = 0;y < height; y++) {
+      for (let x = 0;x < width; x++) {
+        const srcIdx = (y * width + x) * channels;
+        const dstIdx = (y * width + (width - 1 - x)) * channels;
+        for (let c = 0;c < channels; c++) {
+          dst[dstIdx + c] = src[srcIdx + c];
+        }
+      }
+    }
+  }
+  return { data: dst, width, height, channels };
+}
+registerFilterOp6("cpu", "flip", (image, { direction }) => {
+  return CpuImage6.fromImageBinary(cpuFlip(image.getBinary(), direction));
+});
+
+// src/task/image/grayscale/grayscale.cpu.ts
+import { CpuImage as CpuImage7, registerFilterOp as registerFilterOp7 } from "@workglow/util/media";
+function cpuGrayscale(bin) {
+  const { data: src, width, height, channels } = bin;
+  const pixelCount = width * height;
+  const dst = new Uint8ClampedArray(pixelCount * 4);
+  for (let i = 0;i < pixelCount; i++) {
+    const idx = i * channels;
+    let g;
+    if (channels === 1) {
+      g = src[idx];
+    } else {
+      g = src[idx] * 77 + src[idx + 1] * 150 + src[idx + 2] * 29 >> 8;
+    }
+    const a = channels === 4 ? src[idx + 3] : 255;
+    const dstIdx = i * 4;
+    dst[dstIdx] = g;
+    dst[dstIdx + 1] = g;
+    dst[dstIdx + 2] = g;
+    dst[dstIdx + 3] = a;
+  }
+  return { data: dst, width, height, channels: 4 };
+}
+registerFilterOp7("cpu", "grayscale", (image, _params) => {
+  return CpuImage7.fromImageBinary(cpuGrayscale(image.getBinary()));
+});
+
+// src/task/image/invert/invert.cpu.ts
+import { CpuImage as CpuImage8, registerFilterOp as registerFilterOp8 } from "@workglow/util/media";
+function cpuInvert(bin) {
+  const { data: src, width, height, channels } = bin;
+  const dst = new Uint8ClampedArray(src.length);
+  if (channels === 4) {
+    for (let i = 0;i < src.length; i += 4) {
+      dst[i] = 255 - src[i];
+      dst[i + 1] = 255 - src[i + 1];
+      dst[i + 2] = 255 - src[i + 2];
+      dst[i + 3] = src[i + 3];
+    }
+  } else {
+    for (let i = 0;i < src.length; i++) {
+      dst[i] = 255 - src[i];
+    }
+  }
+  return { data: dst, width, height, channels };
+}
+registerFilterOp8("cpu", "invert", (image, _params) => {
+  return CpuImage8.fromImageBinary(cpuInvert(image.getBinary()));
+});
+
+// src/task/image/pixelate/pixelate.cpu.ts
+import { CpuImage as CpuImage9, registerFilterOp as registerFilterOp9 } from "@workglow/util/media";
+function cpuPixelate(bin, blockSize) {
+  const { data: src, width, height, channels } = bin;
+  const dst = new Uint8ClampedArray(src.length);
+  for (let by = 0;by < height; by += blockSize) {
+    const blockH = Math.min(blockSize, height - by);
+    for (let bx = 0;bx < width; bx += blockSize) {
+      const blockW = Math.min(blockSize, width - bx);
+      const blockArea = blockW * blockH;
+      const sums = new Array(channels).fill(0);
+      for (let y = by;y < by + blockH; y++) {
+        for (let x = bx;x < bx + blockW; x++) {
+          const idx = (y * width + x) * channels;
+          for (let c = 0;c < channels; c++) {
+            sums[c] += src[idx + c];
+          }
+        }
+      }
+      const avg = sums.map((s) => s / blockArea + 0.5 | 0);
+      for (let y = by;y < by + blockH; y++) {
+        for (let x = bx;x < bx + blockW; x++) {
+          const idx = (y * width + x) * channels;
+          for (let c = 0;c < channels; c++) {
+            dst[idx + c] = avg[c];
+          }
+        }
+      }
+    }
+  }
+  return { data: dst, width, height, channels };
+}
+registerFilterOp9("cpu", "pixelate", (image, { blockSize }) => {
+  return CpuImage9.fromImageBinary(cpuPixelate(image.getBinary(), blockSize));
+});
+
+// src/task/image/posterize/posterize.cpu.ts
+import { CpuImage as CpuImage10, registerFilterOp as registerFilterOp10 } from "@workglow/util/media";
+function cpuPosterize(bin, levels) {
+  const { data: src, width, height, channels } = bin;
+  const step = 255 / (levels - 1);
+  const lut = new Uint8ClampedArray(256);
+  for (let i = 0;i < 256; i++) {
+    lut[i] = Math.round(Math.round(i / step) * step);
+  }
+  const dst = new Uint8ClampedArray(src.length);
+  if (channels === 4) {
+    for (let i = 0;i < src.length; i += 4) {
+      dst[i] = lut[src[i]];
+      dst[i + 1] = lut[src[i + 1]];
+      dst[i + 2] = lut[src[i + 2]];
+      dst[i + 3] = src[i + 3];
+    }
+  } else {
+    for (let i = 0;i < src.length; i++) {
+      dst[i] = lut[src[i]];
+    }
+  }
+  return { data: dst, width, height, channels };
+}
+registerFilterOp10("cpu", "posterize", (image, { levels }) => {
+  return CpuImage10.fromImageBinary(cpuPosterize(image.getBinary(), levels));
+});
+
+// src/task/image/resize/resize.cpu.ts
+import { CpuImage as CpuImage11, registerFilterOp as registerFilterOp11 } from "@workglow/util/media";
+function cpuResize(bin, dstW, dstH) {
+  const { data: src, width: srcW, height: srcH, channels } = bin;
+  const dst = new Uint8ClampedArray(dstW * dstH * channels);
+  for (let dy = 0;dy < dstH; dy++) {
+    const srcY = Math.min(Math.floor(dy * srcH / dstH), srcH - 1);
+    for (let dx = 0;dx < dstW; dx++) {
+      const srcX = Math.min(Math.floor(dx * srcW / dstW), srcW - 1);
+      const srcIdx = (srcY * srcW + srcX) * channels;
+      const dstIdx = (dy * dstW + dx) * channels;
+      for (let c = 0;c < channels; c++) {
+        dst[dstIdx + c] = src[srcIdx + c];
+      }
+    }
+  }
+  return { data: dst, width: dstW, height: dstH, channels };
+}
+registerFilterOp11("cpu", "resize", (image, { width, height }) => {
+  return CpuImage11.fromImageBinary(cpuResize(image.getBinary(), width, height));
+});
+
+// src/task/image/rotate/rotate.cpu.ts
+import { CpuImage as CpuImage12, registerFilterOp as registerFilterOp12 } from "@workglow/util/media";
+function cpuRotate(bin, angle) {
+  const { data: src, width: srcW, height: srcH, channels } = bin;
+  const swap = angle === 90 || angle === 270;
+  const dstW = swap ? srcH : srcW;
+  const dstH = swap ? srcW : srcH;
+  const dst = new Uint8ClampedArray(dstW * dstH * channels);
+  for (let sy = 0;sy < srcH; sy++) {
+    for (let sx = 0;sx < srcW; sx++) {
+      let dx, dy;
+      if (angle === 90) {
+        dx = srcH - 1 - sy;
+        dy = sx;
+      } else if (angle === 180) {
+        dx = srcW - 1 - sx;
+        dy = srcH - 1 - sy;
+      } else {
+        dx = sy;
+        dy = srcW - 1 - sx;
+      }
+      const srcIdx = (sy * srcW + sx) * channels;
+      const dstIdx = (dy * dstW + dx) * channels;
+      for (let c = 0;c < channels; c++) {
+        dst[dstIdx + c] = src[srcIdx + c];
+      }
+    }
+  }
+  return { data: dst, width: dstW, height: dstH, channels };
+}
+registerFilterOp12("cpu", "rotate", (image, { angle }) => {
+  return CpuImage12.fromImageBinary(cpuRotate(image.getBinary(), angle));
+});
+
+// src/task/image/sepia/sepia.cpu.ts
+import { CpuImage as CpuImage13, registerFilterOp as registerFilterOp13 } from "@workglow/util/media";
+function cpuSepia(bin) {
+  const { data: src, width, height, channels } = bin;
+  const dst = new Uint8ClampedArray(src.length);
+  const pixelCount = width * height;
+  for (let i = 0;i < pixelCount; i++) {
+    const idx = i * channels;
+    const r = src[idx];
+    const g = channels === 1 ? r : src[idx + 1];
+    const b = channels === 1 ? r : src[idx + 2];
+    const outR = r * 402 + g * 787 + b * 194 >> 10;
+    const outG = r * 357 + g * 702 + b * 172 >> 10;
+    const outB = r * 279 + g * 547 + b * 134 >> 10;
+    dst[idx] = outR > 255 ? 255 : outR;
+    if (channels >= 3) {
+      dst[idx + 1] = outG > 255 ? 255 : outG;
+      dst[idx + 2] = outB > 255 ? 255 : outB;
+    }
+    if (channels === 4) {
+      dst[idx + 3] = src[idx + 3];
+    }
+  }
+  return { data: dst, width, height, channels };
+}
+registerFilterOp13("cpu", "sepia", (image, _params) => {
+  return CpuImage13.fromImageBinary(cpuSepia(image.getBinary()));
+});
+
+// src/task/image/threshold/threshold.cpu.ts
+import { CpuImage as CpuImage14, registerFilterOp as registerFilterOp14 } from "@workglow/util/media";
+function cpuThreshold(bin, value) {
+  const { data: src, width, height, channels } = bin;
+  const pixelCount = width * height;
+  const dst = new Uint8ClampedArray(pixelCount * channels);
+  for (let i = 0;i < pixelCount; i++) {
+    const idx = i * channels;
+    if (channels === 1) {
+      dst[idx] = src[idx] >= value ? 255 : 0;
+    } else {
+      dst[idx] = src[idx] >= value ? 255 : 0;
+      dst[idx + 1] = src[idx + 1] >= value ? 255 : 0;
+      dst[idx + 2] = src[idx + 2] >= value ? 255 : 0;
+      if (channels === 4) {
+        dst[idx + 3] = src[idx + 3];
+      }
+    }
+  }
+  return { data: dst, width, height, channels };
+}
+registerFilterOp14("cpu", "threshold", (image, { value }) => {
+  return CpuImage14.fromImageBinary(cpuThreshold(image.getBinary(), value));
+});
+
+// src/task/image/tint/tint.cpu.ts
+import {
+  CpuImage as CpuImage15,
+  registerFilterOp as registerFilterOp15,
+  resolveColor as resolveColor2
+} from "@workglow/util/media";
+function cpuTint(bin, tr, tg, tb, amount) {
+  const { data: src, width, height, channels } = bin;
+  const invAmount = 1 - amount;
+  const tintR = tr * amount;
+  const tintG = tg * amount;
+  const tintB = tb * amount;
+  const pixelCount = width * height;
+  if (channels === 1) {
+    const dst2 = new Uint8ClampedArray(pixelCount * 3);
+    for (let i = 0;i < pixelCount; i++) {
+      const gray = src[i];
+      dst2[i * 3] = gray * invAmount + tintR;
+      dst2[i * 3 + 1] = gray * invAmount + tintG;
+      dst2[i * 3 + 2] = gray * invAmount + tintB;
+    }
+    return { data: dst2, width, height, channels: 3 };
+  }
+  const dst = new Uint8ClampedArray(src.length);
+  for (let i = 0;i < pixelCount; i++) {
+    const idx = i * channels;
+    dst[idx] = src[idx] * invAmount + tintR;
+    dst[idx + 1] = src[idx + 1] * invAmount + tintG;
+    dst[idx + 2] = src[idx + 2] * invAmount + tintB;
+    if (channels === 4) {
+      dst[idx + 3] = src[idx + 3];
+    }
+  }
+  return { data: dst, width, height, channels };
+}
+registerFilterOp15("cpu", "tint", (image, { color, amount }) => {
+  const { r: tr, g: tg, b: tb } = resolveColor2(color);
+  return CpuImage15.fromImageBinary(cpuTint(image.getBinary(), tr, tg, tb, amount));
+});
+
+// src/task/image/transparency/transparency.cpu.ts
+import { CpuImage as CpuImage16, registerFilterOp as registerFilterOp16 } from "@workglow/util/media";
+function cpuTransparency(bin, amount) {
+  const { data: src, width, height, channels: srcCh } = bin;
+  const pixelCount = width * height;
+  const dst = new Uint8ClampedArray(pixelCount * 4);
+  const alphaScale = Math.round(amount * 255);
+  for (let i = 0;i < pixelCount; i++) {
+    const srcIdx = i * srcCh;
+    const dstIdx = i * 4;
+    dst[dstIdx] = src[srcIdx];
+    dst[dstIdx + 1] = srcCh >= 3 ? src[srcIdx + 1] : src[srcIdx];
+    dst[dstIdx + 2] = srcCh >= 3 ? src[srcIdx + 2] : src[srcIdx];
+    const srcAlpha = srcCh === 4 ? src[srcIdx + 3] : 255;
+    dst[dstIdx + 3] = (srcAlpha * alphaScale + 127) / 255;
+  }
+  return { data: dst, width, height, channels: 4 };
+}
+registerFilterOp16("cpu", "transparency", (image, { amount }) => {
+  return CpuImage16.fromImageBinary(cpuTransparency(image.getBinary(), amount));
+});
+
+// src/task/image/blur/blur.sharp.ts
+import { registerFilterOp as registerFilterOp17 } from "@workglow/util/media";
+registerFilterOp17("sharp", "blur", (image, { radius }) => {
+  return image.apply((p) => p.blur(radius * 0.5));
+});
+
+// src/task/image/border/border.sharp.ts
+import { registerFilterOp as registerFilterOp18, resolveColor as resolveColor3 } from "@workglow/util/media";
+registerFilterOp18("sharp", "border", (image, { borderWidth: bw, color }) => {
+  const sharp = image;
+  const resolved = resolveColor3(color);
+  const outW = sharp.width + bw * 2;
+  const outH = sharp.height + bw * 2;
+  return sharp.apply((p) => p.extend({
+    top: bw,
+    bottom: bw,
+    left: bw,
+    right: bw,
+    background: { r: resolved.r, g: resolved.g, b: resolved.b, alpha: resolved.a / 255 }
+  }), { width: outW, height: outH });
+});
+
+// src/task/image/brightness/brightness.sharp.ts
+import { registerFilterOp as registerFilterOp19 } from "@workglow/util/media";
+registerFilterOp19("sharp", "brightness", (image, { amount }) => {
+  return image.apply((p) => p.linear(1, amount));
+});
+
+// src/task/image/contrast/contrast.sharp.ts
+import { registerFilterOp as registerFilterOp20 } from "@workglow/util/media";
+registerFilterOp20("sharp", "contrast", (image, { amount }) => {
+  const slope = 259 * (amount + 255) / (255 * (259 - amount));
+  const intercept = 128 - slope * 128;
+  return image.apply((p) => p.linear(slope, intercept));
+});
+
+// src/task/image/crop/crop.sharp.ts
+import { registerFilterOp as registerFilterOp21 } from "@workglow/util/media";
+registerFilterOp21("sharp", "crop", (image, { left, top, width, height }) => {
+  return image.apply((p) => p.extract({ left, top, width, height }), {
+    width,
+    height
+  });
+});
+
+// src/task/image/flip/flip.sharp.ts
+import { registerFilterOp as registerFilterOp22 } from "@workglow/util/media";
+registerFilterOp22("sharp", "flip", (image, { direction }) => {
+  const sharp = image;
+  return direction === "horizontal" ? sharp.apply((p) => p.flop()) : sharp.apply((p) => p.flip());
+});
+
+// src/task/image/grayscale/grayscale.sharp.ts
+import { registerFilterOp as registerFilterOp23 } from "@workglow/util/media";
+registerFilterOp23("sharp", "grayscale", (image, _params) => {
+  return image.apply((p) => p.grayscale());
+});
+
+// src/task/image/invert/invert.sharp.ts
+import { registerFilterOp as registerFilterOp24 } from "@workglow/util/media";
+registerFilterOp24("sharp", "invert", (image, _params) => {
+  return image.apply((p) => p.negate({ alpha: false }));
+});
+
+// src/task/image/pixelate/pixelate.sharp.ts
+import { registerFilterOp as registerFilterOp25 } from "@workglow/util/media";
+registerFilterOp25("sharp", "pixelate", (image, { blockSize }) => {
+  const sharp = image;
+  const downW = Math.max(1, Math.floor(sharp.width / blockSize));
+  const downH = Math.max(1, Math.floor(sharp.height / blockSize));
+  const outW = sharp.width;
+  const outH = sharp.height;
+  return sharp.apply((p) => {
+    const down = p.resize(downW, downH, { kernel: "nearest" });
+    return down.resize(outW, outH, { kernel: "nearest" });
+  });
+});
+
+// src/task/image/resize/resize.sharp.ts
+import { registerFilterOp as registerFilterOp26 } from "@workglow/util/media";
+registerFilterOp26("sharp", "resize", (image, { width, height, fit, kernel }) => {
+  return image.apply((p) => p.resize(width, height, { fit, kernel }), {
+    width,
+    height
+  });
+});
+
+// src/task/image/rotate/rotate.sharp.ts
+import { registerFilterOp as registerFilterOp27 } from "@workglow/util/media";
+registerFilterOp27("sharp", "rotate", (image, { angle, background }) => {
+  const sharp = image;
+  const swap = angle === 90 || angle === 270;
+  const outW = swap ? sharp.height : sharp.width;
+  const outH = swap ? sharp.width : sharp.height;
+  return sharp.apply((p) => p.rotate(angle, background ? { background } : undefined), {
+    width: outW,
+    height: outH
+  });
+});
+
+// src/task/image/sepia/sepia.sharp.ts
+import { registerFilterOp as registerFilterOp28 } from "@workglow/util/media";
+registerFilterOp28("sharp", "sepia", (image, _params) => {
+  return image.apply((p) => p.recomb([
+    [0.393, 0.769, 0.189],
+    [0.349, 0.686, 0.168],
+    [0.272, 0.534, 0.131]
+  ]));
+});
+
+// src/task/image/threshold/threshold.sharp.ts
+import { registerFilterOp as registerFilterOp29 } from "@workglow/util/media";
+registerFilterOp29("sharp", "threshold", (image, { value }) => {
+  return image.apply((p) => p.threshold(value));
+});
+
+// src/task/image/tint/tint.sharp.ts
+import { registerFilterOp as registerFilterOp30, resolveColor as resolveColor4 } from "@workglow/util/media";
+registerFilterOp30("sharp", "tint", (image, { color }) => {
+  const { r, g, b } = resolveColor4(color);
+  return image.apply((p) => p.tint({ r, g, b }));
+});
+
+// src/codec.node.ts
+import { applyFilter, registerPreviewResizeFn } from "@workglow/util/media";
+registerPreviewResizeFn((image, width, height) => applyFilter(image, "resize", { width, height }));
+
 // src/task/image/imageTextRender.ts
 import { createServiceToken, globalServiceRegistry } from "@workglow/util";
 var IMAGE_TEXT_ANCHOR_POSITIONS = [
@@ -5877,281 +6476,182 @@ ${input.prompt}` : input.prompt : this.config.message ?? "";
   }
 }
 Workflow16.prototype.humanInput = CreateWorkflow15(HumanInputTask);
-// src/task/image/ImageBlurTask.ts
+
+// src/common.ts
+import {
+  registerFilterOp as registerFilterOp31,
+  applyFilter as applyFilter3,
+  hasFilterOp as hasFilterOp2,
+  _resetFilterRegistryForTests
+} from "@workglow/util/media";
+
+// src/task/image/ImageFilterTask.ts
 import {
-  CreateWorkflow as CreateWorkflow16,
-  Task as Task42,
-  Workflow as Workflow17
+  Task as Task42
 } from "@workglow/task-graph";
+import {
+  applyFilter as applyFilter2,
+  CpuImage as CpuImage17,
+  GpuImageFactory,
+  getGpuImageFactory,
+  hasFilterOp,
+  previewSource
+} from "@workglow/util/media";
 
-// src/task/image/ImageSchemas.ts
-import { FromSchemaDefaultOptions } from "@workglow/util/schema";
-var ImageBinaryType = null;
-var ImageBinarySchemaOptions = {
-  ...FromSchemaDefaultOptions,
-  deserialize: [
-    {
-      pattern: { type: "object", format: "image:ImageBinary" },
-      output: ImageBinaryType
+class ImageFilterTask extends Task42 {
+  scalePreviewParams(params, _scale) {
+    return params;
+  }
+  async hydrateInput(image) {
+    if (image !== null && typeof image === "object" && "backend" in image && "retain" in image && "release" in image && "materialize" in image) {
+      return image;
     }
-  ]
-};
-var ImageBinarySchema = (annotations = {}) => ({
+    if (typeof image === "string" && image.startsWith("data:")) {
+      return GpuImageFactory.fromDataUri(image);
+    }
+    if (typeof Blob !== "undefined" && image instanceof Blob) {
+      return GpuImageFactory.fromBlob(image);
+    }
+    if (typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
+      const fromImageBitmap = getGpuImageFactory("fromImageBitmap");
+      if (!fromImageBitmap) {
+        throw new Error("ImageFilterTask: received ImageBitmap but GpuImage.fromImageBitmap is not registered " + "in this runtime. ImageBitmap inputs require the browser entry point.");
+      }
+      return fromImageBitmap(image);
+    }
+    if (image !== null && typeof image === "object" && "data" in image && "width" in image && "height" in image && "channels" in image) {
+      const bin = image;
+      const asyncFactory = getGpuImageFactory("fromImageBinaryAsync");
+      if (asyncFactory)
+        return asyncFactory(bin);
+      return GpuImageFactory.fromImageBinary(bin);
+    }
+    const ctor = image && typeof image === "object" && image.constructor ? image.constructor.name : typeof image;
+    const keys = image && typeof image === "object" ? Object.keys(image).slice(0, 10).join(", ") : "";
+    throw new Error(`ImageFilterTask: input.image is not a recognized image shape (got ${ctor}` + (keys ? ` with keys [${keys}]` : "") + `). Expected one of: GpuImage instance, raw ImageBinary, Blob, ImageBitmap, ` + `or a data: URI string.`);
+  }
+  async execute(input, ctx) {
+    let inputImage = await this.hydrateInput(input.image);
+    if (!hasFilterOp(inputImage.backend, this.filterName)) {
+      const bin = await inputImage.materialize();
+      const cpu = CpuImage17.fromImageBinary(bin, inputImage.previewScale);
+      inputImage.release();
+      inputImage = cpu;
+    }
+    const params = this.scalePreviewParams(this.opParams(input), inputImage.previewScale);
+    const out = applyFilter2(inputImage, this.filterName, params);
+    inputImage.release();
+    ctx.resourceScope?.register(`gpuimage:${String(this.id)}:image`, async () => out.release());
+    return { image: out };
+  }
+  async executePreview(input, _ctx) {
+    const inputImage = await this.hydrateInput(input.image);
+    let sourced = previewSource(inputImage);
+    if (!hasFilterOp(sourced.backend, this.filterName)) {
+      const bin = await sourced.materialize();
+      const cpu = CpuImage17.fromImageBinary(bin, sourced.previewScale);
+      if (sourced !== inputImage)
+        sourced.release();
+      sourced = cpu;
+    }
+    const params = this.scalePreviewParams(this.opParams(input), sourced.previewScale);
+    const out = applyFilter2(sourced, this.filterName, params);
+    if (sourced !== inputImage)
+      sourced.release();
+    return { image: out };
+  }
+}
+// src/task/image/blur/ImageBlurTask.ts
+import { CreateWorkflow as CreateWorkflow16, Workflow as Workflow17 } from "@workglow/task-graph";
+import { GpuImageSchema } from "@workglow/util/media";
+var inputSchema41 = {
   type: "object",
   properties: {
-    data: {
-      type: "array",
-      items: { type: "number", format: "Uint8Clamped" },
-      format: "Uint8ClampedArray",
-      title: "Data",
-      description: "Pixel data of the image"
-    },
-    width: {
-      type: "integer",
+    image: GpuImageSchema({ title: "Image", description: "Source image" }),
+    radius: {
+      type: "number",
+      title: "Radius",
+      description: "Blur radius (1-10)",
       minimum: 1,
-      title: "Width",
-      description: "Width in pixels"
-    },
-    height: {
+      maximum: 10,
+      default: 1
+    }
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema40 = {
+  type: "object",
+  properties: { image: GpuImageSchema({ title: "Image", description: "Blurred image" }) },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageBlurTask extends ImageFilterTask {
+  static type = "ImageBlurTask";
+  static category = "Image";
+  static title = "Blur Image";
+  static description = "Applies a box blur to an image";
+  static inputSchema() {
+    return inputSchema41;
+  }
+  static outputSchema() {
+    return outputSchema40;
+  }
+  filterName = "blur";
+  opParams(input) {
+    return { radius: input.radius ?? 1 };
+  }
+  scalePreviewParams({ radius }, s) {
+    return { radius: Math.max(1, Math.round(radius * s)) };
+  }
+}
+Workflow17.prototype.imageBlur = CreateWorkflow16(ImageBlurTask);
+// src/task/image/border/ImageBorderTask.ts
+import { CreateWorkflow as CreateWorkflow17, Workflow as Workflow18 } from "@workglow/task-graph";
+import { GpuImageSchema as GpuImageSchema2 } from "@workglow/util/media";
+var inputSchema42 = {
+  type: "object",
+  properties: {
+    image: GpuImageSchema2({ title: "Image", description: "Source image" }),
+    borderWidth: {
       type: "integer",
+      title: "Border Width",
+      description: "Border width in pixels",
       minimum: 1,
-      title: "Height",
-      description: "Height in pixels"
+      default: 10
     },
-    channels: {
-      type: "integer",
-      enum: [1, 3, 4],
-      title: "Channels",
-      description: "1 (gray), 3 (RGB), or 4 (RGBA)"
+    color: {
+      oneOf: [
+        { type: "string", pattern: "^#([0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$" },
+        {
+          type: "object",
+          properties: {
+            r: { type: "integer", minimum: 0, maximum: 255 },
+            g: { type: "integer", minimum: 0, maximum: 255 },
+            b: { type: "integer", minimum: 0, maximum: 255 },
+            a: { type: "integer", minimum: 0, maximum: 255 }
+          },
+          required: ["r", "g", "b"],
+          additionalProperties: false
+        }
+      ],
+      title: "Color",
+      description: "Border color",
+      default: "#000000"
     }
   },
-  additionalProperties: false,
-  required: ["data", "width", "height", "channels"],
-  format: "image:ImageBinary",
-  title: "Image",
-  description: "Raw pixel image data",
-  ...annotations
-});
-var ImageBinaryOrDataUriSchema = (annotations = {}) => ({
-  oneOf: [
-    ImageBinarySchema(annotations),
-    {
-      type: "string",
-      format: "image:data-uri",
-      title: annotations.title ?? "Image",
-      description: annotations.description ?? "Image as ImageBinary or data URI (data:image/png;base64,...)"
-    }
-  ]
-});
-var ColorSchema = (annotations = {}) => ({
+  required: ["image", "color"],
+  additionalProperties: false
+};
+var outputSchema41 = {
   type: "object",
-  properties: {
-    r: { type: "integer", minimum: 0, maximum: 255, title: "Red" },
-    g: { type: "integer", minimum: 0, maximum: 255, title: "Green" },
-    b: { type: "integer", minimum: 0, maximum: 255, title: "Blue" },
-    a: { type: "integer", minimum: 0, maximum: 255, title: "Alpha", default: 255 }
-  },
-  required: ["r", "g", "b"],
-  format: "color",
-  additionalProperties: false,
-  ...annotations
-});
-var HexColorSchema = (annotations = {}) => ({
-  type: "string",
-  format: "color",
-  pattern: "^#([0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$",
-  title: "Color (hex)",
-  description: "Color as a `#RRGGBB[AA]` or `#RGB[A]` hex string",
-  ...annotations
-});
-var ColorValueSchema = (annotations = {}) => ({
-  oneOf: [
-    ColorSchema(),
-    HexColorSchema({
-      title: annotations.title ?? "Color",
-      description: annotations.description ?? "Color as {r,g,b,a} object or `#RRGGBB[AA]` / `#RGB[A]` hex string"
-    })
-  ],
-  ...annotations
-});
-var ColorObjectType = null;
-var ColorFromSchemaOptions = {
-  ...FromSchemaDefaultOptions,
-  deserialize: [
-    {
-      pattern: { type: "object", format: "color" },
-      output: ColorObjectType
-    }
-  ]
-};
-
-// src/task/image/imageTaskIo.ts
-import { Image, getImageRasterCodec } from "@workglow/util/media";
-async function produceImageOutput(inputImage, run) {
-  const image = Image.is(inputImage) ? inputImage : Image.from(inputImage);
-  const pixels = await image.getPixels();
-  const out = await run(pixels);
-  if (image.kind === "dataUri") {
-    const mime = image.mimeType ?? "image/png";
-    return getImageRasterCodec().encodeDataUri(out, mime);
-  }
-  return out;
-}
-
-// src/task/image/ImageBlurTask.ts
-async function applyBlur(input) {
-  const { radius = 1 } = input;
-  const image = await produceImageOutput(input.image, (img) => {
-    const { data: src, width, height, channels } = img;
-    const kernelSize = radius * 2 + 1;
-    const tmp = new Uint8ClampedArray(src.length);
-    for (let y = 0;y < height; y++) {
-      for (let c = 0;c < channels; c++) {
-        let sum = 0;
-        for (let k = -radius;k <= radius; k++) {
-          const x = Math.max(0, Math.min(k, width - 1));
-          sum += src[(y * width + x) * channels + c];
-        }
-        tmp[y * width * channels + c] = sum / kernelSize + 0.5 | 0;
-        for (let x = 1;x < width; x++) {
-          const addX = Math.min(x + radius, width - 1);
-          const removeX = Math.max(x - radius - 1, 0);
-          sum += src[(y * width + addX) * channels + c] - src[(y * width + removeX) * channels + c];
-          tmp[(y * width + x) * channels + c] = sum / kernelSize + 0.5 | 0;
-        }
-      }
-    }
-    const dst = new Uint8ClampedArray(src.length);
-    for (let x = 0;x < width; x++) {
-      for (let c = 0;c < channels; c++) {
-        let sum = 0;
-        for (let k = -radius;k <= radius; k++) {
-          const y = Math.max(0, Math.min(k, height - 1));
-          sum += tmp[(y * width + x) * channels + c];
-        }
-        dst[x * channels + c] = sum / kernelSize + 0.5 | 0;
-        for (let y = 1;y < height; y++) {
-          const addY = Math.min(y + radius, height - 1);
-          const removeY = Math.max(y - radius - 1, 0);
-          sum += tmp[(addY * width + x) * channels + c] - tmp[(removeY * width + x) * channels + c];
-          dst[(y * width + x) * channels + c] = sum / kernelSize + 0.5 | 0;
-        }
-      }
-    }
-    return { data: dst, width, height, channels };
-  });
-  return { image };
-}
-var inputSchema41 = {
-  type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Source image" }),
-    radius: {
-      type: "integer",
-      title: "Radius",
-      description: "Blur radius (1-10)",
-      minimum: 1,
-      maximum: 10,
-      default: 1
-    }
-  },
-  required: ["image"],
-  additionalProperties: false
-};
-var outputSchema40 = {
-  type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Blurred image" })
-  },
+  properties: { image: GpuImageSchema2({ title: "Image", description: "Image with border" }) },
   required: ["image"],
   additionalProperties: false
 };
 
-class ImageBlurTask extends Task42 {
-  static type = "ImageBlurTask";
-  static category = "Image";
-  static title = "Blur Image";
-  static description = "Applies a box blur to an image";
-  static inputSchema() {
-    return inputSchema41;
-  }
-  static outputSchema() {
-    return outputSchema40;
-  }
-  async execute(input, _context) {
-    return await applyBlur(input);
-  }
-  async executePreview(input, _context) {
-    return await applyBlur(input);
-  }
-}
-Workflow17.prototype.imageBlur = CreateWorkflow16(ImageBlurTask);
-// src/task/image/ImageBorderTask.ts
-import {
-  CreateWorkflow as CreateWorkflow17,
-  Task as Task43,
-  Workflow as Workflow18
-} from "@workglow/task-graph";
-import { resolveColor } from "@workglow/util/media";
-async function applyBorder(input) {
-  const { borderWidth: bw = 1 } = input;
-  const color = resolveColor(input.color);
-  const image = await produceImageOutput(input.image, (img) => {
-    const { data: src, width: srcW, height: srcH, channels: srcCh } = img;
-    const outCh = 4;
-    const dstW = srcW + bw * 2;
-    const dstH = srcH + bw * 2;
-    const dst = new Uint8ClampedArray(dstW * dstH * outCh);
-    const r = color.r;
-    const g = color.g;
-    const b = color.b;
-    const a = color.a;
-    for (let i = 0;i < dst.length; i += outCh) {
-      dst[i] = r;
-      dst[i + 1] = g;
-      dst[i + 2] = b;
-      dst[i + 3] = a;
-    }
-    for (let y = 0;y < srcH; y++) {
-      for (let x = 0;x < srcW; x++) {
-        const srcIdx = (y * srcW + x) * srcCh;
-        const dstIdx = ((y + bw) * dstW + (x + bw)) * outCh;
-        dst[dstIdx] = src[srcIdx];
-        dst[dstIdx + 1] = srcCh >= 3 ? src[srcIdx + 1] : src[srcIdx];
-        dst[dstIdx + 2] = srcCh >= 3 ? src[srcIdx + 2] : src[srcIdx];
-        dst[dstIdx + 3] = srcCh === 4 ? src[srcIdx + 3] : 255;
-      }
-    }
-    return { data: dst, width: dstW, height: dstH, channels: outCh };
-  });
-  return { image };
-}
-var inputSchema42 = {
-  type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Source image" }),
-    borderWidth: {
-      type: "integer",
-      title: "Border Width",
-      description: "Border width in pixels",
-      minimum: 1,
-      default: 1
-    },
-    color: ColorValueSchema({ title: "Color", description: "Border color" })
-  },
-  required: ["image", "color"],
-  additionalProperties: false
-};
-var outputSchema41 = {
-  type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Image with border" })
-  },
-  required: ["image"],
-  additionalProperties: false
-};
-
-class ImageBorderTask extends Task43 {
+class ImageBorderTask extends ImageFilterTask {
   static type = "ImageBorderTask";
   static category = "Image";
   static title = "Add Border";
@@ -6162,45 +6662,25 @@ class ImageBorderTask extends Task43 {
   static outputSchema() {
     return outputSchema41;
   }
-  async execute(input, _context) {
-    return await applyBorder(input);
+  filterName = "border";
+  opParams(input) {
+    return {
+      borderWidth: input.borderWidth ?? 10,
+      color: input.color
+    };
   }
-  async executePreview(input, _context) {
-    return await applyBorder(input);
+  scalePreviewParams({ borderWidth, color }, s) {
+    return { borderWidth: Math.max(1, Math.round(borderWidth * s)), color };
   }
 }
 Workflow18.prototype.imageBorder = CreateWorkflow17(ImageBorderTask);
-// src/task/image/ImageBrightnessTask.ts
-import {
-  CreateWorkflow as CreateWorkflow18,
-  Task as Task44,
-  Workflow as Workflow19
-} from "@workglow/task-graph";
-async function applyBrightness(input) {
-  const amount = input.amount ?? 0;
-  const image = await produceImageOutput(input.image, (img) => {
-    const { data: src, width, height, channels } = img;
-    const dst = new Uint8ClampedArray(src.length);
-    if (channels === 4) {
-      for (let i = 0;i < src.length; i += 4) {
-        dst[i] = src[i] + amount;
-        dst[i + 1] = src[i + 1] + amount;
-        dst[i + 2] = src[i + 2] + amount;
-        dst[i + 3] = src[i + 3];
-      }
-    } else {
-      for (let i = 0;i < src.length; i++) {
-        dst[i] = src[i] + amount;
-      }
-    }
-    return { data: dst, width, height, channels };
-  });
-  return { image };
-}
+// src/task/image/brightness/ImageBrightnessTask.ts
+import { CreateWorkflow as CreateWorkflow18, Workflow as Workflow19 } from "@workglow/task-graph";
+import { GpuImageSchema as GpuImageSchema3 } from "@workglow/util/media";
 var inputSchema43 = {
   type: "object",
   properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Source image" }),
+    image: GpuImageSchema3({ title: "Image", description: "Source image" }),
     amount: {
       type: "number",
       title: "Amount",
@@ -6215,14 +6695,12 @@ var inputSchema43 = {
 };
 var outputSchema42 = {
   type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Brightness-adjusted image" })
-  },
+  properties: { image: GpuImageSchema3({ title: "Image", description: "Brightness-adjusted image" }) },
   required: ["image"],
   additionalProperties: false
 };
 
-class ImageBrightnessTask extends Task44 {
+class ImageBrightnessTask extends ImageFilterTask {
   static type = "ImageBrightnessTask";
   static category = "Image";
   static title = "Adjust Brightness";
@@ -6233,50 +6711,19 @@ class ImageBrightnessTask extends Task44 {
   static outputSchema() {
     return outputSchema42;
   }
-  async execute(input, _context) {
-    return await applyBrightness(input);
-  }
-  async executePreview(input, _context) {
-    return await applyBrightness(input);
+  filterName = "brightness";
+  opParams(input) {
+    return { amount: input.amount ?? 0 };
   }
 }
 Workflow19.prototype.imageBrightness = CreateWorkflow18(ImageBrightnessTask);
-// src/task/image/ImageContrastTask.ts
-import {
-  CreateWorkflow as CreateWorkflow19,
-  Task as Task45,
-  Workflow as Workflow20
-} from "@workglow/task-graph";
-async function applyContrast(input) {
-  const amount = input.amount ?? 0;
-  const image = await produceImageOutput(input.image, (img) => {
-    const { data: src, width, height, channels } = img;
-    const factor = 259 * (amount + 255) / (255 * (259 - amount));
-    const lut = new Uint8ClampedArray(256);
-    for (let i = 0;i < 256; i++) {
-      lut[i] = factor * (i - 128) + 128;
-    }
-    const dst = new Uint8ClampedArray(src.length);
-    if (channels === 4) {
-      for (let i = 0;i < src.length; i += 4) {
-        dst[i] = lut[src[i]];
-        dst[i + 1] = lut[src[i + 1]];
-        dst[i + 2] = lut[src[i + 2]];
-        dst[i + 3] = src[i + 3];
-      }
-    } else {
-      for (let i = 0;i < src.length; i++) {
-        dst[i] = lut[src[i]];
-      }
-    }
-    return { data: dst, width, height, channels };
-  });
-  return { image };
-}
+// src/task/image/contrast/ImageContrastTask.ts
+import { CreateWorkflow as CreateWorkflow19, Workflow as Workflow20 } from "@workglow/task-graph";
+import { GpuImageSchema as GpuImageSchema4 } from "@workglow/util/media";
 var inputSchema44 = {
   type: "object",
   properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Source image" }),
+    image: GpuImageSchema4({ title: "Image", description: "Source image" }),
     amount: {
       type: "number",
       title: "Amount",
@@ -6291,14 +6738,12 @@ var inputSchema44 = {
 };
 var outputSchema43 = {
   type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Contrast-adjusted image" })
-  },
+  properties: { image: GpuImageSchema4({ title: "Image", description: "Contrast-adjusted image" }) },
   required: ["image"],
   additionalProperties: false
 };
 
-class ImageContrastTask extends Task45 {
+class ImageContrastTask extends ImageFilterTask {
   static type = "ImageContrastTask";
   static category = "Image";
   static title = "Adjust Contrast";
@@ -6309,67 +6754,35 @@ class ImageContrastTask extends Task45 {
   static outputSchema() {
     return outputSchema43;
   }
-  async execute(input, _context) {
-    return await applyContrast(input);
-  }
-  async executePreview(input, _context) {
-    return await applyContrast(input);
+  filterName = "contrast";
+  opParams(input) {
+    return { amount: input.amount ?? 0 };
   }
 }
 Workflow20.prototype.imageContrast = CreateWorkflow19(ImageContrastTask);
-// src/task/image/ImageCropTask.ts
-import {
-  CreateWorkflow as CreateWorkflow20,
-  Task as Task46,
-  Workflow as Workflow21
-} from "@workglow/task-graph";
-async function cropImage(input) {
-  const { x: rawX, y: rawY, width: rawW, height: rawH } = input;
-  const image = await produceImageOutput(input.image, (img) => {
-    const { data: src, width: srcW, height: srcH, channels } = img;
-    if (srcW < 1 || srcH < 1) {
-      throw new RangeError("Cannot crop an empty image");
-    }
-    if (rawX < 0 || rawX >= srcW || rawY < 0 || rawY >= srcH) {
-      throw new RangeError("Crop origin is outside the source image bounds");
-    }
-    const x = rawX;
-    const y = rawY;
-    const w = Math.min(rawW, srcW - x);
-    const h = Math.min(rawH, srcH - y);
-    const dst = new Uint8ClampedArray(w * h * channels);
-    const rowBytes = w * channels;
-    for (let row = 0;row < h; row++) {
-      const srcOffset = ((y + row) * srcW + x) * channels;
-      const dstOffset = row * rowBytes;
-      dst.set(src.subarray(srcOffset, srcOffset + rowBytes), dstOffset);
-    }
-    return { data: dst, width: w, height: h, channels };
-  });
-  return { image };
-}
+// src/task/image/crop/ImageCropTask.ts
+import { CreateWorkflow as CreateWorkflow20, Workflow as Workflow21 } from "@workglow/task-graph";
+import { GpuImageSchema as GpuImageSchema5 } from "@workglow/util/media";
 var inputSchema45 = {
   type: "object",
   properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Source image" }),
-    x: { type: "integer", title: "X", description: "Left offset", minimum: 0 },
-    y: { type: "integer", title: "Y", description: "Top offset", minimum: 0 },
+    image: GpuImageSchema5({ title: "Image", description: "Source image" }),
+    left: { type: "integer", title: "Left", description: "Left offset", minimum: 0, default: 0 },
+    top: { type: "integer", title: "Top", description: "Top offset", minimum: 0, default: 0 },
     width: { type: "integer", title: "Width", description: "Crop width", minimum: 1 },
     height: { type: "integer", title: "Height", description: "Crop height", minimum: 1 }
   },
-  required: ["image", "x", "y", "width", "height"],
+  required: ["image", "left", "top", "width", "height"],
   additionalProperties: false
 };
 var outputSchema44 = {
   type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Cropped image" })
-  },
+  properties: { image: GpuImageSchema5({ title: "Image", description: "Cropped image" }) },
   required: ["image"],
   additionalProperties: false
 };
 
-class ImageCropTask extends Task46 {
+class ImageCropTask extends ImageFilterTask {
   static type = "ImageCropTask";
   static category = "Image";
   static title = "Crop Image";
@@ -6380,56 +6793,38 @@ class ImageCropTask extends Task46 {
   static outputSchema() {
     return outputSchema44;
   }
-  async execute(input, _context) {
-    return await cropImage(input);
+  filterName = "crop";
+  opParams(input) {
+    return {
+      left: input.left,
+      top: input.top,
+      width: input.width,
+      height: input.height
+    };
   }
-  async executePreview(input, _context) {
-    return await cropImage(input);
+  scalePreviewParams({ left, top, width, height }, s) {
+    return {
+      left: Math.round(left * s),
+      top: Math.round(top * s),
+      width: Math.max(1, Math.round(width * s)),
+      height: Math.max(1, Math.round(height * s))
+    };
   }
 }
 Workflow21.prototype.imageCrop = CreateWorkflow20(ImageCropTask);
-// src/task/image/ImageFlipTask.ts
-import {
-  CreateWorkflow as CreateWorkflow21,
-  Task as Task47,
-  Workflow as Workflow22
-} from "@workglow/task-graph";
-async function flipImage(input) {
-  const { direction } = input;
-  const image = await produceImageOutput(input.image, (img) => {
-    const { data: src, width, height, channels } = img;
-    const dst = new Uint8ClampedArray(src.length);
-    const rowBytes = width * channels;
-    if (direction === "vertical") {
-      for (let y = 0;y < height; y++) {
-        const srcOffset = y * rowBytes;
-        const dstOffset = (height - 1 - y) * rowBytes;
-        dst.set(src.subarray(srcOffset, srcOffset + rowBytes), dstOffset);
-      }
-    } else {
-      for (let y = 0;y < height; y++) {
-        for (let x = 0;x < width; x++) {
-          const srcIdx = (y * width + x) * channels;
-          const dstIdx = (y * width + (width - 1 - x)) * channels;
-          for (let c = 0;c < channels; c++) {
-            dst[dstIdx + c] = src[srcIdx + c];
-          }
-        }
-      }
-    }
-    return { data: dst, width, height, channels };
-  });
-  return { image };
-}
+// src/task/image/flip/ImageFlipTask.ts
+import { CreateWorkflow as CreateWorkflow21, Workflow as Workflow22 } from "@workglow/task-graph";
+import { GpuImageSchema as GpuImageSchema6 } from "@workglow/util/media";
 var inputSchema46 = {
   type: "object",
   properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Source image" }),
+    image: GpuImageSchema6({ title: "Image", description: "Source image" }),
     direction: {
       type: "string",
       enum: ["horizontal", "vertical"],
       title: "Direction",
-      description: "Flip direction"
+      description: "Flip direction",
+      default: "horizontal"
     }
   },
   required: ["image", "direction"],
@@ -6437,14 +6832,12 @@ var inputSchema46 = {
 };
 var outputSchema45 = {
   type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Flipped image" })
-  },
+  properties: { image: GpuImageSchema6({ title: "Image", description: "Flipped image" }) },
   required: ["image"],
   additionalProperties: false
 };
 
-class ImageFlipTask extends Task47 {
+class ImageFlipTask extends ImageFilterTask {
   static type = "ImageFlipTask";
   static category = "Image";
   static title = "Flip Image";
@@ -6455,54 +6848,29 @@ class ImageFlipTask extends Task47 {
   static outputSchema() {
     return outputSchema45;
   }
-  async execute(input, _context) {
-    return await flipImage(input);
-  }
-  async executePreview(input, _context) {
-    return await flipImage(input);
+  filterName = "flip";
+  opParams(input) {
+    return { direction: input.direction ?? "horizontal" };
   }
 }
 Workflow22.prototype.imageFlip = CreateWorkflow21(ImageFlipTask);
-// src/task/image/ImageGrayscaleTask.ts
-import {
-  CreateWorkflow as CreateWorkflow22,
-  Task as Task48,
-  Workflow as Workflow23
-} from "@workglow/task-graph";
-async function applyGrayscale(input) {
-  const image = await produceImageOutput(input.image, (img) => {
-    const { data: src, width, height, channels } = img;
-    if (channels === 1) {
-      return { data: new Uint8ClampedArray(src), width, height, channels: 1 };
-    }
-    const pixelCount = width * height;
-    const dst = new Uint8ClampedArray(pixelCount);
-    for (let i = 0;i < pixelCount; i++) {
-      const idx = i * channels;
-      dst[i] = src[idx] * 77 + src[idx + 1] * 150 + src[idx + 2] * 29 >> 8;
-    }
-    return { data: dst, width, height, channels: 1 };
-  });
-  return { image };
-}
+// src/task/image/grayscale/ImageGrayscaleTask.ts
+import { CreateWorkflow as CreateWorkflow22, Workflow as Workflow23 } from "@workglow/task-graph";
+import { GpuImageSchema as GpuImageSchema7 } from "@workglow/util/media";
 var inputSchema47 = {
   type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Source image" })
-  },
+  properties: { image: GpuImageSchema7({ title: "Image", description: "Source image" }) },
   required: ["image"],
   additionalProperties: false
 };
 var outputSchema46 = {
   type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Grayscale image" })
-  },
+  properties: { image: GpuImageSchema7({ title: "Image", description: "Grayscale image" }) },
   required: ["image"],
   additionalProperties: false
 };
 
-class ImageGrayscaleTask extends Task48 {
+class ImageGrayscaleTask extends ImageFilterTask {
   static type = "ImageGrayscaleTask";
   static category = "Image";
   static title = "Grayscale";
@@ -6513,58 +6881,29 @@ class ImageGrayscaleTask extends Task48 {
   static outputSchema() {
     return outputSchema46;
   }
-  async execute(input, _context) {
-    return await applyGrayscale(input);
-  }
-  async executePreview(input, _context) {
-    return await applyGrayscale(input);
+  filterName = "grayscale";
+  opParams(_input) {
+    return;
   }
 }
 Workflow23.prototype.imageGrayscale = CreateWorkflow22(ImageGrayscaleTask);
-// src/task/image/ImageInvertTask.ts
-import {
-  CreateWorkflow as CreateWorkflow23,
-  Task as Task49,
-  Workflow as Workflow24
-} from "@workglow/task-graph";
-async function invertImage(input) {
-  const image = await produceImageOutput(input.image, (img) => {
-    const { data: src, width, height, channels } = img;
-    const dst = new Uint8ClampedArray(src.length);
-    if (channels === 4) {
-      for (let i = 0;i < src.length; i += 4) {
-        dst[i] = 255 - src[i];
-        dst[i + 1] = 255 - src[i + 1];
-        dst[i + 2] = 255 - src[i + 2];
-        dst[i + 3] = src[i + 3];
-      }
-    } else {
-      for (let i = 0;i < src.length; i++) {
-        dst[i] = 255 - src[i];
-      }
-    }
-    return { data: dst, width, height, channels };
-  });
-  return { image };
-}
+// src/task/image/invert/ImageInvertTask.ts
+import { CreateWorkflow as CreateWorkflow23, Workflow as Workflow24 } from "@workglow/task-graph";
+import { GpuImageSchema as GpuImageSchema8 } from "@workglow/util/media";
 var inputSchema48 = {
   type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Source image" })
-  },
+  properties: { image: GpuImageSchema8({ title: "Image", description: "Source image" }) },
   required: ["image"],
   additionalProperties: false
 };
 var outputSchema47 = {
   type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Inverted image" })
-  },
+  properties: { image: GpuImageSchema8({ title: "Image", description: "Inverted image" }) },
   required: ["image"],
   additionalProperties: false
 };
 
-class ImageInvertTask extends Task49 {
+class ImageInvertTask extends ImageFilterTask {
   static type = "ImageInvertTask";
   static category = "Image";
   static title = "Invert Colors";
@@ -6575,64 +6914,26 @@ class ImageInvertTask extends Task49 {
   static outputSchema() {
     return outputSchema47;
   }
-  async execute(input, _context) {
-    return await invertImage(input);
-  }
-  async executePreview(input, _context) {
-    return await invertImage(input);
+  filterName = "invert";
+  opParams(_input) {
+    return;
   }
 }
 Workflow24.prototype.imageInvert = CreateWorkflow23(ImageInvertTask);
-// src/task/image/ImagePixelateTask.ts
-import {
-  CreateWorkflow as CreateWorkflow24,
-  Task as Task50,
-  Workflow as Workflow25
-} from "@workglow/task-graph";
-async function pixelateImage(input) {
-  const { blockSize = 8 } = input;
-  const image = await produceImageOutput(input.image, (img) => {
-    const { data: src, width, height, channels } = img;
-    const dst = new Uint8ClampedArray(src.length);
-    for (let by = 0;by < height; by += blockSize) {
-      const blockH = Math.min(blockSize, height - by);
-      for (let bx = 0;bx < width; bx += blockSize) {
-        const blockW = Math.min(blockSize, width - bx);
-        const blockArea = blockW * blockH;
-        const sums = new Array(channels).fill(0);
-        for (let y = by;y < by + blockH; y++) {
-          for (let x = bx;x < bx + blockW; x++) {
-            const idx = (y * width + x) * channels;
-            for (let c = 0;c < channels; c++) {
-              sums[c] += src[idx + c];
-            }
-          }
-        }
-        const avg = sums.map((s) => s / blockArea + 0.5 | 0);
-        for (let y = by;y < by + blockH; y++) {
-          for (let x = bx;x < bx + blockW; x++) {
-            const idx = (y * width + x) * channels;
-            for (let c = 0;c < channels; c++) {
-              dst[idx + c] = avg[c];
-            }
-          }
-        }
-      }
-    }
-    return { data: dst, width, height, channels };
-  });
-  return { image };
-}
+// src/task/image/pixelate/ImagePixelateTask.ts
+import { CreateWorkflow as CreateWorkflow24, Workflow as Workflow25 } from "@workglow/task-graph";
+import { GpuImageSchema as GpuImageSchema9 } from "@workglow/util/media";
 var inputSchema49 = {
   type: "object",
   properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Source image" }),
+    image: GpuImageSchema9({ title: "Image", description: "Source image" }),
     blockSize: {
       type: "integer",
       title: "Block Size",
       description: "Size of each pixelation block",
       minimum: 2,
-      default: 8
+      maximum: 64,
+      default: 4
     }
   },
   required: ["image"],
@@ -6640,14 +6941,12 @@ var inputSchema49 = {
 };
 var outputSchema48 = {
   type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Pixelated image" })
-  },
+  properties: { image: GpuImageSchema9({ title: "Image", description: "Pixelated image" }) },
   required: ["image"],
   additionalProperties: false
 };
 
-class ImagePixelateTask extends Task50 {
+class ImagePixelateTask extends ImageFilterTask {
   static type = "ImagePixelateTask";
   static category = "Image";
   static title = "Pixelate Image";
@@ -6658,56 +6957,28 @@ class ImagePixelateTask extends Task50 {
   static outputSchema() {
     return outputSchema48;
   }
-  async execute(input, _context) {
-    return await pixelateImage(input);
+  filterName = "pixelate";
+  opParams(input) {
+    return { blockSize: input.blockSize ?? 4 };
   }
-  async executePreview(input, _context) {
-    return await pixelateImage(input);
+  scalePreviewParams({ blockSize }, s) {
+    return { blockSize: Math.max(1, Math.round(blockSize * s)) };
   }
 }
 Workflow25.prototype.imagePixelate = CreateWorkflow24(ImagePixelateTask);
-// src/task/image/ImagePosterizeTask.ts
-import {
-  CreateWorkflow as CreateWorkflow25,
-  Task as Task51,
-  Workflow as Workflow26
-} from "@workglow/task-graph";
-async function posterizeImage(input) {
-  const levels = input.levels ?? 4;
-  const image = await produceImageOutput(input.image, (img) => {
-    const { data: src, width, height, channels } = img;
-    const step = 255 / (levels - 1);
-    const lut = new Uint8ClampedArray(256);
-    for (let i = 0;i < 256; i++) {
-      lut[i] = Math.round(Math.round(i / step) * step);
-    }
-    const dst = new Uint8ClampedArray(src.length);
-    if (channels === 4) {
-      for (let i = 0;i < src.length; i += 4) {
-        dst[i] = lut[src[i]];
-        dst[i + 1] = lut[src[i + 1]];
-        dst[i + 2] = lut[src[i + 2]];
-        dst[i + 3] = src[i + 3];
-      }
-    } else {
-      for (let i = 0;i < src.length; i++) {
-        dst[i] = lut[src[i]];
-      }
-    }
-    return { data: dst, width, height, channels };
-  });
-  return { image };
-}
+// src/task/image/posterize/ImagePosterizeTask.ts
+import { CreateWorkflow as CreateWorkflow25, Workflow as Workflow26 } from "@workglow/task-graph";
+import { GpuImageSchema as GpuImageSchema10 } from "@workglow/util/media";
 var inputSchema50 = {
   type: "object",
   properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Source image" }),
+    image: GpuImageSchema10({ title: "Image", description: "Source image" }),
     levels: {
       type: "integer",
       title: "Levels",
-      description: "Number of color levels per channel (2-32)",
+      description: "Number of color levels per channel (2-16)",
       minimum: 2,
-      maximum: 32,
+      maximum: 16,
       default: 4
     }
   },
@@ -6716,14 +6987,12 @@ var inputSchema50 = {
 };
 var outputSchema49 = {
   type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Posterized image" })
-  },
+  properties: { image: GpuImageSchema10({ title: "Image", description: "Posterized image" }) },
   required: ["image"],
   additionalProperties: false
 };
 
-class ImagePosterizeTask extends Task51 {
+class ImagePosterizeTask extends ImageFilterTask {
   static type = "ImagePosterizeTask";
   static category = "Image";
   static title = "Posterize";
@@ -6734,52 +7003,34 @@ class ImagePosterizeTask extends Task51 {
   static outputSchema() {
     return outputSchema49;
   }
-  async execute(input, _context) {
-    return await posterizeImage(input);
-  }
-  async executePreview(input, _context) {
-    return await posterizeImage(input);
+  filterName = "posterize";
+  opParams(input) {
+    return { levels: input.levels ?? 4 };
   }
 }
 Workflow26.prototype.imagePosterize = CreateWorkflow25(ImagePosterizeTask);
 // src/task/image/imageRasterCodecRegistry.ts
-import { getImageRasterCodec as getImageRasterCodec2, registerImageRasterCodec as registerImageRasterCodec2 } from "@workglow/util/media";
-// src/task/image/ImageResizeTask.ts
-import {
-  CreateWorkflow as CreateWorkflow26,
-  Task as Task52,
-  Workflow as Workflow27
-} from "@workglow/task-graph";
-async function resizeImage(input) {
-  const { width: dstW, height: dstH } = input;
-  const image = await produceImageOutput(input.image, (img) => {
-    const { data: src, width: srcW, height: srcH, channels } = img;
-    const dst = new Uint8ClampedArray(dstW * dstH * channels);
-    for (let dy = 0;dy < dstH; dy++) {
-      const srcY = Math.min(Math.floor(dy * srcH / dstH), srcH - 1);
-      for (let dx = 0;dx < dstW; dx++) {
-        const srcX = Math.min(Math.floor(dx * srcW / dstW), srcW - 1);
-        const srcIdx = (srcY * srcW + srcX) * channels;
-        const dstIdx = (dy * dstW + dx) * channels;
-        for (let c = 0;c < channels; c++) {
-          dst[dstIdx + c] = src[srcIdx + c];
-        }
-      }
-    }
-    return { data: dst, width: dstW, height: dstH, channels };
-  });
-  return { image };
-}
+import { getImageRasterCodec, registerImageRasterCodec as registerImageRasterCodec2 } from "@workglow/util/media";
+// src/task/image/resize/ImageResizeTask.ts
+import { CreateWorkflow as CreateWorkflow26, Workflow as Workflow27 } from "@workglow/task-graph";
+import { GpuImageSchema as GpuImageSchema11 } from "@workglow/util/media";
 var inputSchema51 = {
   type: "object",
   properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Source image" }),
+    image: GpuImageSchema11({ title: "Image", description: "Source image" }),
     width: { type: "integer", title: "Width", description: "Target width in pixels", minimum: 1 },
-    height: {
-      type: "integer",
-      title: "Height",
-      description: "Target height in pixels",
-      minimum: 1
+    height: { type: "integer", title: "Height", description: "Target height in pixels", minimum: 1 },
+    fit: {
+      type: "string",
+      enum: ["cover", "contain", "fill", "inside", "outside"],
+      title: "Fit",
+      description: "How the image should be resized to fit"
+    },
+    kernel: {
+      type: "string",
+      enum: ["nearest", "cubic", "mitchell", "lanczos2", "lanczos3"],
+      title: "Kernel",
+      description: "Resampling kernel"
     }
   },
   required: ["image", "width", "height"],
@@ -6787,14 +7038,12 @@ var inputSchema51 = {
 };
 var outputSchema50 = {
   type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Resized image" })
-  },
+  properties: { image: GpuImageSchema11({ title: "Image", description: "Resized image" }) },
   required: ["image"],
   additionalProperties: false
 };
 
-class ImageResizeTask extends Task52 {
+class ImageResizeTask extends ImageFilterTask {
   static type = "ImageResizeTask";
   static category = "Image";
   static title = "Resize Image";
@@ -6805,61 +7054,42 @@ class ImageResizeTask extends Task52 {
   static outputSchema() {
     return outputSchema50;
   }
-  async execute(input, _context) {
-    return await resizeImage(input);
+  filterName = "resize";
+  opParams(input) {
+    return {
+      width: input.width,
+      height: input.height,
+      fit: input.fit,
+      kernel: input.kernel
+    };
   }
-  async executePreview(input, _context) {
-    return await resizeImage(input);
+  scalePreviewParams({ width, height, fit, kernel }, s) {
+    return {
+      width: Math.max(1, Math.round(width * s)),
+      height: Math.max(1, Math.round(height * s)),
+      fit,
+      kernel
+    };
   }
 }
 Workflow27.prototype.imageResize = CreateWorkflow26(ImageResizeTask);
-// src/task/image/ImageRotateTask.ts
-import {
-  CreateWorkflow as CreateWorkflow27,
-  Task as Task53,
-  Workflow as Workflow28
-} from "@workglow/task-graph";
-async function rotateImage(input) {
-  const { angle } = input;
-  const image = await produceImageOutput(input.image, (img) => {
-    const { data: src, width: srcW, height: srcH, channels } = img;
-    const swap = angle === 90 || angle === 270;
-    const dstW = swap ? srcH : srcW;
-    const dstH = swap ? srcW : srcH;
-    const dst = new Uint8ClampedArray(dstW * dstH * channels);
-    for (let sy = 0;sy < srcH; sy++) {
-      for (let sx = 0;sx < srcW; sx++) {
-        let dx, dy;
-        if (angle === 90) {
-          dx = srcH - 1 - sy;
-          dy = sx;
-        } else if (angle === 180) {
-          dx = srcW - 1 - sx;
-          dy = srcH - 1 - sy;
-        } else {
-          dx = sy;
-          dy = srcW - 1 - sx;
-        }
-        const srcIdx = (sy * srcW + sx) * channels;
-        const dstIdx = (dy * dstW + dx) * channels;
-        for (let c = 0;c < channels; c++) {
-          dst[dstIdx + c] = src[srcIdx + c];
-        }
-      }
-    }
-    return { data: dst, width: dstW, height: dstH, channels };
-  });
-  return { image };
-}
+// src/task/image/rotate/ImageRotateTask.ts
+import { CreateWorkflow as CreateWorkflow27, Workflow as Workflow28 } from "@workglow/task-graph";
+import { GpuImageSchema as GpuImageSchema12 } from "@workglow/util/media";
 var inputSchema52 = {
   type: "object",
   properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Source image" }),
+    image: GpuImageSchema12({ title: "Image", description: "Source image" }),
     angle: {
       type: "integer",
       enum: [90, 180, 270],
       title: "Angle",
       description: "Rotation angle in degrees (clockwise)"
+    },
+    background: {
+      type: "string",
+      title: "Background",
+      description: "Background color for rotation (hex string)"
     }
   },
   required: ["image", "angle"],
@@ -6867,14 +7097,12 @@ var inputSchema52 = {
 };
 var outputSchema51 = {
   type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Rotated image" })
-  },
+  properties: { image: GpuImageSchema12({ title: "Image", description: "Rotated image" }) },
   required: ["image"],
   additionalProperties: false
 };
 
-class ImageRotateTask extends Task53 {
+class ImageRotateTask extends ImageFilterTask {
   static type = "ImageRotateTask";
   static category = "Image";
   static title = "Rotate Image";
@@ -6885,64 +7113,87 @@ class ImageRotateTask extends Task53 {
   static outputSchema() {
     return outputSchema51;
   }
-  async execute(input, _context) {
-    return await rotateImage(input);
-  }
-  async executePreview(input, _context) {
-    return await rotateImage(input);
+  filterName = "rotate";
+  opParams(input) {
+    return {
+      angle: input.angle,
+      background: input.background
+    };
   }
 }
 Workflow28.prototype.imageRotate = CreateWorkflow27(ImageRotateTask);
-// src/task/image/ImageSepiaTask.ts
-import {
-  CreateWorkflow as CreateWorkflow28,
-  Task as Task54,
-  Workflow as Workflow29
-} from "@workglow/task-graph";
-async function applySepia(input) {
-  const image = await produceImageOutput(input.image, (img) => {
-    const { data: src, width, height, channels } = img;
-    const dst = new Uint8ClampedArray(src.length);
-    const pixelCount = width * height;
-    for (let i = 0;i < pixelCount; i++) {
-      const idx = i * channels;
-      const r = channels === 1 ? src[idx] : src[idx];
-      const g = channels === 1 ? src[idx] : src[idx + 1];
-      const b = channels === 1 ? src[idx] : src[idx + 2];
-      const outR = r * 402 + g * 787 + b * 194 >> 10;
-      const outG = r * 357 + g * 702 + b * 172 >> 10;
-      const outB = r * 279 + g * 547 + b * 134 >> 10;
-      dst[idx] = outR > 255 ? 255 : outR;
-      if (channels >= 3) {
-        dst[idx + 1] = outG > 255 ? 255 : outG;
-        dst[idx + 2] = outB > 255 ? 255 : outB;
-      }
-      if (channels === 4) {
-        dst[idx + 3] = src[idx + 3];
-      }
+// src/task/image/ImageSchemas.ts
+import { FromSchemaDefaultOptions } from "@workglow/util/schema";
+var cssRgbChannelPattern = "(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)";
+var cssRgbAlphaPattern = "(?:0(?:\\.\\d+)?|1(?:\\.0+)?)";
+var cssRgbColorPattern = `^rgba?\\(\\s*${cssRgbChannelPattern}\\s*,\\s*${cssRgbChannelPattern}\\s*,\\s*` + `${cssRgbChannelPattern}\\s*(?:,\\s*${cssRgbAlphaPattern})?\\s*\\)$`;
+var ColorSchema = (annotations = {}) => ({
+  type: "object",
+  properties: {
+    r: { type: "integer", minimum: 0, maximum: 255, title: "Red" },
+    g: { type: "integer", minimum: 0, maximum: 255, title: "Green" },
+    b: { type: "integer", minimum: 0, maximum: 255, title: "Blue" },
+    a: { type: "integer", minimum: 0, maximum: 255, title: "Alpha", default: 255 }
+  },
+  required: ["r", "g", "b"],
+  format: "color",
+  additionalProperties: false,
+  ...annotations
+});
+var HexColorSchema = (annotations = {}) => ({
+  type: "string",
+  format: "color",
+  pattern: "^#([0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$",
+  title: "Color (hex)",
+  description: "Color as a `#RRGGBB[AA]` or `#RGB[A]` hex string",
+  ...annotations
+});
+var CssRgbColorSchema = (annotations = {}) => ({
+  type: "string",
+  format: "color",
+  pattern: cssRgbColorPattern,
+  title: "Color (RGB)",
+  description: "Color as a CSS `rgb(r,g,b)` or `rgba(r,g,b,a)` string",
+  ...annotations
+});
+var ColorValueSchema = (annotations = {}) => ({
+  oneOf: [
+    ColorSchema(),
+    HexColorSchema({
+      title: annotations.title ?? "Color",
+      description: annotations.description ?? "Color as {r,g,b,a} object, `#RRGGBB[AA]` / `#RGB[A]` hex string, or CSS `rgb(...)` / `rgba(...)` string"
+    }),
+    CssRgbColorSchema()
+  ],
+  ...annotations
+});
+var ColorObjectType = null;
+var ColorFromSchemaOptions = {
+  ...FromSchemaDefaultOptions,
+  deserialize: [
+    {
+      pattern: { type: "object", format: "color" },
+      output: ColorObjectType
     }
-    return { data: dst, width, height, channels };
-  });
-  return { image };
-}
+  ]
+};
+// src/task/image/sepia/ImageSepiaTask.ts
+import { CreateWorkflow as CreateWorkflow28, Workflow as Workflow29 } from "@workglow/task-graph";
+import { GpuImageSchema as GpuImageSchema13 } from "@workglow/util/media";
 var inputSchema53 = {
   type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Source image" })
-  },
+  properties: { image: GpuImageSchema13({ title: "Image", description: "Source image" }) },
   required: ["image"],
   additionalProperties: false
 };
 var outputSchema52 = {
   type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Sepia-toned image" })
-  },
+  properties: { image: GpuImageSchema13({ title: "Image", description: "Sepia-toned image" }) },
   required: ["image"],
   additionalProperties: false
 };
 
-class ImageSepiaTask extends Task54 {
+class ImageSepiaTask extends ImageFilterTask {
   static type = "ImageSepiaTask";
   static category = "Image";
   static title = "Sepia Tone";
@@ -6953,21 +7204,24 @@ class ImageSepiaTask extends Task54 {
   static outputSchema() {
     return outputSchema52;
   }
-  async execute(input, _context) {
-    return await applySepia(input);
-  }
-  async executePreview(input, _context) {
-    return await applySepia(input);
+  filterName = "sepia";
+  opParams(_input) {
+    return;
   }
 }
 Workflow29.prototype.imageSepia = CreateWorkflow28(ImageSepiaTask);
-// src/task/image/ImageTextTask.ts
+// src/task/image/text/ImageTextTask.ts
 import {
   CreateWorkflow as CreateWorkflow29,
-  Task as Task55,
+  Task as Task43,
   Workflow as Workflow30
 } from "@workglow/task-graph";
-import { resolveColor as resolveColor2 } from "@workglow/util/media";
+import {
+  CpuImage as CpuImage18,
+  getPreviewBudget,
+  GpuImageSchema as GpuImageSchema14,
+  resolveColor as resolveColor5
+} from "@workglow/util/media";
 function toRgbaImage(image) {
   const { data, width, height, channels } = image;
   const rgba = new Uint8ClampedArray(width * height * 4);
@@ -7042,7 +7296,7 @@ var IMAGE_TEXT_POSITION_LABELS = {
   "bottom-center": "Bottom center",
   "bottom-right": "Bottom right"
 };
-var backgroundImageProperty = ImageBinaryOrDataUriSchema({
+var backgroundImageProperty = GpuImageSchema14({
   title: "Image",
   description: "Background image to render the text onto"
 });
@@ -7107,65 +7361,73 @@ var inputSchema54 = {
 var outputSchema53 = {
   type: "object",
   properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Raster image with text" })
+    image: GpuImageSchema14({ title: "Image", description: "Raster image with text" })
   },
   required: ["image"],
   additionalProperties: false
 };
-function hasUsableBackgroundImage(value) {
-  if (typeof value === "string") {
-    return value.length > 0;
-  }
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate.width === "number" && typeof candidate.height === "number" && typeof candidate.channels === "number" && candidate.data !== undefined;
+function resolveTextParams(input) {
+  return {
+    text: input.text,
+    font: input.font ?? "sans-serif",
+    fontSize: input.fontSize ?? 24,
+    bold: input.bold ?? false,
+    italic: input.italic ?? false,
+    color: resolveColor5(input.color),
+    position: input.position ?? "middle-center"
+  };
+}
+function requireStandaloneDims(input) {
+  if (!("width" in input) || !("height" in input) || typeof input.width !== "number" || typeof input.height !== "number") {
+    throw new Error("ImageTextTask: width and height are required when no background image is provided");
+  }
+  return { width: input.width, height: input.height };
+}
+async function renderTextOverBackground(params, backgroundImage, previewScale) {
+  const background = await backgroundImage.materialize();
+  const overlay = await renderImageTextToRgba({
+    text: params.text,
+    font: params.font,
+    fontSize: Math.max(1, Math.round(params.fontSize * previewScale)),
+    bold: params.bold,
+    italic: params.italic,
+    color: params.color,
+    width: background.width,
+    height: background.height,
+    position: params.position
+  });
+  const composited = compositeTextOverBackground(background, overlay);
+  return {
+    image: CpuImage18.fromImageBinary(composited, previewScale)
+  };
 }
-async function renderImageText(input) {
-  const color = resolveColor2(input.color);
-  const fontSize = input.fontSize ?? 24;
-  const font = input.font ?? "sans-serif";
-  const bold = input.bold ?? false;
-  const italic = input.italic ?? false;
-  const position = input.position ?? "middle-center";
+async function renderTextStandalone(params, width, height, previewScale) {
+  const textBinary = await renderImageTextToRgba({
+    text: params.text,
+    font: params.font,
+    fontSize: Math.max(1, Math.round(params.fontSize * previewScale)),
+    bold: params.bold,
+    italic: params.italic,
+    color: params.color,
+    width: Math.max(1, Math.round(width * previewScale)),
+    height: Math.max(1, Math.round(height * previewScale)),
+    position: params.position
+  });
+  return {
+    image: CpuImage18.fromImageBinary(textBinary, previewScale)
+  };
+}
+async function runText(input) {
+  const params = resolveTextParams(input);
   const backgroundImage = "image" in input ? input.image : undefined;
-  let image;
-  if (hasUsableBackgroundImage(backgroundImage)) {
-    image = await produceImageOutput(backgroundImage, async (background) => {
-      const overlay = await renderImageTextToRgba({
-        text: input.text,
-        font,
-        fontSize,
-        bold,
-        italic,
-        color,
-        width: background.width,
-        height: background.height,
-        position
-      });
-      return compositeTextOverBackground(background, overlay);
-    });
-  } else {
-    if (!("width" in input) || !("height" in input) || typeof input.width !== "number" || typeof input.height !== "number") {
-      throw new Error("ImageTextTask: width and height are required when no background image is provided");
-    }
-    image = await renderImageTextToRgba({
-      text: input.text,
-      font,
-      fontSize,
-      bold,
-      italic,
-      color,
-      width: input.width,
-      height: input.height,
-      position
-    });
+  if (backgroundImage != null) {
+    return renderTextOverBackground(params, backgroundImage, 1);
   }
-  return { image };
+  const { width, height } = requireStandaloneDims(input);
+  return renderTextStandalone(params, width, height, 1);
 }
 
-class ImageTextTask extends Task55 {
+class ImageTextTask extends Task43 {
   static type = "ImageTextTask";
   static category = "Image";
   static title = "Render Text to Image";
@@ -7184,46 +7446,32 @@ class ImageTextTask extends Task55 {
     return defaults;
   }
   async execute(input, _context) {
-    return await renderImageText(input);
+    return await runText(input);
   }
   async executePreview(input, _context) {
-    return await renderImageText(input);
+    const params = resolveTextParams(input);
+    const backgroundImage = "image" in input ? input.image : undefined;
+    if (backgroundImage != null) {
+      return await renderTextOverBackground(params, backgroundImage, backgroundImage.previewScale);
+    }
+    const { width, height } = requireStandaloneDims(input);
+    const longEdge = Math.max(width, height);
+    const budget = getPreviewBudget();
+    const s = longEdge > budget ? budget / longEdge : 1;
+    return await renderTextStandalone(params, width, height, s);
   }
 }
 Workflow30.prototype.imageText = CreateWorkflow29(ImageTextTask);
-// src/task/image/ImageThresholdTask.ts
-import {
-  CreateWorkflow as CreateWorkflow30,
-  Task as Task56,
-  Workflow as Workflow31
-} from "@workglow/task-graph";
-async function applyThreshold(input) {
-  const threshold = input.threshold ?? 128;
-  const image = await produceImageOutput(input.image, (img) => {
-    const { data: src, width, height, channels } = img;
-    const pixelCount = width * height;
-    const dst = new Uint8ClampedArray(pixelCount);
-    for (let i = 0;i < pixelCount; i++) {
-      const idx = i * channels;
-      let gray;
-      if (channels === 1) {
-        gray = src[idx];
-      } else {
-        gray = src[idx] * 77 + src[idx + 1] * 150 + src[idx + 2] * 29 >> 8;
-      }
-      dst[i] = gray >= threshold ? 255 : 0;
-    }
-    return { data: dst, width, height, channels: 1 };
-  });
-  return { image };
-}
+// src/task/image/threshold/ImageThresholdTask.ts
+import { CreateWorkflow as CreateWorkflow30, Workflow as Workflow31 } from "@workglow/task-graph";
+import { GpuImageSchema as GpuImageSchema15 } from "@workglow/util/media";
 var inputSchema55 = {
   type: "object",
   properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Source image" }),
-    threshold: {
-      type: "integer",
-      title: "Threshold",
+    image: GpuImageSchema15({ title: "Image", description: "Source image" }),
+    value: {
+      type: "number",
+      title: "Value",
       description: "Threshold value (0-255)",
       minimum: 0,
       maximum: 255,
@@ -7235,77 +7483,35 @@ var inputSchema55 = {
 };
 var outputSchema54 = {
   type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Thresholded binary image" })
-  },
+  properties: { image: GpuImageSchema15({ title: "Image", description: "Thresholded image" }) },
   required: ["image"],
   additionalProperties: false
 };
 
-class ImageThresholdTask extends Task56 {
+class ImageThresholdTask extends ImageFilterTask {
   static type = "ImageThresholdTask";
   static category = "Image";
   static title = "Threshold";
-  static description = "Converts an image to binary black and white";
+  static description = "Applies a binary threshold per channel";
   static inputSchema() {
     return inputSchema55;
   }
   static outputSchema() {
     return outputSchema54;
   }
-  async execute(input, _context) {
-    return await applyThreshold(input);
-  }
-  async executePreview(input, _context) {
-    return await applyThreshold(input);
+  filterName = "threshold";
+  opParams(input) {
+    return { value: input.value ?? 128 };
   }
 }
 Workflow31.prototype.imageThreshold = CreateWorkflow30(ImageThresholdTask);
-// src/task/image/ImageTintTask.ts
-import {
-  CreateWorkflow as CreateWorkflow31,
-  Task as Task57,
-  Workflow as Workflow32
-} from "@workglow/task-graph";
-import { resolveColor as resolveColor3 } from "@workglow/util/media";
-async function applyTint(input) {
-  const { r: tr, g: tg, b: tb } = resolveColor3(input.color);
-  const amount = input.amount ?? 0.5;
-  const invAmount = 1 - amount;
-  const tintR = tr * amount;
-  const tintG = tg * amount;
-  const tintB = tb * amount;
-  const image = await produceImageOutput(input.image, (img) => {
-    const { data: src, width, height, channels } = img;
-    const pixelCount = width * height;
-    if (channels === 1) {
-      const dst2 = new Uint8ClampedArray(pixelCount * 3);
-      for (let i = 0;i < pixelCount; i++) {
-        const gray = src[i];
-        dst2[i * 3] = gray * invAmount + tintR;
-        dst2[i * 3 + 1] = gray * invAmount + tintG;
-        dst2[i * 3 + 2] = gray * invAmount + tintB;
-      }
-      return { data: dst2, width, height, channels: 3 };
-    }
-    const dst = new Uint8ClampedArray(src.length);
-    for (let i = 0;i < pixelCount; i++) {
-      const idx = i * channels;
-      dst[idx] = src[idx] * invAmount + tintR;
-      dst[idx + 1] = src[idx + 1] * invAmount + tintG;
-      dst[idx + 2] = src[idx + 2] * invAmount + tintB;
-      if (channels === 4) {
-        dst[idx + 3] = src[idx + 3];
-      }
-    }
-    return { data: dst, width, height, channels };
-  });
-  return { image };
-}
+// src/task/image/tint/ImageTintTask.ts
+import { CreateWorkflow as CreateWorkflow31, Workflow as Workflow32 } from "@workglow/task-graph";
+import { GpuImageSchema as GpuImageSchema16 } from "@workglow/util/media";
 var inputSchema56 = {
   type: "object",
   properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Source image" }),
+    image: GpuImageSchema16({ title: "Image", description: "Source image" }),
     color: ColorValueSchema({ title: "Color", description: "Tint color" }),
     amount: {
       type: "number",
@@ -7321,14 +7527,12 @@ var inputSchema56 = {
 };
 var outputSchema55 = {
   type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Tinted image" })
-  },
+  properties: { image: GpuImageSchema16({ title: "Image", description: "Tinted image" }) },
   required: ["image"],
   additionalProperties: false
 };
 
-class ImageTintTask extends Task57 {
+class ImageTintTask extends ImageFilterTask {
   static type = "ImageTintTask";
   static category = "Image";
   static title = "Tint Image";
@@ -7339,68 +7543,42 @@ class ImageTintTask extends Task57 {
   static outputSchema() {
     return outputSchema55;
   }
-  async execute(input, _context) {
-    return await applyTint(input);
-  }
-  async executePreview(input, _context) {
-    return await applyTint(input);
+  filterName = "tint";
+  opParams(input) {
+    return {
+      color: input.color,
+      amount: input.amount ?? 0.5
+    };
   }
 }
 Workflow32.prototype.imageTint = CreateWorkflow31(ImageTintTask);
-// src/task/image/ImageTransparencyTask.ts
-import {
-  CreateWorkflow as CreateWorkflow32,
-  Task as Task58,
-  Workflow as Workflow33
-} from "@workglow/task-graph";
-async function applyTransparency(input) {
-  const { opacity } = input;
-  const image = await produceImageOutput(input.image, (img) => {
-    const { data: src, width, height, channels: srcCh } = img;
-    const pixelCount = width * height;
-    const dst = new Uint8ClampedArray(pixelCount * 4);
-    const alphaScale = Math.round(opacity * 255);
-    for (let i = 0;i < pixelCount; i++) {
-      const srcIdx = i * srcCh;
-      const dstIdx = i * 4;
-      dst[dstIdx] = src[srcIdx];
-      dst[dstIdx + 1] = srcCh >= 3 ? src[srcIdx + 1] : src[srcIdx];
-      dst[dstIdx + 2] = srcCh >= 3 ? src[srcIdx + 2] : src[srcIdx];
-      const srcAlpha = srcCh === 4 ? src[srcIdx + 3] : 255;
-      dst[dstIdx + 3] = (srcAlpha * alphaScale + 127) / 255;
-    }
-    return { data: dst, width, height, channels: 4 };
-  });
-  return { image };
-}
+// src/task/image/transparency/ImageTransparencyTask.ts
+import { CreateWorkflow as CreateWorkflow32, Workflow as Workflow33 } from "@workglow/task-graph";
+import { GpuImageSchema as GpuImageSchema17 } from "@workglow/util/media";
 var inputSchema57 = {
   type: "object",
   properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Source image" }),
-    opacity: {
+    image: GpuImageSchema17({ title: "Image", description: "Source image" }),
+    amount: {
       type: "number",
-      title: "Opacity",
+      title: "Amount",
       description: "Opacity level (0.0 = fully transparent, 1.0 = fully opaque)",
       minimum: 0,
-      maximum: 1
+      maximum: 1,
+      default: 1
     }
   },
-  required: ["image", "opacity"],
+  required: ["image"],
   additionalProperties: false
 };
 var outputSchema56 = {
   type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({
-      title: "Image",
-      description: "Image with adjusted transparency"
-    })
-  },
+  properties: { image: GpuImageSchema17({ title: "Image", description: "Image with adjusted transparency" }) },
   required: ["image"],
   additionalProperties: false
 };
 
-class ImageTransparencyTask extends Task58 {
+class ImageTransparencyTask extends ImageFilterTask {
   static type = "ImageTransparencyTask";
   static category = "Image";
   static title = "Set Transparency";
@@ -7411,133 +7589,19 @@ class ImageTransparencyTask extends Task58 {
   static outputSchema() {
     return outputSchema56;
   }
-  async execute(input, _context) {
-    return await applyTransparency(input);
-  }
-  async executePreview(input, _context) {
-    return await applyTransparency(input);
+  filterName = "transparency";
+  opParams(input) {
+    return { amount: input.amount ?? 1 };
   }
 }
 Workflow33.prototype.imageTransparency = CreateWorkflow32(ImageTransparencyTask);
-// src/task/image/ImageWatermarkTask.ts
-import {
-  CreateWorkflow as CreateWorkflow33,
-  Task as Task59,
-  Workflow as Workflow34
-} from "@workglow/task-graph";
-async function applyWatermark(input) {
-  const { spacing = 64, opacity = 0.3, pattern = "diagonal-lines" } = input;
-  const image = await produceImageOutput(input.image, (img) => {
-    const { data: src, width, height, channels: srcCh } = img;
-    const outCh = 4;
-    const dst = new Uint8ClampedArray(width * height * outCh);
-    const lineWidth = 2;
-    const dotRadius = Math.max(2, spacing >> 3);
-    const dotRadiusSq = dotRadius * dotRadius;
-    const half = spacing >> 1;
-    const alpha = Math.round(opacity * 255);
-    for (let y = 0;y < height; y++) {
-      for (let x = 0;x < width; x++) {
-        const srcIdx = (y * width + x) * srcCh;
-        const dstIdx = (y * width + x) * outCh;
-        const sr = src[srcIdx];
-        const sg = srcCh >= 3 ? src[srcIdx + 1] : sr;
-        const sb = srcCh >= 3 ? src[srcIdx + 2] : sr;
-        const sa = srcCh === 4 ? src[srcIdx + 3] : 255;
-        let isPattern = false;
-        if (pattern === "diagonal-lines") {
-          isPattern = (x + y) % spacing < lineWidth;
-        } else if (pattern === "grid") {
-          isPattern = x % spacing < lineWidth || y % spacing < lineWidth;
-        } else {
-          const dx = x % spacing - half;
-          const dy = y % spacing - half;
-          isPattern = dx * dx + dy * dy < dotRadiusSq;
-        }
-        if (isPattern) {
-          const blend = alpha;
-          const invBlend = 255 - blend;
-          dst[dstIdx] = (sr * invBlend + 255 * blend + 127) / 255;
-          dst[dstIdx + 1] = (sg * invBlend + 255 * blend + 127) / 255;
-          dst[dstIdx + 2] = (sb * invBlend + 255 * blend + 127) / 255;
-          dst[dstIdx + 3] = sa;
-        } else {
-          dst[dstIdx] = sr;
-          dst[dstIdx + 1] = sg;
-          dst[dstIdx + 2] = sb;
-          dst[dstIdx + 3] = sa;
-        }
-      }
-    }
-    return { data: dst, width, height, channels: outCh };
-  });
-  return { image };
-}
-var inputSchema58 = {
-  type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Source image" }),
-    spacing: {
-      type: "integer",
-      title: "Spacing",
-      description: "Pattern spacing in pixels",
-      minimum: 8,
-      default: 64
-    },
-    opacity: {
-      type: "number",
-      title: "Opacity",
-      description: "Watermark opacity (0.0-1.0)",
-      minimum: 0,
-      maximum: 1,
-      default: 0.3
-    },
-    pattern: {
-      type: "string",
-      enum: ["diagonal-lines", "grid", "dots"],
-      title: "Pattern",
-      description: "Watermark pattern type",
-      default: "diagonal-lines"
-    }
-  },
-  required: ["image"],
-  additionalProperties: false
-};
-var outputSchema57 = {
-  type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Watermarked image" })
-  },
-  required: ["image"],
-  additionalProperties: false
-};
-
-class ImageWatermarkTask extends Task59 {
-  static type = "ImageWatermarkTask";
-  static category = "Image";
-  static title = "Add Watermark";
-  static description = "Adds a repeating pattern watermark to an image";
-  static inputSchema() {
-    return inputSchema58;
-  }
-  static outputSchema() {
-    return outputSchema57;
-  }
-  async execute(input, _context) {
-    return await applyWatermark(input);
-  }
-  async executePreview(input, _context) {
-    return await applyWatermark(input);
-  }
-}
-Workflow34.prototype.imageWatermark = CreateWorkflow33(ImageWatermarkTask);
 // src/task/InputTask.ts
-import { CreateWorkflow as CreateWorkflow34, Task as Task60, Workflow as Workflow35 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow33, Task as Task44, Workflow as Workflow34 } from "@workglow/task-graph";
 function passthroughInput(input) {
   return input;
 }
 
-class InputTask extends Task60 {
+class InputTask extends Task44 {
   static type = "InputTask";
   static category = "Flow Control";
   static title = "Input";
@@ -7592,15 +7656,15 @@ class InputTask extends Task60 {
     yield { type: "finish", data: input };
   }
 }
-Workflow35.prototype.input = CreateWorkflow34(InputTask);
+Workflow34.prototype.input = CreateWorkflow33(InputTask);
 // src/task/JavaScriptTask.ts
 import {
-  CreateWorkflow as CreateWorkflow35,
+  CreateWorkflow as CreateWorkflow34,
   Entitlements as Entitlements7,
-  Task as Task61,
+  Task as Task45,
   TaskConfigSchema as TaskConfigSchema32,
   TaskInvalidInputError as TaskInvalidInputError3,
-  Workflow as Workflow36
+  Workflow as Workflow35
 } from "@workglow/task-graph";
 
 // src/util/acorn.js
@@ -12096,7 +12160,7 @@ var configSchema = {
   },
   additionalProperties: false
 };
-var inputSchema59 = {
+var inputSchema58 = {
   type: "object",
   properties: {
     javascript_code: {
@@ -12110,7 +12174,7 @@ var inputSchema59 = {
   required: ["javascript_code"],
   additionalProperties: true
 };
-var outputSchema58 = {
+var outputSchema57 = {
   type: "object",
   properties: {
     output: {
@@ -12122,7 +12186,7 @@ var outputSchema58 = {
   additionalProperties: false
 };
 
-class JavaScriptTask extends Task61 {
+class JavaScriptTask extends Task45 {
   static type = "JavaScriptTask";
   static category = "Utility";
   static title = "JavaScript Interpreter";
@@ -12143,10 +12207,10 @@ class JavaScriptTask extends Task61 {
     return configSchema;
   }
   static inputSchema() {
-    return inputSchema59;
+    return inputSchema58;
   }
   static outputSchema() {
-    return outputSchema58;
+    return outputSchema57;
   }
   inputSchema() {
     if (this.config?.javascript_code) {
@@ -12159,7 +12223,7 @@ class JavaScriptTask extends Task61 {
         additionalProperties: true
       };
     }
-    return inputSchema59;
+    return inputSchema58;
   }
   async execute(input2) {
     return runJavaScript(input2, this.config.javascript_code);
@@ -12171,14 +12235,14 @@ class JavaScriptTask extends Task61 {
 var javaScript = (input2, config = {}) => {
   return new JavaScriptTask(config).run(input2);
 };
-Workflow36.prototype.javaScript = CreateWorkflow35(JavaScriptTask);
+Workflow35.prototype.javaScript = CreateWorkflow34(JavaScriptTask);
 // src/task/JsonPathTask.ts
 import {
-  CreateWorkflow as CreateWorkflow36,
-  Task as Task62,
-  Workflow as Workflow37
+  CreateWorkflow as CreateWorkflow35,
+  Task as Task46,
+  Workflow as Workflow36
 } from "@workglow/task-graph";
-var inputSchema60 = {
+var inputSchema59 = {
   type: "object",
   properties: {
     value: {
@@ -12194,7 +12258,7 @@ var inputSchema60 = {
   required: ["value", "path"],
   additionalProperties: false
 };
-var outputSchema59 = {
+var outputSchema58 = {
   type: "object",
   properties: {
     result: {
@@ -12231,16 +12295,16 @@ function extractJsonPath(value, path) {
   return resolvePath(value, segments);
 }
 
-class JsonPathTask extends Task62 {
+class JsonPathTask extends Task46 {
   static type = "JsonPathTask";
   static category = "Utility";
   static title = "JSON Path";
   static description = "Extracts a value from an object using a dot-notation path";
   static inputSchema() {
-    return inputSchema60;
+    return inputSchema59;
   }
   static outputSchema() {
-    return outputSchema59;
+    return outputSchema58;
   }
   async execute(input2, _context) {
     return { result: extractJsonPath(input2.value, input2.path) };
@@ -12249,18 +12313,18 @@ class JsonPathTask extends Task62 {
     return { result: extractJsonPath(input2.value, input2.path) };
   }
 }
-Workflow37.prototype.jsonPath = CreateWorkflow36(JsonPathTask);
+Workflow36.prototype.jsonPath = CreateWorkflow35(JsonPathTask);
 // src/task/JsonTask.ts
 import {
   createGraphFromDependencyJSON,
   createGraphFromGraphJSON,
-  CreateWorkflow as CreateWorkflow37,
+  CreateWorkflow as CreateWorkflow36,
   Dataflow,
   GraphAsTask as GraphAsTask2,
   TaskConfigurationError as TaskConfigurationError3,
-  Workflow as Workflow38
+  Workflow as Workflow37
 } from "@workglow/task-graph";
-var inputSchema61 = {
+var inputSchema60 = {
   type: "object",
   properties: {
     json: {
@@ -12271,7 +12335,7 @@ var inputSchema61 = {
   },
   additionalProperties: false
 };
-var outputSchema60 = {
+var outputSchema59 = {
   type: "object",
   properties: {
     output: {
@@ -12288,10 +12352,10 @@ class JsonTask extends GraphAsTask2 {
   static title = "JSON Task";
   static description = "A task that creates and manages task graphs from JSON configurations";
   static inputSchema() {
-    return inputSchema61;
+    return inputSchema60;
   }
   static outputSchema() {
-    return outputSchema60;
+    return outputSchema59;
   }
   regenerateGraph() {
     if (!this.runInputData.json)
@@ -12325,15 +12389,15 @@ class JsonTask extends GraphAsTask2 {
 var json = (input2, config = {}) => {
   return new JsonTask(config).run(input2);
 };
-Workflow38.prototype.json = CreateWorkflow37(JsonTask);
+Workflow37.prototype.json = CreateWorkflow36(JsonTask);
 // src/task/LambdaTask.ts
 import {
-  CreateWorkflow as CreateWorkflow38,
+  CreateWorkflow as CreateWorkflow37,
   DATAFLOW_ALL_PORTS,
-  Task as Task63,
+  Task as Task47,
   TaskConfigSchema as TaskConfigSchema33,
   TaskConfigurationError as TaskConfigurationError4,
-  Workflow as Workflow39
+  Workflow as Workflow38
 } from "@workglow/task-graph";
 var lambdaTaskConfigSchema = {
   type: "object",
@@ -12344,7 +12408,7 @@ var lambdaTaskConfigSchema = {
   },
   additionalProperties: false
 };
-var inputSchema62 = {
+var inputSchema61 = {
   type: "object",
   properties: {
     [DATAFLOW_ALL_PORTS]: {
@@ -12354,7 +12418,7 @@ var inputSchema62 = {
   },
   additionalProperties: true
 };
-var outputSchema61 = {
+var outputSchema60 = {
   type: "object",
   properties: {
     [DATAFLOW_ALL_PORTS]: {
@@ -12365,7 +12429,7 @@ var outputSchema61 = {
   additionalProperties: true
 };
 
-class LambdaTask extends Task63 {
+class LambdaTask extends Task47 {
   static type = "LambdaTask";
   static title = "Lambda Task";
   static description = "A task that wraps a provided function and its input";
@@ -12375,10 +12439,10 @@ class LambdaTask extends Task63 {
     return lambdaTaskConfigSchema;
   }
   static inputSchema() {
-    return inputSchema62;
+    return inputSchema61;
   }
   static outputSchema() {
-    return outputSchema61;
+    return outputSchema60;
   }
   canSerializeConfig() {
     return false;
@@ -12412,14 +12476,14 @@ function lambda(input2, config) {
   const task = new LambdaTask({ ...config, defaults: input2 });
   return task.run();
 }
-Workflow39.prototype.lambda = CreateWorkflow38(LambdaTask);
+Workflow38.prototype.lambda = CreateWorkflow37(LambdaTask);
 // src/task/mcp/McpListTask.ts
 import {
-  CreateWorkflow as CreateWorkflow39,
+  CreateWorkflow as CreateWorkflow38,
   Entitlements as Entitlements8,
   mergeEntitlements as mergeEntitlements4,
-  Task as Task64,
-  Workflow as Workflow40
+  Task as Task48,
+  Workflow as Workflow39
 } from "@workglow/task-graph";
 
 // src/util/getMcpServerTransport.ts
@@ -12593,7 +12657,7 @@ var outputSchemaAll = {
   additionalProperties: false
 };
 
-class McpListTask extends Task64 {
+class McpListTask extends Task48 {
   static type = "McpListTask";
   static category = "MCP";
   static title = "MCP List";
@@ -12700,15 +12764,15 @@ class McpListTask extends Task64 {
 var mcpList = async (input2, config = {}) => {
   return new McpListTask(config).run(input2);
 };
-Workflow40.prototype.mcpList = CreateWorkflow39(McpListTask);
+Workflow39.prototype.mcpList = CreateWorkflow38(McpListTask);
 // src/task/mcp/McpPromptGetTask.ts
 import {
-  CreateWorkflow as CreateWorkflow40,
+  CreateWorkflow as CreateWorkflow39,
   Entitlements as Entitlements9,
   mergeEntitlements as mergeEntitlements5,
-  Task as Task65,
+  Task as Task49,
   TaskConfigSchema as TaskConfigSchema34,
-  Workflow as Workflow41
+  Workflow as Workflow40
 } from "@workglow/task-graph";
 var annotationsSchema = {
   type: "object",
@@ -12843,7 +12907,7 @@ var fallbackInputSchema = {
   additionalProperties: false
 };
 
-class McpPromptGetTask extends Task65 {
+class McpPromptGetTask extends Task49 {
   static type = "McpPromptGetTask";
   static category = "MCP";
   static title = "MCP Get Prompt";
@@ -12966,15 +13030,15 @@ class McpPromptGetTask extends Task65 {
 var mcpPromptGet = async (input2, config) => {
   return new McpPromptGetTask(config).run(input2);
 };
-Workflow41.prototype.mcpPromptGet = CreateWorkflow40(McpPromptGetTask);
+Workflow40.prototype.mcpPromptGet = CreateWorkflow39(McpPromptGetTask);
 // src/task/mcp/McpResourceReadTask.ts
 import {
-  CreateWorkflow as CreateWorkflow41,
+  CreateWorkflow as CreateWorkflow40,
   Entitlements as Entitlements10,
   mergeEntitlements as mergeEntitlements6,
-  Task as Task66,
+  Task as Task50,
   TaskConfigSchema as TaskConfigSchema35,
-  Workflow as Workflow42
+  Workflow as Workflow41
 } from "@workglow/task-graph";
 var contentItemSchema = {
   anyOf: [
@@ -13002,12 +13066,12 @@ var contentItemSchema = {
     }
   ]
 };
-var inputSchema63 = {
+var inputSchema62 = {
   type: "object",
   properties: {},
   additionalProperties: false
 };
-var outputSchema62 = {
+var outputSchema61 = {
   type: "object",
   properties: {
     contents: {
@@ -13021,7 +13085,7 @@ var outputSchema62 = {
   additionalProperties: false
 };
 
-class McpResourceReadTask extends Task66 {
+class McpResourceReadTask extends Task50 {
   static type = "McpResourceReadTask";
   static category = "MCP";
   static title = "MCP Read Resource";
@@ -13054,10 +13118,10 @@ class McpResourceReadTask extends Task66 {
     });
   }
   static inputSchema() {
-    return inputSchema63;
+    return inputSchema62;
   }
   static outputSchema() {
-    return outputSchema62;
+    return outputSchema61;
   }
   static configSchema() {
     const { mcpServerConfigSchema: mcpServerConfigSchema2 } = getMcpTaskDeps();
@@ -13094,13 +13158,13 @@ class McpResourceReadTask extends Task66 {
 var mcpResourceRead = async (config) => {
   return new McpResourceReadTask(config).run({});
 };
-Workflow42.prototype.mcpResourceRead = CreateWorkflow41(McpResourceReadTask);
+Workflow41.prototype.mcpResourceRead = CreateWorkflow40(McpResourceReadTask);
 // src/task/mcp/McpSearchTask.ts
 import {
-  CreateWorkflow as CreateWorkflow42,
+  CreateWorkflow as CreateWorkflow41,
   Entitlements as Entitlements11,
-  Task as Task67,
-  Workflow as Workflow43
+  Task as Task51,
+  Workflow as Workflow42
 } from "@workglow/task-graph";
 var MCP_REGISTRY_BASE = "https://registry.modelcontextprotocol.io/v0.1";
 var McpSearchInputSchema = {
@@ -13240,7 +13304,7 @@ async function searchMcpRegistry(query, signal) {
   return page.results;
 }
 
-class McpSearchTask extends Task67 {
+class McpSearchTask extends Task51 {
   static type = "McpSearchTask";
   static category = "MCP";
   static title = "MCP Search";
@@ -13267,15 +13331,15 @@ class McpSearchTask extends Task67 {
 var mcpSearch = (input2, config) => {
   return new McpSearchTask(config).run(input2);
 };
-Workflow43.prototype.mcpSearch = CreateWorkflow42(McpSearchTask);
+Workflow42.prototype.mcpSearch = CreateWorkflow41(McpSearchTask);
 // src/task/mcp/McpToolCallTask.ts
 import {
-  CreateWorkflow as CreateWorkflow43,
+  CreateWorkflow as CreateWorkflow42,
   Entitlements as Entitlements12,
   mergeEntitlements as mergeEntitlements7,
-  Task as Task68,
+  Task as Task52,
   TaskConfigSchema as TaskConfigSchema36,
-  Workflow as Workflow44
+  Workflow as Workflow43
 } from "@workglow/task-graph";
 var annotationsSchema2 = {
   type: "object",
@@ -13402,7 +13466,7 @@ var fallbackInputSchema2 = {
   additionalProperties: true
 };
 
-class McpToolCallTask extends Task68 {
+class McpToolCallTask extends Task52 {
   static type = "McpToolCallTask";
   static category = "MCP";
   static title = "MCP Call Tool";
@@ -13540,7 +13604,7 @@ class McpToolCallTask extends Task68 {
 var mcpToolCall = async (input2, config) => {
   return new McpToolCallTask(config).run(input2);
 };
-Workflow44.prototype.mcpToolCall = CreateWorkflow43(McpToolCallTask);
+Workflow43.prototype.mcpToolCall = CreateWorkflow42(McpToolCallTask);
 // src/task/McpElicitationConnector.ts
 function defaultAbortError() {
   const err = new Error("The operation was aborted");
@@ -13634,13 +13698,13 @@ class McpElicitationConnector {
   }
 }
 // src/task/MergeTask.ts
-import { CreateWorkflow as CreateWorkflow44, Task as Task69, Workflow as Workflow45 } from "@workglow/task-graph";
-var inputSchema64 = {
+import { CreateWorkflow as CreateWorkflow43, Task as Task53, Workflow as Workflow44 } from "@workglow/task-graph";
+var inputSchema63 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
-var outputSchema63 = {
+var outputSchema62 = {
   type: "object",
   properties: {
     output: {
@@ -13652,17 +13716,17 @@ var outputSchema63 = {
   additionalProperties: false
 };
 
-class MergeTask extends Task69 {
+class MergeTask extends Task53 {
   static type = "MergeTask";
   static category = "Utility";
   static title = "Merge";
   static description = "Merges multiple inputs into a single array output";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema64;
+    return inputSchema63;
   }
   static outputSchema() {
-    return outputSchema63;
+    return outputSchema62;
   }
   async execute(input2, _context) {
     const keys = Object.keys(input2).sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
@@ -13676,14 +13740,14 @@ var merge = (input2, config = {}) => {
   const task = new MergeTask(config);
   return task.run(input2);
 };
-Workflow45.prototype.merge = CreateWorkflow44(MergeTask);
+Workflow44.prototype.merge = CreateWorkflow43(MergeTask);
 // src/task/OutputTask.ts
-import { CreateWorkflow as CreateWorkflow45, Task as Task70, Workflow as Workflow46 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow44, Task as Task54, Workflow as Workflow45 } from "@workglow/task-graph";
 function passthroughInput2(input2) {
   return input2;
 }
 
-class OutputTask extends Task70 {
+class OutputTask extends Task54 {
   static type = "OutputTask";
   static category = "Flow Control";
   static title = "Output";
@@ -13739,13 +13803,13 @@ class OutputTask extends Task70 {
     yield { type: "finish", data: input2 };
   }
 }
-Workflow46.prototype.output = CreateWorkflow45(OutputTask);
+Workflow45.prototype.output = CreateWorkflow44(OutputTask);
 // src/task/RegexTask.ts
 import {
-  CreateWorkflow as CreateWorkflow46,
-  Task as Task71,
+  CreateWorkflow as CreateWorkflow45,
+  Task as Task55,
   TaskInvalidInputError as TaskInvalidInputError4,
-  Workflow as Workflow47
+  Workflow as Workflow46
 } from "@workglow/task-graph";
 var MAX_BRACKET_COUNT = 100;
 function hasNestedQuantifiers(pattern) {
@@ -13778,7 +13842,7 @@ function executeRegex(input2) {
     matches: result.slice(0)
   };
 }
-var inputSchema65 = {
+var inputSchema64 = {
   type: "object",
   properties: {
     value: {
@@ -13801,7 +13865,7 @@ var inputSchema65 = {
   required: ["value", "pattern"],
   additionalProperties: false
 };
-var outputSchema64 = {
+var outputSchema63 = {
   type: "object",
   properties: {
     match: {
@@ -13820,16 +13884,16 @@ var outputSchema64 = {
   additionalProperties: false
 };
 
-class RegexTask extends Task71 {
+class RegexTask extends Task55 {
   static type = "RegexTask";
   static category = "String";
   static title = "Regex";
   static description = "Matches a string against a regular expression pattern";
   static inputSchema() {
-    return inputSchema65;
+    return inputSchema64;
   }
   static outputSchema() {
-    return outputSchema64;
+    return outputSchema63;
   }
   async execute(input2, _context) {
     return executeRegex(input2);
@@ -13838,10 +13902,10 @@ class RegexTask extends Task71 {
     return executeRegex(input2);
   }
 }
-Workflow47.prototype.regex = CreateWorkflow46(RegexTask);
+Workflow46.prototype.regex = CreateWorkflow45(RegexTask);
 // src/task/scalar/ScalarAbsTask.ts
-import { CreateWorkflow as CreateWorkflow47, Task as Task72, Workflow as Workflow48 } from "@workglow/task-graph";
-var inputSchema66 = {
+import { CreateWorkflow as CreateWorkflow46, Task as Task56, Workflow as Workflow47 } from "@workglow/task-graph";
+var inputSchema65 = {
   type: "object",
   properties: {
     value: {
@@ -13853,7 +13917,7 @@ var inputSchema66 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema65 = {
+var outputSchema64 = {
   type: "object",
   properties: {
     result: {
@@ -13866,25 +13930,25 @@ var outputSchema65 = {
   additionalProperties: false
 };
 
-class ScalarAbsTask extends Task72 {
+class ScalarAbsTask extends Task56 {
   static type = "ScalarAbsTask";
   static category = "Math";
   static title = "Abs";
   static description = "Returns the absolute value of a number";
   static inputSchema() {
-    return inputSchema66;
+    return inputSchema65;
   }
   static outputSchema() {
-    return outputSchema65;
+    return outputSchema64;
   }
   async execute(input2, _context) {
     return { result: Math.abs(input2.value) };
   }
 }
-Workflow48.prototype.scalarAbs = CreateWorkflow47(ScalarAbsTask);
+Workflow47.prototype.scalarAbs = CreateWorkflow46(ScalarAbsTask);
 // src/task/scalar/ScalarCeilTask.ts
-import { CreateWorkflow as CreateWorkflow48, Task as Task73, Workflow as Workflow49 } from "@workglow/task-graph";
-var inputSchema67 = {
+import { CreateWorkflow as CreateWorkflow47, Task as Task57, Workflow as Workflow48 } from "@workglow/task-graph";
+var inputSchema66 = {
   type: "object",
   properties: {
     value: {
@@ -13896,7 +13960,7 @@ var inputSchema67 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema66 = {
+var outputSchema65 = {
   type: "object",
   properties: {
     result: {
@@ -13909,25 +13973,25 @@ var outputSchema66 = {
   additionalProperties: false
 };
 
-class ScalarCeilTask extends Task73 {
+class ScalarCeilTask extends Task57 {
   static type = "ScalarCeilTask";
   static category = "Math";
   static title = "Ceil";
   static description = "Returns the smallest integer greater than or equal to a number";
   static inputSchema() {
-    return inputSchema67;
+    return inputSchema66;
   }
   static outputSchema() {
-    return outputSchema66;
+    return outputSchema65;
   }
   async execute(input2, _context) {
     return { result: Math.ceil(input2.value) };
   }
 }
-Workflow49.prototype.scalarCeil = CreateWorkflow48(ScalarCeilTask);
+Workflow48.prototype.scalarCeil = CreateWorkflow47(ScalarCeilTask);
 // src/task/scalar/ScalarFloorTask.ts
-import { CreateWorkflow as CreateWorkflow49, Task as Task74, Workflow as Workflow50 } from "@workglow/task-graph";
-var inputSchema68 = {
+import { CreateWorkflow as CreateWorkflow48, Task as Task58, Workflow as Workflow49 } from "@workglow/task-graph";
+var inputSchema67 = {
   type: "object",
   properties: {
     value: {
@@ -13939,7 +14003,7 @@ var inputSchema68 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema67 = {
+var outputSchema66 = {
   type: "object",
   properties: {
     result: {
@@ -13952,25 +14016,25 @@ var outputSchema67 = {
   additionalProperties: false
 };
 
-class ScalarFloorTask extends Task74 {
+class ScalarFloorTask extends Task58 {
   static type = "ScalarFloorTask";
   static category = "Math";
   static title = "Floor";
   static description = "Returns the largest integer less than or equal to a number";
   static inputSchema() {
-    return inputSchema68;
+    return inputSchema67;
   }
   static outputSchema() {
-    return outputSchema67;
+    return outputSchema66;
   }
   async execute(input2, _context) {
     return { result: Math.floor(input2.value) };
   }
 }
-Workflow50.prototype.scalarFloor = CreateWorkflow49(ScalarFloorTask);
+Workflow49.prototype.scalarFloor = CreateWorkflow48(ScalarFloorTask);
 // src/task/scalar/ScalarMaxTask.ts
-import { CreateWorkflow as CreateWorkflow50, Task as Task75, Workflow as Workflow51 } from "@workglow/task-graph";
-var inputSchema69 = {
+import { CreateWorkflow as CreateWorkflow49, Task as Task59, Workflow as Workflow50 } from "@workglow/task-graph";
+var inputSchema68 = {
   type: "object",
   properties: {
     values: {
@@ -13983,7 +14047,7 @@ var inputSchema69 = {
   required: ["values"],
   additionalProperties: false
 };
-var outputSchema68 = {
+var outputSchema67 = {
   type: "object",
   properties: {
     result: {
@@ -13996,25 +14060,25 @@ var outputSchema68 = {
   additionalProperties: false
 };
 
-class ScalarMaxTask extends Task75 {
+class ScalarMaxTask extends Task59 {
   static type = "ScalarMaxTask";
   static category = "Math";
   static title = "Max";
   static description = "Returns the largest of the given numbers";
   static inputSchema() {
-    return inputSchema69;
+    return inputSchema68;
   }
   static outputSchema() {
-    return outputSchema68;
+    return outputSchema67;
   }
   async execute(input2, _context) {
     return { result: Math.max(...input2.values) };
   }
 }
-Workflow51.prototype.scalarMax = CreateWorkflow50(ScalarMaxTask);
+Workflow50.prototype.scalarMax = CreateWorkflow49(ScalarMaxTask);
 // src/task/scalar/ScalarMinTask.ts
-import { CreateWorkflow as CreateWorkflow51, Task as Task76, Workflow as Workflow52 } from "@workglow/task-graph";
-var inputSchema70 = {
+import { CreateWorkflow as CreateWorkflow50, Task as Task60, Workflow as Workflow51 } from "@workglow/task-graph";
+var inputSchema69 = {
   type: "object",
   properties: {
     values: {
@@ -14027,7 +14091,7 @@ var inputSchema70 = {
   required: ["values"],
   additionalProperties: false
 };
-var outputSchema69 = {
+var outputSchema68 = {
   type: "object",
   properties: {
     result: {
@@ -14040,25 +14104,25 @@ var outputSchema69 = {
   additionalProperties: false
 };
 
-class ScalarMinTask extends Task76 {
+class ScalarMinTask extends Task60 {
   static type = "ScalarMinTask";
   static category = "Math";
   static title = "Min";
   static description = "Returns the smallest of the given numbers";
   static inputSchema() {
-    return inputSchema70;
+    return inputSchema69;
   }
   static outputSchema() {
-    return outputSchema69;
+    return outputSchema68;
   }
   async execute(input2, _context) {
     return { result: Math.min(...input2.values) };
   }
 }
-Workflow52.prototype.scalarMin = CreateWorkflow51(ScalarMinTask);
+Workflow51.prototype.scalarMin = CreateWorkflow50(ScalarMinTask);
 // src/task/scalar/ScalarRoundTask.ts
-import { CreateWorkflow as CreateWorkflow52, Task as Task77, Workflow as Workflow53 } from "@workglow/task-graph";
-var inputSchema71 = {
+import { CreateWorkflow as CreateWorkflow51, Task as Task61, Workflow as Workflow52 } from "@workglow/task-graph";
+var inputSchema70 = {
   type: "object",
   properties: {
     value: {
@@ -14070,7 +14134,7 @@ var inputSchema71 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema70 = {
+var outputSchema69 = {
   type: "object",
   properties: {
     result: {
@@ -14083,25 +14147,25 @@ var outputSchema70 = {
   additionalProperties: false
 };
 
-class ScalarRoundTask extends Task77 {
+class ScalarRoundTask extends Task61 {
   static type = "ScalarRoundTask";
   static category = "Math";
   static title = "Round";
   static description = "Returns the value of a number rounded to the nearest integer";
   static inputSchema() {
-    return inputSchema71;
+    return inputSchema70;
   }
   static outputSchema() {
-    return outputSchema70;
+    return outputSchema69;
   }
   async execute(input2, _context) {
     return { result: Math.round(input2.value) };
   }
 }
-Workflow53.prototype.scalarRound = CreateWorkflow52(ScalarRoundTask);
+Workflow52.prototype.scalarRound = CreateWorkflow51(ScalarRoundTask);
 // src/task/scalar/ScalarTruncTask.ts
-import { CreateWorkflow as CreateWorkflow53, Task as Task78, Workflow as Workflow54 } from "@workglow/task-graph";
-var inputSchema72 = {
+import { CreateWorkflow as CreateWorkflow52, Task as Task62, Workflow as Workflow53 } from "@workglow/task-graph";
+var inputSchema71 = {
   type: "object",
   properties: {
     value: {
@@ -14113,7 +14177,7 @@ var inputSchema72 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema71 = {
+var outputSchema70 = {
   type: "object",
   properties: {
     result: {
@@ -14126,25 +14190,25 @@ var outputSchema71 = {
   additionalProperties: false
 };
 
-class ScalarTruncTask extends Task78 {
+class ScalarTruncTask extends Task62 {
   static type = "ScalarTruncTask";
   static category = "Math";
   static title = "Truncate";
   static description = "Returns the integer part of a number by removing fractional digits";
   static inputSchema() {
-    return inputSchema72;
+    return inputSchema71;
   }
   static outputSchema() {
-    return outputSchema71;
+    return outputSchema70;
   }
   async execute(input2, _context) {
     return { result: Math.trunc(input2.value) };
   }
 }
-Workflow54.prototype.scalarTrunc = CreateWorkflow53(ScalarTruncTask);
+Workflow53.prototype.scalarTrunc = CreateWorkflow52(ScalarTruncTask);
 // src/task/SplitTask.ts
-import { CreateWorkflow as CreateWorkflow54, Task as Task79, Workflow as Workflow55 } from "@workglow/task-graph";
-var inputSchema73 = {
+import { CreateWorkflow as CreateWorkflow53, Task as Task63, Workflow as Workflow54 } from "@workglow/task-graph";
+var inputSchema72 = {
   type: "object",
   properties: {
     input: {
@@ -14154,7 +14218,7 @@ var inputSchema73 = {
   },
   additionalProperties: false
 };
-var outputSchema72 = {
+var outputSchema71 = {
   type: "object",
   properties: {},
   additionalProperties: true
@@ -14171,17 +14235,17 @@ function fanoutToIndexedOutputs(inputValue) {
   return output;
 }
 
-class SplitTask extends Task79 {
+class SplitTask extends Task63 {
   static type = "SplitTask";
   static category = "Utility";
   static title = "Split";
   static description = "Splits an array into individual outputs, creating one output per element";
   static cacheable = false;
   static inputSchema() {
-    return inputSchema73;
+    return inputSchema72;
   }
   static outputSchema() {
-    return outputSchema72;
+    return outputSchema71;
   }
   async execute(input2, _context) {
     return fanoutToIndexedOutputs(input2.input);
@@ -14194,22 +14258,22 @@ var split = (input2, config = {}) => {
   const task = new SplitTask(config);
   return task.run(input2);
 };
-Workflow55.prototype.split = CreateWorkflow54(SplitTask);
+Workflow54.prototype.split = CreateWorkflow53(SplitTask);
 // src/task/string/StringConcatTask.ts
 import {
-  CreateWorkflow as CreateWorkflow55,
-  Task as Task80,
-  Workflow as Workflow56
+  CreateWorkflow as CreateWorkflow54,
+  Task as Task64,
+  Workflow as Workflow55
 } from "@workglow/task-graph";
 function concatStrings(input2) {
   return Object.values(input2).join("");
 }
-var inputSchema74 = {
+var inputSchema73 = {
   type: "object",
   properties: {},
   additionalProperties: { type: "string" }
 };
-var outputSchema73 = {
+var outputSchema72 = {
   type: "object",
   properties: {
     text: {
@@ -14222,16 +14286,16 @@ var outputSchema73 = {
   additionalProperties: false
 };
 
-class StringConcatTask extends Task80 {
+class StringConcatTask extends Task64 {
   static type = "StringConcatTask";
   static category = "String";
   static title = "Concat";
   static description = "Concatenates all input strings";
   static inputSchema() {
-    return inputSchema74;
+    return inputSchema73;
   }
   static outputSchema() {
-    return outputSchema73;
+    return outputSchema72;
   }
   async execute(input2, _context) {
     return { text: concatStrings(input2) };
@@ -14240,17 +14304,17 @@ class StringConcatTask extends Task80 {
     return { text: concatStrings(input2) };
   }
 }
-Workflow56.prototype.stringConcat = CreateWorkflow55(StringConcatTask);
+Workflow55.prototype.stringConcat = CreateWorkflow54(StringConcatTask);
 // src/task/string/StringIncludesTask.ts
 import {
-  CreateWorkflow as CreateWorkflow56,
-  Task as Task81,
-  Workflow as Workflow57
+  CreateWorkflow as CreateWorkflow55,
+  Task as Task65,
+  Workflow as Workflow56
 } from "@workglow/task-graph";
 function stringIncludes(text, search) {
   return text.includes(search);
 }
-var inputSchema75 = {
+var inputSchema74 = {
   type: "object",
   properties: {
     text: {
@@ -14267,7 +14331,7 @@ var inputSchema75 = {
   required: ["text", "search"],
   additionalProperties: false
 };
-var outputSchema74 = {
+var outputSchema73 = {
   type: "object",
   properties: {
     included: {
@@ -14280,16 +14344,16 @@ var outputSchema74 = {
   additionalProperties: false
 };
 
-class StringIncludesTask extends Task81 {
+class StringIncludesTask extends Task65 {
   static type = "StringIncludesTask";
   static category = "String";
   static title = "Includes";
   static description = "Checks if a string contains a substring";
   static inputSchema() {
-    return inputSchema75;
+    return inputSchema74;
   }
   static outputSchema() {
-    return outputSchema74;
+    return outputSchema73;
   }
   async execute(input2, _context) {
     return { included: stringIncludes(input2.text, input2.search) };
@@ -14298,17 +14362,17 @@ class StringIncludesTask extends Task81 {
     return { included: stringIncludes(input2.text, input2.search) };
   }
 }
-Workflow57.prototype.stringIncludes = CreateWorkflow56(StringIncludesTask);
+Workflow56.prototype.stringIncludes = CreateWorkflow55(StringIncludesTask);
 // src/task/string/StringJoinTask.ts
 import {
-  CreateWorkflow as CreateWorkflow57,
-  Task as Task82,
-  Workflow as Workflow58
+  CreateWorkflow as CreateWorkflow56,
+  Task as Task66,
+  Workflow as Workflow57
 } from "@workglow/task-graph";
 function joinStrings(texts, separator) {
   return texts.join(separator ?? "");
 }
-var inputSchema76 = {
+var inputSchema75 = {
   type: "object",
   properties: {
     texts: {
@@ -14327,7 +14391,7 @@ var inputSchema76 = {
   required: ["texts"],
   additionalProperties: false
 };
-var outputSchema75 = {
+var outputSchema74 = {
   type: "object",
   properties: {
     text: {
@@ -14340,16 +14404,16 @@ var outputSchema75 = {
   additionalProperties: false
 };
 
-class StringJoinTask extends Task82 {
+class StringJoinTask extends Task66 {
   static type = "StringJoinTask";
   static category = "String";
   static title = "Join";
   static description = "Joins an array of strings with a separator";
   static inputSchema() {
-    return inputSchema76;
+    return inputSchema75;
   }
   static outputSchema() {
-    return outputSchema75;
+    return outputSchema74;
   }
   async execute(input2, _context) {
     return { text: joinStrings(input2.texts, input2.separator) };
@@ -14358,17 +14422,17 @@ class StringJoinTask extends Task82 {
     return { text: joinStrings(input2.texts, input2.separator) };
   }
 }
-Workflow58.prototype.stringJoin = CreateWorkflow57(StringJoinTask);
+Workflow57.prototype.stringJoin = CreateWorkflow56(StringJoinTask);
 // src/task/string/StringLengthTask.ts
 import {
-  CreateWorkflow as CreateWorkflow58,
-  Task as Task83,
-  Workflow as Workflow59
+  CreateWorkflow as CreateWorkflow57,
+  Task as Task67,
+  Workflow as Workflow58
 } from "@workglow/task-graph";
 function stringLength(text) {
   return text.length;
 }
-var inputSchema77 = {
+var inputSchema76 = {
   type: "object",
   properties: {
     text: {
@@ -14380,7 +14444,7 @@ var inputSchema77 = {
   required: ["text"],
   additionalProperties: false
 };
-var outputSchema76 = {
+var outputSchema75 = {
   type: "object",
   properties: {
     length: {
@@ -14393,16 +14457,16 @@ var outputSchema76 = {
   additionalProperties: false
 };
 
-class StringLengthTask extends Task83 {
+class StringLengthTask extends Task67 {
   static type = "StringLengthTask";
   static category = "String";
   static title = "Length";
   static description = "Returns the length of a string";
   static inputSchema() {
-    return inputSchema77;
+    return inputSchema76;
   }
   static outputSchema() {
-    return outputSchema76;
+    return outputSchema75;
   }
   async execute(input2, _context) {
     return { length: stringLength(input2.text) };
@@ -14411,17 +14475,17 @@ class StringLengthTask extends Task83 {
     return { length: stringLength(input2.text) };
   }
 }
-Workflow59.prototype.stringLength = CreateWorkflow58(StringLengthTask);
+Workflow58.prototype.stringLength = CreateWorkflow57(StringLengthTask);
 // src/task/string/StringLowerCaseTask.ts
 import {
-  CreateWorkflow as CreateWorkflow59,
-  Task as Task84,
-  Workflow as Workflow60
+  CreateWorkflow as CreateWorkflow58,
+  Task as Task68,
+  Workflow as Workflow59
 } from "@workglow/task-graph";
 function toLowerCase(text) {
   return text.toLowerCase();
 }
-var inputSchema78 = {
+var inputSchema77 = {
   type: "object",
   properties: {
     text: {
@@ -14433,7 +14497,7 @@ var inputSchema78 = {
   required: ["text"],
   additionalProperties: false
 };
-var outputSchema77 = {
+var outputSchema76 = {
   type: "object",
   properties: {
     text: {
@@ -14446,16 +14510,16 @@ var outputSchema77 = {
   additionalProperties: false
 };
 
-class StringLowerCaseTask extends Task84 {
+class StringLowerCaseTask extends Task68 {
   static type = "StringLowerCaseTask";
   static category = "String";
   static title = "Lower Case";
   static description = "Converts a string to lower case";
   static inputSchema() {
-    return inputSchema78;
+    return inputSchema77;
   }
   static outputSchema() {
-    return outputSchema77;
+    return outputSchema76;
   }
   async execute(input2, _context) {
     return { text: toLowerCase(input2.text) };
@@ -14464,17 +14528,17 @@ class StringLowerCaseTask extends Task84 {
     return { text: toLowerCase(input2.text) };
   }
 }
-Workflow60.prototype.stringLowerCase = CreateWorkflow59(StringLowerCaseTask);
+Workflow59.prototype.stringLowerCase = CreateWorkflow58(StringLowerCaseTask);
 // src/task/string/StringReplaceTask.ts
 import {
-  CreateWorkflow as CreateWorkflow60,
-  Task as Task85,
-  Workflow as Workflow61
+  CreateWorkflow as CreateWorkflow59,
+  Task as Task69,
+  Workflow as Workflow60
 } from "@workglow/task-graph";
 function replaceString(text, search, replace) {
   return text.replaceAll(search, replace);
 }
-var inputSchema79 = {
+var inputSchema78 = {
   type: "object",
   properties: {
     text: {
@@ -14496,7 +14560,7 @@ var inputSchema79 = {
   required: ["text", "search", "replace"],
   additionalProperties: false
 };
-var outputSchema78 = {
+var outputSchema77 = {
   type: "object",
   properties: {
     text: {
@@ -14509,16 +14573,16 @@ var outputSchema78 = {
   additionalProperties: false
 };
 
-class StringReplaceTask extends Task85 {
+class StringReplaceTask extends Task69 {
   static type = "StringReplaceTask";
   static category = "String";
   static title = "Replace";
   static description = "Replaces all occurrences of a substring";
   static inputSchema() {
-    return inputSchema79;
+    return inputSchema78;
   }
   static outputSchema() {
-    return outputSchema78;
+    return outputSchema77;
   }
   async execute(input2, _context) {
     return { text: replaceString(input2.text, input2.search, input2.replace) };
@@ -14527,17 +14591,17 @@ class StringReplaceTask extends Task85 {
     return { text: replaceString(input2.text, input2.search, input2.replace) };
   }
 }
-Workflow61.prototype.stringReplace = CreateWorkflow60(StringReplaceTask);
+Workflow60.prototype.stringReplace = CreateWorkflow59(StringReplaceTask);
 // src/task/string/StringSliceTask.ts
 import {
-  CreateWorkflow as CreateWorkflow61,
-  Task as Task86,
-  Workflow as Workflow62
+  CreateWorkflow as CreateWorkflow60,
+  Task as Task70,
+  Workflow as Workflow61
 } from "@workglow/task-graph";
 function sliceString(text, start, end) {
   return text.slice(start, end);
 }
-var inputSchema80 = {
+var inputSchema79 = {
   type: "object",
   properties: {
     text: {
@@ -14559,7 +14623,7 @@ var inputSchema80 = {
   required: ["text", "start"],
   additionalProperties: false
 };
-var outputSchema79 = {
+var outputSchema78 = {
   type: "object",
   properties: {
     text: {
@@ -14572,16 +14636,16 @@ var outputSchema79 = {
   additionalProperties: false
 };
 
-class StringSliceTask extends Task86 {
+class StringSliceTask extends Task70 {
   static type = "StringSliceTask";
   static category = "String";
   static title = "Slice";
   static description = "Extracts a substring by start and optional end index";
   static inputSchema() {
-    return inputSchema80;
+    return inputSchema79;
   }
   static outputSchema() {
-    return outputSchema79;
+    return outputSchema78;
   }
   async execute(input2, _context) {
     return { text: sliceString(input2.text, input2.start, input2.end) };
@@ -14590,12 +14654,12 @@ class StringSliceTask extends Task86 {
     return { text: sliceString(input2.text, input2.start, input2.end) };
   }
 }
-Workflow62.prototype.stringSlice = CreateWorkflow61(StringSliceTask);
+Workflow61.prototype.stringSlice = CreateWorkflow60(StringSliceTask);
 // src/task/string/StringTemplateTask.ts
 import {
-  CreateWorkflow as CreateWorkflow62,
-  Task as Task87,
-  Workflow as Workflow63
+  CreateWorkflow as CreateWorkflow61,
+  Task as Task71,
+  Workflow as Workflow62
 } from "@workglow/task-graph";
 function renderStringTemplate(template, values) {
   let text = template;
@@ -14604,7 +14668,7 @@ function renderStringTemplate(template, values) {
   }
   return text;
 }
-var inputSchema81 = {
+var inputSchema80 = {
   type: "object",
   properties: {
     template: {
@@ -14622,7 +14686,7 @@ var inputSchema81 = {
   required: ["template", "values"],
   additionalProperties: false
 };
-var outputSchema80 = {
+var outputSchema79 = {
   type: "object",
   properties: {
     text: {
@@ -14635,16 +14699,16 @@ var outputSchema80 = {
   additionalProperties: false
 };
 
-class StringTemplateTask extends Task87 {
+class StringTemplateTask extends Task71 {
   static type = "StringTemplateTask";
   static category = "String";
   static title = "Template";
   static description = "Replaces {{key}} placeholders in a template string with values";
   static inputSchema() {
-    return inputSchema81;
+    return inputSchema80;
   }
   static outputSchema() {
-    return outputSchema80;
+    return outputSchema79;
   }
   async execute(input2, _context) {
     return { text: renderStringTemplate(input2.template, input2.values) };
@@ -14653,17 +14717,17 @@ class StringTemplateTask extends Task87 {
     return { text: renderStringTemplate(input2.template, input2.values) };
   }
 }
-Workflow63.prototype.stringTemplate = CreateWorkflow62(StringTemplateTask);
+Workflow62.prototype.stringTemplate = CreateWorkflow61(StringTemplateTask);
 // src/task/string/StringTrimTask.ts
 import {
-  CreateWorkflow as CreateWorkflow63,
-  Task as Task88,
-  Workflow as Workflow64
+  CreateWorkflow as CreateWorkflow62,
+  Task as Task72,
+  Workflow as Workflow63
 } from "@workglow/task-graph";
 function trimString(text) {
   return text.trim();
 }
-var inputSchema82 = {
+var inputSchema81 = {
   type: "object",
   properties: {
     text: {
@@ -14675,7 +14739,7 @@ var inputSchema82 = {
   required: ["text"],
   additionalProperties: false
 };
-var outputSchema81 = {
+var outputSchema80 = {
   type: "object",
   properties: {
     text: {
@@ -14688,16 +14752,16 @@ var outputSchema81 = {
   additionalProperties: false
 };
 
-class StringTrimTask extends Task88 {
+class StringTrimTask extends Task72 {
   static type = "StringTrimTask";
   static category = "String";
   static title = "Trim";
   static description = "Removes leading and trailing whitespace from a string";
   static inputSchema() {
-    return inputSchema82;
+    return inputSchema81;
   }
   static outputSchema() {
-    return outputSchema81;
+    return outputSchema80;
   }
   async execute(input2, _context) {
     return { text: trimString(input2.text) };
@@ -14706,17 +14770,17 @@ class StringTrimTask extends Task88 {
     return { text: trimString(input2.text) };
   }
 }
-Workflow64.prototype.stringTrim = CreateWorkflow63(StringTrimTask);
+Workflow63.prototype.stringTrim = CreateWorkflow62(StringTrimTask);
 // src/task/string/StringUpperCaseTask.ts
 import {
-  CreateWorkflow as CreateWorkflow64,
-  Task as Task89,
-  Workflow as Workflow65
+  CreateWorkflow as CreateWorkflow63,
+  Task as Task73,
+  Workflow as Workflow64
 } from "@workglow/task-graph";
 function toUpperCase(text) {
   return text.toUpperCase();
 }
-var inputSchema83 = {
+var inputSchema82 = {
   type: "object",
   properties: {
     text: {
@@ -14728,7 +14792,7 @@ var inputSchema83 = {
   required: ["text"],
   additionalProperties: false
 };
-var outputSchema82 = {
+var outputSchema81 = {
   type: "object",
   properties: {
     text: {
@@ -14741,16 +14805,16 @@ var outputSchema82 = {
   additionalProperties: false
 };
 
-class StringUpperCaseTask extends Task89 {
+class StringUpperCaseTask extends Task73 {
   static type = "StringUpperCaseTask";
   static category = "String";
   static title = "Upper Case";
   static description = "Converts a string to upper case";
   static inputSchema() {
-    return inputSchema83;
+    return inputSchema82;
   }
   static outputSchema() {
-    return outputSchema82;
+    return outputSchema81;
   }
   async execute(input2, _context) {
     return { text: toUpperCase(input2.text) };
@@ -14759,12 +14823,12 @@ class StringUpperCaseTask extends Task89 {
     return { text: toUpperCase(input2.text) };
   }
 }
-Workflow65.prototype.stringUpperCase = CreateWorkflow64(StringUpperCaseTask);
+Workflow64.prototype.stringUpperCase = CreateWorkflow63(StringUpperCaseTask);
 // src/task/TemplateTask.ts
 import {
-  CreateWorkflow as CreateWorkflow65,
-  Task as Task90,
-  Workflow as Workflow66
+  CreateWorkflow as CreateWorkflow64,
+  Task as Task74,
+  Workflow as Workflow65
 } from "@workglow/task-graph";
 function renderTemplate(template, values) {
   return template.replace(/\{\{([^{}]+)\}\}/g, (_match, expr) => {
@@ -14784,7 +14848,7 @@ function renderTemplate(template, values) {
     return defaultValue !== undefined ? defaultValue : "";
   });
 }
-var inputSchema84 = {
+var inputSchema83 = {
   type: "object",
   properties: {
     template: {
@@ -14802,7 +14866,7 @@ var inputSchema84 = {
   required: ["template", "values"],
   additionalProperties: false
 };
-var outputSchema83 = {
+var outputSchema82 = {
   type: "object",
   properties: {
     result: {
@@ -14815,16 +14879,16 @@ var outputSchema83 = {
   additionalProperties: false
 };
 
-class TemplateTask extends Task90 {
+class TemplateTask extends Task74 {
   static type = "TemplateTask";
   static category = "Utility";
   static title = "Template";
   static description = "Renders a template string with {{key}} placeholders and optional defaults";
   static inputSchema() {
-    return inputSchema84;
+    return inputSchema83;
   }
   static outputSchema() {
-    return outputSchema83;
+    return outputSchema82;
   }
   async execute(input2, _context) {
     return { result: renderTemplate(input2.template, input2.values) };
@@ -14833,13 +14897,13 @@ class TemplateTask extends Task90 {
     return { result: renderTemplate(input2.template, input2.values) };
   }
 }
-Workflow66.prototype.template = CreateWorkflow65(TemplateTask);
+Workflow65.prototype.template = CreateWorkflow64(TemplateTask);
 // src/task/vector/VectorDistanceTask.ts
-import { CreateWorkflow as CreateWorkflow66, Task as Task91, Workflow as Workflow67 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow65, Task as Task75, Workflow as Workflow66 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema5
 } from "@workglow/util/schema";
-var inputSchema85 = {
+var inputSchema84 = {
   type: "object",
   properties: {
     vectors: {
@@ -14855,7 +14919,7 @@ var inputSchema85 = {
   required: ["vectors"],
   additionalProperties: false
 };
-var outputSchema84 = {
+var outputSchema83 = {
   type: "object",
   properties: {
     result: {
@@ -14868,16 +14932,16 @@ var outputSchema84 = {
   additionalProperties: false
 };
 
-class VectorDistanceTask extends Task91 {
+class VectorDistanceTask extends Task75 {
   static type = "VectorDistanceTask";
   static category = "Vector";
   static title = "Distance";
   static description = "Returns the Euclidean distance between the first two vectors";
   static inputSchema() {
-    return inputSchema85;
+    return inputSchema84;
   }
   static outputSchema() {
-    return outputSchema84;
+    return outputSchema83;
   }
   async execute(input2, _context) {
     const { vectors } = input2;
@@ -14895,13 +14959,13 @@ class VectorDistanceTask extends Task91 {
     return { result: Math.sqrt(sumPrecise(diffs)) };
   }
 }
-Workflow67.prototype.vectorDistance = CreateWorkflow66(VectorDistanceTask);
+Workflow66.prototype.vectorDistance = CreateWorkflow65(VectorDistanceTask);
 // src/task/vector/VectorDotProductTask.ts
-import { CreateWorkflow as CreateWorkflow67, Task as Task92, Workflow as Workflow68 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow66, Task as Task76, Workflow as Workflow67 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema6
 } from "@workglow/util/schema";
-var inputSchema86 = {
+var inputSchema85 = {
   type: "object",
   properties: {
     vectors: {
@@ -14917,7 +14981,7 @@ var inputSchema86 = {
   required: ["vectors"],
   additionalProperties: false
 };
-var outputSchema85 = {
+var outputSchema84 = {
   type: "object",
   properties: {
     result: {
@@ -14930,16 +14994,16 @@ var outputSchema85 = {
   additionalProperties: false
 };
 
-class VectorDotProductTask extends Task92 {
+class VectorDotProductTask extends Task76 {
   static type = "VectorDotProductTask";
   static category = "Vector";
   static title = "Dot Product";
   static description = "Returns the dot (inner) product of the first two vectors";
   static inputSchema() {
-    return inputSchema86;
+    return inputSchema85;
   }
   static outputSchema() {
-    return outputSchema85;
+    return outputSchema84;
   }
   async execute(input2, _context) {
     const { vectors } = input2;
@@ -14954,14 +15018,14 @@ class VectorDotProductTask extends Task92 {
     return { result: sumPrecise(products) };
   }
 }
-Workflow68.prototype.vectorDotProduct = CreateWorkflow67(VectorDotProductTask);
+Workflow67.prototype.vectorDotProduct = CreateWorkflow66(VectorDotProductTask);
 // src/task/vector/VectorNormalizeTask.ts
-import { CreateWorkflow as CreateWorkflow68, Task as Task93, Workflow as Workflow69 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow67, Task as Task77, Workflow as Workflow68 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema7,
   normalize
 } from "@workglow/util/schema";
-var inputSchema87 = {
+var inputSchema86 = {
   type: "object",
   properties: {
     vector: TypedArraySchema7({
@@ -14972,7 +15036,7 @@ var inputSchema87 = {
   required: ["vector"],
   additionalProperties: false
 };
-var outputSchema86 = {
+var outputSchema85 = {
   type: "object",
   properties: {
     result: TypedArraySchema7({
@@ -14984,29 +15048,29 @@ var outputSchema86 = {
   additionalProperties: false
 };
 
-class VectorNormalizeTask extends Task93 {
+class VectorNormalizeTask extends Task77 {
   static type = "VectorNormalizeTask";
   static category = "Vector";
   static title = "Normalize";
   static description = "Returns the L2-normalized (unit length) vector";
   static inputSchema() {
-    return inputSchema87;
+    return inputSchema86;
   }
   static outputSchema() {
-    return outputSchema86;
+    return outputSchema85;
   }
   async execute(input2, _context) {
     return { result: normalize(input2.vector) };
   }
 }
-Workflow69.prototype.vectorNormalize = CreateWorkflow68(VectorNormalizeTask);
+Workflow68.prototype.vectorNormalize = CreateWorkflow67(VectorNormalizeTask);
 // src/task/vector/VectorScaleTask.ts
-import { CreateWorkflow as CreateWorkflow69, Task as Task94, Workflow as Workflow70 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow68, Task as Task78, Workflow as Workflow69 } from "@workglow/task-graph";
 import {
   createTypedArrayFrom as createTypedArrayFrom5,
   TypedArraySchema as TypedArraySchema8
 } from "@workglow/util/schema";
-var inputSchema88 = {
+var inputSchema87 = {
   type: "object",
   properties: {
     vector: TypedArraySchema8({
@@ -15022,7 +15086,7 @@ var inputSchema88 = {
   required: ["vector", "scalar"],
   additionalProperties: false
 };
-var outputSchema87 = {
+var outputSchema86 = {
   type: "object",
   properties: {
     result: TypedArraySchema8({
@@ -15034,16 +15098,16 @@ var outputSchema87 = {
   additionalProperties: false
 };
 
-class VectorScaleTask extends Task94 {
+class VectorScaleTask extends Task78 {
   static type = "VectorScaleTask";
   static category = "Vector";
   static title = "Scale";
   static description = "Multiplies each element of a vector by a scalar";
   static inputSchema() {
-    return inputSchema88;
+    return inputSchema87;
   }
   static outputSchema() {
-    return outputSchema87;
+    return outputSchema86;
   }
   async execute(input2, _context) {
     const { vector, scalar } = input2;
@@ -15051,7 +15115,7 @@ class VectorScaleTask extends Task94 {
     return { result: createTypedArrayFrom5([vector], values) };
   }
 }
-Workflow70.prototype.vectorScale = CreateWorkflow69(VectorScaleTask);
+Workflow69.prototype.vectorScale = CreateWorkflow68(VectorScaleTask);
 
 // src/common.ts
 import { TaskRegistry as TaskRegistry2 } from "@workglow/task-graph";
@@ -15152,7 +15216,6 @@ var registerCommonTasks = () => {
     ImageBorderTask,
     ImageTransparencyTask,
     ImageBlurTask,
-    ImageWatermarkTask,
     ImagePixelateTask,
     ImageInvertTask,
     ImageBrightnessTask,
@@ -15169,18 +15232,18 @@ var registerCommonTasks = () => {
 };
 // src/task/FileLoaderTask.server.ts
 import {
-  CreateWorkflow as CreateWorkflow71,
+  CreateWorkflow as CreateWorkflow70,
   TaskAbortedError as TaskAbortedError5,
-  Workflow as Workflow72
+  Workflow as Workflow71
 } from "@workglow/task-graph";
 import { readFile } from "node:fs/promises";
 
 // src/task/FileLoaderTask.ts
 import {
-  CreateWorkflow as CreateWorkflow70,
-  Task as Task95,
+  CreateWorkflow as CreateWorkflow69,
+  Task as Task79,
   TaskAbortedError as TaskAbortedError4,
-  Workflow as Workflow71
+  Workflow as Workflow70
 } from "@workglow/task-graph";
 var _papaParse;
 async function getPapaParse() {
@@ -15194,7 +15257,7 @@ async function getPapaParse() {
   }
   return _papaParse;
 }
-var inputSchema89 = {
+var inputSchema88 = {
   type: "object",
   properties: {
     url: {
@@ -15214,7 +15277,7 @@ var inputSchema89 = {
   required: ["url"],
   additionalProperties: false
 };
-var outputSchema88 = {
+var outputSchema87 = {
   type: "object",
   properties: {
     text: {
@@ -15265,17 +15328,17 @@ var outputSchema88 = {
   additionalProperties: false
 };
 
-class FileLoaderTask extends Task95 {
+class FileLoaderTask extends Task79 {
   static type = "FileLoaderTask";
   static category = "Document";
   static title = "File Loader";
   static description = "Load documents from URLs (http://, https://)";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema89;
+    return inputSchema88;
   }
   static outputSchema() {
-    return outputSchema88;
+    return outputSchema87;
   }
   async execute(input2, context) {
     const { url, format = "auto" } = input2;
@@ -15628,7 +15691,7 @@ class FileLoaderTask extends Task95 {
     });
   }
 }
-Workflow71.prototype.fileLoader = CreateWorkflow70(FileLoaderTask);
+Workflow70.prototype.fileLoader = CreateWorkflow69(FileLoaderTask);
 
 // src/task/FileLoaderTask.server.ts
 class FileLoaderTask2 extends FileLoaderTask {
@@ -15817,7 +15880,7 @@ class FileLoaderTask2 extends FileLoaderTask {
 var fileLoader = (input2, config) => {
   return new FileLoaderTask2(config).run(input2);
 };
-Workflow72.prototype.fileLoader = CreateWorkflow71(FileLoaderTask2);
+Workflow71.prototype.fileLoader = CreateWorkflow70(FileLoaderTask2);
 // src/task/browser-control/ElectronBackend.ts
 import { sleep as sleep3 } from "@workglow/util";
 var electronModule = null;
@@ -16587,9 +16650,9 @@ export {
   registerMcpTaskDeps,
   registerMcpServer,
   registerImageRasterCodec2 as registerImageRasterCodec,
+  registerFilterOp31 as registerFilterOp,
   registerCommonTasks2 as registerCommonTasks,
   registerBrowserDeps,
-  produceImageOutput,
   normalizeOutputMimeType,
   merge,
   mcpTransportTypes,
@@ -16607,11 +16670,12 @@ export {
   lambda,
   json,
   javaScript,
+  hasFilterOp2 as hasFilterOp,
   getSafeFetchImpl,
   getMcpTaskDeps,
   getMcpServerConfig,
   getMcpServer,
-  getImageRasterCodec2 as getImageRasterCodec,
+  getImageRasterCodec,
   getGlobalMcpServers,
   getGlobalMcpServerRepository,
   getBrowserDeps,
@@ -16628,6 +16692,8 @@ export {
   assertWithinPixelBudget,
   assertWithinByteBudget,
   assertIsDataUri,
+  applyFilter3 as applyFilter,
+  _resetFilterRegistryForTests,
   VectorSumTask,
   VectorSubtractTask,
   VectorScaleTask,
@@ -16689,7 +16755,6 @@ export {
   JavaScriptTask,
   InputTask,
   InMemoryMcpServerRepository,
-  ImageWatermarkTask,
   ImageTransparencyTask,
   ImageTintTask,
   ImageThresholdTask,
@@ -16702,14 +16767,12 @@ export {
   ImageInvertTask,
   ImageGrayscaleTask,
   ImageFlipTask,
+  ImageFilterTask,
   ImageCropTask,
   ImageContrastTask,
   ImageBrightnessTask,
   ImageBorderTask,
   ImageBlurTask,
-  ImageBinarySchemaOptions,
-  ImageBinarySchema,
-  ImageBinaryOrDataUriSchema,
   HumanInputTask,
   HumanApprovalTask,
   HexColorSchema,
@@ -16720,6 +16783,7 @@ export {
   DelayTask,
   DebugLogTask,
   DateFormatTask,
+  CssRgbColorSchema,
   CredentialStoreOAuthProvider,
   ColorValueSchema,
   ColorSchema,
@@ -16757,4 +16821,4 @@ export {
   ArrayTask
 };
 
-//# debugId=A0F5730670C6AF6364756E2164756E21
+//# debugId=71F58D454DFC36C464756E2164756E21