@workglow/tasks 0.2.17 → 0.2.18

package/dist/browser.js

@@ -12,7 +12,7 @@ import { registerImageRasterCodec } 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",
@@ -176,6 +176,890 @@ function createBrowserImageRasterCodec() {
 // src/task/image/registerImageRasterCodec.browser.ts
 registerImageRasterCodec(createBrowserImageRasterCodec());
 
+// 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.webgpu.ts
+import { registerFilterOp as registerFilterOp17, VERTEX_PRELUDE } from "@workglow/util/media";
+var SHADER_SRC = `${VERTEX_PRELUDE}
+struct U { radius: u32, direction: u32, width: f32, height: f32 };
+@group(0) @binding(2) var<uniform> u: U;
+
+@fragment
+fn fs(in: VsOut) -> @location(0) vec4f {
+  let r = i32(u.radius);
+  var sum = vec4f(0.0);
+  let texel = vec2f(1.0 / u.width, 1.0 / u.height);
+  // direction: 0 = horizontal, 1 = vertical.
+  let dir = select(vec2f(0.0, texel.y), vec2f(texel.x, 0.0), u.direction == 0u);
+  for (var k: i32 = -r; k <= r; k = k + 1) {
+    let uv = clamp(in.uv + dir * f32(k), vec2f(0.0), vec2f(1.0));
+    sum = sum + textureSample(src, src_sampler, uv);
+  }
+  let n = f32(2 * r + 1);
+  return sum / n;
+}
+`;
+function makeUniforms(radius, direction, width, height) {
+  const buf = new ArrayBuffer(16);
+  const u = new Uint32Array(buf, 0, 2);
+  u[0] = Math.max(1, radius | 0);
+  u[1] = direction;
+  const f = new Float32Array(buf, 8, 2);
+  f[0] = width;
+  f[1] = height;
+  return buf;
+}
+registerFilterOp17("webgpu", "blur", (image, { radius }) => {
+  const w = image.width;
+  const h = image.height;
+  const horiz = image.apply({
+    shader: SHADER_SRC,
+    uniforms: makeUniforms(radius, 0, w, h)
+  });
+  const vert = horiz.apply({ shader: SHADER_SRC, uniforms: makeUniforms(radius, 1, w, h) });
+  horiz.release();
+  return vert;
+});
+
+// src/task/image/border/border.webgpu.ts
+import { VERTEX_PRELUDE as VERTEX_PRELUDE2, registerFilterOp as registerFilterOp18, resolveColor as resolveColor3 } from "@workglow/util/media";
+var SHADER_SRC2 = `${VERTEX_PRELUDE2}
+struct U { color: vec4f, borderWidth: f32, srcWidth: f32, srcHeight: f32, _pad: f32 };
+@group(0) @binding(2) var<uniform> u: U;
+
+@fragment
+fn fs(in: VsOut) -> @location(0) vec4f {
+  let outW = u.srcWidth + 2.0 * u.borderWidth;
+  let outH = u.srcHeight + 2.0 * u.borderWidth;
+  let px = in.uv.x * outW;
+  let py = in.uv.y * outH;
+  let inside = px >= u.borderWidth && px < (u.borderWidth + u.srcWidth)
+            && py >= u.borderWidth && py < (u.borderWidth + u.srcHeight);
+  if (!inside) {
+    return u.color;
+  }
+  let sx = (px - u.borderWidth) / u.srcWidth;
+  let sy = (py - u.borderWidth) / u.srcHeight;
+  return textureSample(src, src_sampler, vec2f(sx, sy));
+}
+`;
+registerFilterOp18("webgpu", "border", (image, { borderWidth, color }) => {
+  const w = image.width;
+  const h = image.height;
+  const c = resolveColor3(color);
+  const buf = new ArrayBuffer(32);
+  const f = new Float32Array(buf);
+  f[0] = c.r / 255;
+  f[1] = c.g / 255;
+  f[2] = c.b / 255;
+  f[3] = c.a / 255;
+  f[4] = borderWidth;
+  f[5] = w;
+  f[6] = h;
+  return image.apply({
+    shader: SHADER_SRC2,
+    uniforms: buf,
+    outSize: { width: w + 2 * borderWidth, height: h + 2 * borderWidth }
+  });
+});
+
+// src/task/image/brightness/brightness.webgpu.ts
+import { registerFilterOp as registerFilterOp19, VERTEX_PRELUDE as VERTEX_PRELUDE3 } from "@workglow/util/media";
+var SHADER_SRC3 = `${VERTEX_PRELUDE3}
+struct U { amount: f32 };
+@group(0) @binding(2) var<uniform> u: U;
+
+@fragment
+fn fs(in: VsOut) -> @location(0) vec4f {
+  let s = textureSample(src, src_sampler, in.uv);
+  let d = u.amount / 255.0;
+  return vec4f(clamp(s.rgb + vec3f(d), vec3f(0.0), vec3f(1.0)), s.a);
+}
+`;
+registerFilterOp19("webgpu", "brightness", (image, { amount }) => {
+  const buf = new ArrayBuffer(16);
+  new Float32Array(buf, 0, 1)[0] = amount;
+  return image.apply({ shader: SHADER_SRC3, uniforms: buf });
+});
+
+// src/task/image/contrast/contrast.webgpu.ts
+import { registerFilterOp as registerFilterOp20, VERTEX_PRELUDE as VERTEX_PRELUDE4 } from "@workglow/util/media";
+var SHADER_SRC4 = `${VERTEX_PRELUDE4}
+struct U { amount: f32 };
+@group(0) @binding(2) var<uniform> u: U;
+
+@fragment
+fn fs(in: VsOut) -> @location(0) vec4f {
+  let s = textureSample(src, src_sampler, in.uv);
+  // Standard "GIMP" contrast curve, matching cpuContrast.
+  let factor = (259.0 * (u.amount + 255.0)) / (255.0 * (259.0 - u.amount));
+  let rgb = factor * (s.rgb - vec3f(0.5)) + vec3f(0.5);
+  return vec4f(clamp(rgb, vec3f(0.0), vec3f(1.0)), s.a);
+}
+`;
+registerFilterOp20("webgpu", "contrast", (image, { amount }) => {
+  const buf = new ArrayBuffer(16);
+  new Float32Array(buf, 0, 1)[0] = amount;
+  return image.apply({ shader: SHADER_SRC4, uniforms: buf });
+});
+
+// src/task/image/crop/crop.webgpu.ts
+import { registerFilterOp as registerFilterOp21, VERTEX_PRELUDE as VERTEX_PRELUDE5 } from "@workglow/util/media";
+var SHADER_SRC5 = `${VERTEX_PRELUDE5}
+struct U { left: f32, top: f32, srcWidth: f32, srcHeight: f32, outWidth: f32, outHeight: f32 };
+@group(0) @binding(2) var<uniform> u: U;
+
+@fragment
+fn fs(in: VsOut) -> @location(0) vec4f {
+  let px = u.left + in.uv.x * u.outWidth;
+  let py = u.top + in.uv.y * u.outHeight;
+  let uv = vec2f(px / u.srcWidth, py / u.srcHeight);
+  return textureSample(src, src_sampler, uv);
+}
+`;
+registerFilterOp21("webgpu", "crop", (image, { left, top, width, height }) => {
+  const w = image.width;
+  const h = image.height;
+  const buf = new ArrayBuffer(32);
+  const f = new Float32Array(buf);
+  f[0] = left;
+  f[1] = top;
+  f[2] = w;
+  f[3] = h;
+  f[4] = width;
+  f[5] = height;
+  return image.apply({
+    shader: SHADER_SRC5,
+    uniforms: buf,
+    outSize: { width, height }
+  });
+});
+
+// src/task/image/flip/flip.webgpu.ts
+import { registerFilterOp as registerFilterOp22, VERTEX_PRELUDE as VERTEX_PRELUDE6 } from "@workglow/util/media";
+var SHADER_SRC6 = `${VERTEX_PRELUDE6}
+struct U { direction: u32 };
+@group(0) @binding(2) var<uniform> u: U;
+
+@fragment
+fn fs(in: VsOut) -> @location(0) vec4f {
+  // direction: 0 = horizontal (flip x), 1 = vertical (flip y).
+  let flipX = u.direction == 0u;
+  let flipY = u.direction == 1u;
+  let uv = vec2f(
+    select(in.uv.x, 1.0 - in.uv.x, flipX),
+    select(in.uv.y, 1.0 - in.uv.y, flipY),
+  );
+  return textureSample(src, src_sampler, uv);
+}
+`;
+var DIRECTION_TO_CODE = { horizontal: 0, vertical: 1 };
+registerFilterOp22("webgpu", "flip", (image, { direction }) => {
+  const buf = new ArrayBuffer(16);
+  new Uint32Array(buf, 0, 1)[0] = DIRECTION_TO_CODE[direction];
+  return image.apply({ shader: SHADER_SRC6, uniforms: buf });
+});
+
+// src/task/image/grayscale/grayscale.webgpu.ts
+import { registerFilterOp as registerFilterOp23, VERTEX_PRELUDE as VERTEX_PRELUDE7 } from "@workglow/util/media";
+var SHADER_SRC7 = `${VERTEX_PRELUDE7}
+@fragment
+fn fs(in: VsOut) -> @location(0) vec4f {
+  let s = textureSample(src, src_sampler, in.uv);
+  // Match cpuGrayscale's BT.601-ish (77,150,29)/256 weights.
+  let g = (s.r * 77.0 + s.g * 150.0 + s.b * 29.0) / 256.0;
+  return vec4f(g, g, g, s.a);
+}
+`;
+registerFilterOp23("webgpu", "grayscale", (image, _params) => {
+  return image.apply({ shader: SHADER_SRC7, uniforms: undefined });
+});
+
+// src/task/image/invert/invert.webgpu.ts
+import { registerFilterOp as registerFilterOp24, VERTEX_PRELUDE as VERTEX_PRELUDE8 } from "@workglow/util/media";
+var SHADER_SRC8 = `${VERTEX_PRELUDE8}
+@fragment
+fn fs(in: VsOut) -> @location(0) vec4f {
+  let s = textureSample(src, src_sampler, in.uv);
+  return vec4f(1.0 - s.rgb, s.a);
+}
+`;
+registerFilterOp24("webgpu", "invert", (image, _params) => {
+  return image.apply({ shader: SHADER_SRC8, uniforms: undefined });
+});
+
+// src/task/image/pixelate/pixelate.webgpu.ts
+import { registerFilterOp as registerFilterOp25, VERTEX_PRELUDE as VERTEX_PRELUDE9 } from "@workglow/util/media";
+var SHADER_SRC9 = `${VERTEX_PRELUDE9}
+struct U { blockSize: u32, width: u32, height: u32, _pad: u32 };
+@group(0) @binding(2) var<uniform> u: U;
+
+@fragment
+fn fs(in: VsOut) -> @location(0) vec4f {
+  let px = u32(in.uv.x * f32(u.width));
+  let py = u32(in.uv.y * f32(u.height));
+  let bx = px / u.blockSize;
+  let by = py / u.blockSize;
+  let startX = bx * u.blockSize;
+  let startY = by * u.blockSize;
+  let endX = min(startX + u.blockSize, u.width);
+  let endY = min(startY + u.blockSize, u.height);
+
+  let invW = 1.0 / f32(u.width);
+  let invH = 1.0 / f32(u.height);
+
+  var sum = vec4f(0.0);
+  var count: f32 = 0.0;
+  for (var sy: u32 = startY; sy < endY; sy = sy + 1u) {
+    for (var sx: u32 = startX; sx < endX; sx = sx + 1u) {
+      // Sample at exact texel center. With a linear sampler, the bilinear
+      // weight collapses to 1.0 on this texel, giving a lossless read.
+      let suv = vec2f((f32(sx) + 0.5) * invW, (f32(sy) + 0.5) * invH);
+      sum = sum + textureSampleLevel(src, src_sampler, suv, 0.0);
+      count = count + 1.0;
+    }
+  }
+  return sum / count;
+}
+`;
+registerFilterOp25("webgpu", "pixelate", (image, { blockSize }) => {
+  const w = image.width;
+  const h = image.height;
+  const buf = new ArrayBuffer(16);
+  const u = new Uint32Array(buf);
+  u[0] = Math.max(1, blockSize | 0);
+  u[1] = w;
+  u[2] = h;
+  return image.apply({ shader: SHADER_SRC9, uniforms: buf });
+});
+
+// src/task/image/posterize/posterize.webgpu.ts
+import { registerFilterOp as registerFilterOp26, VERTEX_PRELUDE as VERTEX_PRELUDE10 } from "@workglow/util/media";
+var SHADER_SRC10 = `${VERTEX_PRELUDE10}
+struct U { levels: f32 };
+@group(0) @binding(2) var<uniform> u: U;
+
+@fragment
+fn fs(in: VsOut) -> @location(0) vec4f {
+  let s = textureSample(src, src_sampler, in.uv);
+  let n = max(u.levels, 2.0);
+  // Round-to-nearest quantization, matching cpuPosterize's LUT semantics.
+  let q = round(s.rgb * (n - 1.0)) / (n - 1.0);
+  return vec4f(clamp(q, vec3f(0.0), vec3f(1.0)), s.a);
+}
+`;
+registerFilterOp26("webgpu", "posterize", (image, { levels }) => {
+  const buf = new ArrayBuffer(16);
+  new Float32Array(buf, 0, 1)[0] = levels;
+  return image.apply({ shader: SHADER_SRC10, uniforms: buf });
+});
+
+// src/task/image/resize/resize.webgpu.ts
+import { registerFilterOp as registerFilterOp27, VERTEX_PRELUDE as VERTEX_PRELUDE11 } from "@workglow/util/media";
+var SHADER_SRC11 = `${VERTEX_PRELUDE11}
+@fragment
+fn fs(in: VsOut) -> @location(0) vec4f {
+  return textureSample(src, src_sampler, in.uv);
+}
+`;
+registerFilterOp27("webgpu", "resize", (image, { width, height }) => {
+  return image.apply({
+    shader: SHADER_SRC11,
+    uniforms: undefined,
+    outSize: { width, height }
+  });
+});
+
+// src/task/image/rotate/rotate.webgpu.ts
+import { registerFilterOp as registerFilterOp28, VERTEX_PRELUDE as VERTEX_PRELUDE12 } from "@workglow/util/media";
+var SHADER_SRC12 = `${VERTEX_PRELUDE12}
+struct U { angle: u32 };
+@group(0) @binding(2) var<uniform> u: U;
+
+@fragment
+fn fs(in: VsOut) -> @location(0) vec4f {
+  // Map output uv back to source uv via inverse rotation.
+  var srcUv = in.uv;
+  if (u.angle == 90u) {
+    srcUv = vec2f(in.uv.y, 1.0 - in.uv.x);
+  } else if (u.angle == 180u) {
+    srcUv = vec2f(1.0 - in.uv.x, 1.0 - in.uv.y);
+  } else if (u.angle == 270u) {
+    srcUv = vec2f(1.0 - in.uv.y, in.uv.x);
+  }
+  return textureSample(src, src_sampler, srcUv);
+}
+`;
+registerFilterOp28("webgpu", "rotate", (image, { angle }) => {
+  const w = image.width;
+  const h = image.height;
+  const swap = angle === 90 || angle === 270;
+  const buf = new ArrayBuffer(16);
+  new Uint32Array(buf, 0, 1)[0] = angle;
+  return image.apply({
+    shader: SHADER_SRC12,
+    uniforms: buf,
+    outSize: { width: swap ? h : w, height: swap ? w : h }
+  });
+});
+
+// src/task/image/sepia/sepia.webgpu.ts
+import { registerFilterOp as registerFilterOp29, VERTEX_PRELUDE as VERTEX_PRELUDE13 } from "@workglow/util/media";
+var SHADER_SRC13 = `${VERTEX_PRELUDE13}
+@fragment
+fn fs(in: VsOut) -> @location(0) vec4f {
+  let s = textureSample(src, src_sampler, in.uv);
+  let r = s.r * 0.393 + s.g * 0.769 + s.b * 0.189;
+  let g = s.r * 0.349 + s.g * 0.686 + s.b * 0.168;
+  let b = s.r * 0.272 + s.g * 0.534 + s.b * 0.131;
+  return vec4f(clamp(r, 0.0, 1.0), clamp(g, 0.0, 1.0), clamp(b, 0.0, 1.0), s.a);
+}
+`;
+registerFilterOp29("webgpu", "sepia", (image, _params) => {
+  return image.apply({ shader: SHADER_SRC13, uniforms: undefined });
+});
+
+// src/task/image/threshold/threshold.webgpu.ts
+import { registerFilterOp as registerFilterOp30, VERTEX_PRELUDE as VERTEX_PRELUDE14 } from "@workglow/util/media";
+var SHADER_SRC14 = `${VERTEX_PRELUDE14}
+struct U { value: f32 };
+@group(0) @binding(2) var<uniform> u: U;
+
+@fragment
+fn fs(in: VsOut) -> @location(0) vec4f {
+  let s = textureSample(src, src_sampler, in.uv);
+  let v = u.value / 255.0;
+  // Per-channel binary threshold to match cpuThreshold (each of R/G/B
+  // compared independently); alpha preserved.
+  let r = select(0.0, 1.0, s.r >= v);
+  let g = select(0.0, 1.0, s.g >= v);
+  let b = select(0.0, 1.0, s.b >= v);
+  return vec4f(r, g, b, s.a);
+}
+`;
+registerFilterOp30("webgpu", "threshold", (image, { value }) => {
+  const buf = new ArrayBuffer(16);
+  new Float32Array(buf, 0, 1)[0] = value;
+  return image.apply({ shader: SHADER_SRC14, uniforms: buf });
+});
+
+// src/task/image/tint/tint.webgpu.ts
+import { VERTEX_PRELUDE as VERTEX_PRELUDE15, registerFilterOp as registerFilterOp31, resolveColor as resolveColor4 } from "@workglow/util/media";
+var SHADER_SRC15 = `${VERTEX_PRELUDE15}
+struct U { color: vec4f, amount: f32 };
+@group(0) @binding(2) var<uniform> u: U;
+
+@fragment
+fn fs(in: VsOut) -> @location(0) vec4f {
+  let s = textureSample(src, src_sampler, in.uv);
+  let tinted = mix(s.rgb, u.color.rgb, u.amount);
+  return vec4f(clamp(tinted, vec3f(0.0), vec3f(1.0)), s.a);
+}
+`;
+registerFilterOp31("webgpu", "tint", (image, { color, amount }) => {
+  const c = resolveColor4(color);
+  const buf = new ArrayBuffer(32);
+  const f = new Float32Array(buf);
+  f[0] = c.r / 255;
+  f[1] = c.g / 255;
+  f[2] = c.b / 255;
+  f[3] = 1;
+  f[4] = amount;
+  return image.apply({ shader: SHADER_SRC15, uniforms: buf });
+});
+
+// src/task/image/transparency/transparency.webgpu.ts
+import { registerFilterOp as registerFilterOp32, VERTEX_PRELUDE as VERTEX_PRELUDE16 } from "@workglow/util/media";
+var SHADER_SRC16 = `${VERTEX_PRELUDE16}
+struct U { amount: f32 };
+@group(0) @binding(2) var<uniform> u: U;
+
+@fragment
+fn fs(in: VsOut) -> @location(0) vec4f {
+  let s = textureSample(src, src_sampler, in.uv);
+  return vec4f(s.rgb, s.a * u.amount);
+}
+`;
+registerFilterOp32("webgpu", "transparency", (image, { amount }) => {
+  const buf = new ArrayBuffer(16);
+  new Float32Array(buf, 0, 1)[0] = amount;
+  return image.apply({ shader: SHADER_SRC16, uniforms: buf });
+});
+
+// src/codec.browser.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 = [
@@ -5762,197 +6646,118 @@ ${input.prompt}` : input.prompt : this.config.message ?? "";
   }
 }
 Workflow16.prototype.humanInput = CreateWorkflow15(HumanInputTask);
-// src/task/image/ImageBlurTask.ts
+
+// src/common.ts
 import {
-  CreateWorkflow as CreateWorkflow16,
-  Task as Task42,
-  Workflow as Workflow17
-} from "@workglow/task-graph";
+  registerFilterOp as registerFilterOp33,
+  applyFilter as applyFilter3,
+  hasFilterOp as hasFilterOp2,
+  _resetFilterRegistryForTests
+} 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
-    }
-  ]
-};
-var ImageBinarySchema = (annotations = {}) => ({
+// src/task/image/ImageFilterTask.ts
+import {
+  Task as Task42
+} from "@workglow/task-graph";
+import {
+  applyFilter as applyFilter2,
+  CpuImage as CpuImage17,
+  GpuImageFactory,
+  getGpuImageFactory,
+  hasFilterOp,
+  previewSource
+} from "@workglow/util/media";
+
+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;
+    }
+    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",
-      minimum: 1,
-      title: "Width",
-      description: "Width in pixels"
-    },
-    height: {
-      type: "integer",
+    image: GpuImageSchema({ title: "Image", description: "Source image" }),
+    radius: {
+      type: "number",
+      title: "Radius",
+      description: "Blur radius (1-10)",
       minimum: 1,
-      title: "Height",
-      description: "Height in pixels"
-    },
-    channels: {
-      type: "integer",
-      enum: [1, 3, 4],
-      title: "Channels",
-      description: "1 (gray), 3 (RGB), or 4 (RGBA)"
+      maximum: 10,
+      default: 1
     }
   },
-  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"],
+  additionalProperties: false
+};
+var outputSchema40 = {
   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: GpuImageSchema({ title: "Image", description: "Blurred image" }) },
   required: ["image"],
   additionalProperties: false
 };
 
-class ImageBlurTask extends Task42 {
+class ImageBlurTask extends ImageFilterTask {
   static type = "ImageBlurTask";
   static category = "Image";
   static title = "Blur Image";
@@ -5963,80 +6768,60 @@ class ImageBlurTask extends Task42 {
   static outputSchema() {
     return outputSchema40;
   }
-  async execute(input, _context) {
-    return await applyBlur(input);
+  filterName = "blur";
+  opParams(input) {
+    return { radius: input.radius ?? 1 };
   }
-  async executePreview(input, _context) {
-    return await applyBlur(input);
+  scalePreviewParams({ radius }, s) {
+    return { radius: Math.max(1, Math.round(radius * s)) };
   }
 }
 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 };
-}
+// 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: ImageBinaryOrDataUriSchema({ title: "Image", description: "Source image" }),
+    image: GpuImageSchema2({ title: "Image", description: "Source image" }),
     borderWidth: {
       type: "integer",
       title: "Border Width",
       description: "Border width in pixels",
       minimum: 1,
-      default: 1
+      default: 10
     },
-    color: ColorValueSchema({ title: "Color", description: "Border color" })
+    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"
+    }
   },
   required: ["image", "color"],
   additionalProperties: false
 };
 var outputSchema41 = {
   type: "object",
-  properties: {
-    image: ImageBinaryOrDataUriSchema({ title: "Image", description: "Image with border" })
-  },
+  properties: { image: GpuImageSchema2({ 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";
@@ -6047,45 +6832,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",
@@ -6100,14 +6865,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";
@@ -6118,50 +6881,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",
@@ -6176,14 +6908,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";
@@ -6194,67 +6924,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";
@@ -6265,56 +6963,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"],
@@ -6322,14 +7002,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";
@@ -6340,54 +7018,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";
@@ -6398,58 +7051,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";
@@ -6460,64 +7084,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"],
@@ -6525,14 +7111,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";
@@ -6543,56 +7127,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
     }
   },
@@ -6601,14 +7157,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";
@@ -6619,52 +7173,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"],
@@ -6672,14 +7208,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";
@@ -6690,61 +7224,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"],
@@ -6752,14 +7267,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";
@@ -6770,64 +7283,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";
@@ -6838,21 +7374,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);
@@ -6927,7 +7466,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"
 });
@@ -6992,65 +7531,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"
+  };
 }
-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";
+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 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";
@@ -7069,46 +7616,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,
@@ -7120,77 +7653,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",
@@ -7206,14 +7697,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";
@@ -7224,68 +7713,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";
@@ -7296,133 +7759,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";
@@ -7477,15 +7826,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
@@ -11981,7 +12330,7 @@ var configSchema = {
   },
   additionalProperties: false
 };
-var inputSchema59 = {
+var inputSchema58 = {
   type: "object",
   properties: {
     javascript_code: {
@@ -11995,7 +12344,7 @@ var inputSchema59 = {
   required: ["javascript_code"],
   additionalProperties: true
 };
-var outputSchema58 = {
+var outputSchema57 = {
   type: "object",
   properties: {
     output: {
@@ -12007,7 +12356,7 @@ var outputSchema58 = {
   additionalProperties: false
 };
 
-class JavaScriptTask extends Task61 {
+class JavaScriptTask extends Task45 {
   static type = "JavaScriptTask";
   static category = "Utility";
   static title = "JavaScript Interpreter";
@@ -12028,10 +12377,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) {
@@ -12044,7 +12393,7 @@ class JavaScriptTask extends Task61 {
         additionalProperties: true
       };
     }
-    return inputSchema59;
+    return inputSchema58;
   }
   async execute(input2) {
     return runJavaScript(input2, this.config.javascript_code);
@@ -12056,14 +12405,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: {
@@ -12079,7 +12428,7 @@ var inputSchema60 = {
   required: ["value", "path"],
   additionalProperties: false
 };
-var outputSchema59 = {
+var outputSchema58 = {
   type: "object",
   properties: {
     result: {
@@ -12116,16 +12465,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) };
@@ -12134,18 +12483,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: {
@@ -12156,7 +12505,7 @@ var inputSchema61 = {
   },
   additionalProperties: false
 };
-var outputSchema60 = {
+var outputSchema59 = {
   type: "object",
   properties: {
     output: {
@@ -12173,10 +12522,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)
@@ -12210,15 +12559,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",
@@ -12229,7 +12578,7 @@ var lambdaTaskConfigSchema = {
   },
   additionalProperties: false
 };
-var inputSchema62 = {
+var inputSchema61 = {
   type: "object",
   properties: {
     [DATAFLOW_ALL_PORTS]: {
@@ -12239,7 +12588,7 @@ var inputSchema62 = {
   },
   additionalProperties: true
 };
-var outputSchema61 = {
+var outputSchema60 = {
   type: "object",
   properties: {
     [DATAFLOW_ALL_PORTS]: {
@@ -12250,7 +12599,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";
@@ -12260,10 +12609,10 @@ class LambdaTask extends Task63 {
     return lambdaTaskConfigSchema;
   }
   static inputSchema() {
-    return inputSchema62;
+    return inputSchema61;
   }
   static outputSchema() {
-    return outputSchema61;
+    return outputSchema60;
   }
   canSerializeConfig() {
     return false;
@@ -12297,14 +12646,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
@@ -12478,7 +12827,7 @@ var outputSchemaAll = {
   additionalProperties: false
 };
 
-class McpListTask extends Task64 {
+class McpListTask extends Task48 {
   static type = "McpListTask";
   static category = "MCP";
   static title = "MCP List";
@@ -12585,15 +12934,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",
@@ -12728,7 +13077,7 @@ var fallbackInputSchema = {
   additionalProperties: false
 };
 
-class McpPromptGetTask extends Task65 {
+class McpPromptGetTask extends Task49 {
   static type = "McpPromptGetTask";
   static category = "MCP";
   static title = "MCP Get Prompt";
@@ -12851,15 +13200,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: [
@@ -12887,12 +13236,12 @@ var contentItemSchema = {
     }
   ]
 };
-var inputSchema63 = {
+var inputSchema62 = {
   type: "object",
   properties: {},
   additionalProperties: false
 };
-var outputSchema62 = {
+var outputSchema61 = {
   type: "object",
   properties: {
     contents: {
@@ -12906,7 +13255,7 @@ var outputSchema62 = {
   additionalProperties: false
 };
 
-class McpResourceReadTask extends Task66 {
+class McpResourceReadTask extends Task50 {
   static type = "McpResourceReadTask";
   static category = "MCP";
   static title = "MCP Read Resource";
@@ -12939,10 +13288,10 @@ class McpResourceReadTask extends Task66 {
     });
   }
   static inputSchema() {
-    return inputSchema63;
+    return inputSchema62;
   }
   static outputSchema() {
-    return outputSchema62;
+    return outputSchema61;
   }
   static configSchema() {
     const { mcpServerConfigSchema: mcpServerConfigSchema2 } = getMcpTaskDeps();
@@ -12979,13 +13328,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 = {
@@ -13125,7 +13474,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";
@@ -13152,15 +13501,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",
@@ -13287,7 +13636,7 @@ var fallbackInputSchema2 = {
   additionalProperties: true
 };
 
-class McpToolCallTask extends Task68 {
+class McpToolCallTask extends Task52 {
   static type = "McpToolCallTask";
   static category = "MCP";
   static title = "MCP Call Tool";
@@ -13425,7 +13774,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");
@@ -13519,13 +13868,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: {
@@ -13537,17 +13886,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 }));
@@ -13561,14 +13910,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";
@@ -13624,13 +13973,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) {
@@ -13663,7 +14012,7 @@ function executeRegex(input2) {
     matches: result.slice(0)
   };
 }
-var inputSchema65 = {
+var inputSchema64 = {
   type: "object",
   properties: {
     value: {
@@ -13686,7 +14035,7 @@ var inputSchema65 = {
   required: ["value", "pattern"],
   additionalProperties: false
 };
-var outputSchema64 = {
+var outputSchema63 = {
   type: "object",
   properties: {
     match: {
@@ -13705,16 +14054,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);
@@ -13723,10 +14072,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: {
@@ -13738,7 +14087,7 @@ var inputSchema66 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema65 = {
+var outputSchema64 = {
   type: "object",
   properties: {
     result: {
@@ -13751,25 +14100,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: {
@@ -13781,7 +14130,7 @@ var inputSchema67 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema66 = {
+var outputSchema65 = {
   type: "object",
   properties: {
     result: {
@@ -13794,25 +14143,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: {
@@ -13824,7 +14173,7 @@ var inputSchema68 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema67 = {
+var outputSchema66 = {
   type: "object",
   properties: {
     result: {
@@ -13837,25 +14186,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: {
@@ -13868,7 +14217,7 @@ var inputSchema69 = {
   required: ["values"],
   additionalProperties: false
 };
-var outputSchema68 = {
+var outputSchema67 = {
   type: "object",
   properties: {
     result: {
@@ -13881,25 +14230,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: {
@@ -13912,7 +14261,7 @@ var inputSchema70 = {
   required: ["values"],
   additionalProperties: false
 };
-var outputSchema69 = {
+var outputSchema68 = {
   type: "object",
   properties: {
     result: {
@@ -13925,25 +14274,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: {
@@ -13955,7 +14304,7 @@ var inputSchema71 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema70 = {
+var outputSchema69 = {
   type: "object",
   properties: {
     result: {
@@ -13968,25 +14317,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: {
@@ -13998,7 +14347,7 @@ var inputSchema72 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema71 = {
+var outputSchema70 = {
   type: "object",
   properties: {
     result: {
@@ -14011,25 +14360,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: {
@@ -14039,7 +14388,7 @@ var inputSchema73 = {
   },
   additionalProperties: false
 };
-var outputSchema72 = {
+var outputSchema71 = {
   type: "object",
   properties: {},
   additionalProperties: true
@@ -14056,17 +14405,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);
@@ -14079,22 +14428,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: {
@@ -14107,16 +14456,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) };
@@ -14125,17 +14474,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: {
@@ -14152,7 +14501,7 @@ var inputSchema75 = {
   required: ["text", "search"],
   additionalProperties: false
 };
-var outputSchema74 = {
+var outputSchema73 = {
   type: "object",
   properties: {
     included: {
@@ -14165,16 +14514,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) };
@@ -14183,17 +14532,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: {
@@ -14212,7 +14561,7 @@ var inputSchema76 = {
   required: ["texts"],
   additionalProperties: false
 };
-var outputSchema75 = {
+var outputSchema74 = {
   type: "object",
   properties: {
     text: {
@@ -14225,16 +14574,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) };
@@ -14243,17 +14592,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: {
@@ -14265,7 +14614,7 @@ var inputSchema77 = {
   required: ["text"],
   additionalProperties: false
 };
-var outputSchema76 = {
+var outputSchema75 = {
   type: "object",
   properties: {
     length: {
@@ -14278,16 +14627,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) };
@@ -14296,17 +14645,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: {
@@ -14318,7 +14667,7 @@ var inputSchema78 = {
   required: ["text"],
   additionalProperties: false
 };
-var outputSchema77 = {
+var outputSchema76 = {
   type: "object",
   properties: {
     text: {
@@ -14331,16 +14680,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) };
@@ -14349,17 +14698,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: {
@@ -14381,7 +14730,7 @@ var inputSchema79 = {
   required: ["text", "search", "replace"],
   additionalProperties: false
 };
-var outputSchema78 = {
+var outputSchema77 = {
   type: "object",
   properties: {
     text: {
@@ -14394,16 +14743,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) };
@@ -14412,17 +14761,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: {
@@ -14444,7 +14793,7 @@ var inputSchema80 = {
   required: ["text", "start"],
   additionalProperties: false
 };
-var outputSchema79 = {
+var outputSchema78 = {
   type: "object",
   properties: {
     text: {
@@ -14457,16 +14806,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) };
@@ -14475,12 +14824,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;
@@ -14489,7 +14838,7 @@ function renderStringTemplate(template, values) {
   }
   return text;
 }
-var inputSchema81 = {
+var inputSchema80 = {
   type: "object",
   properties: {
     template: {
@@ -14507,7 +14856,7 @@ var inputSchema81 = {
   required: ["template", "values"],
   additionalProperties: false
 };
-var outputSchema80 = {
+var outputSchema79 = {
   type: "object",
   properties: {
     text: {
@@ -14520,16 +14869,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) };
@@ -14538,17 +14887,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: {
@@ -14560,7 +14909,7 @@ var inputSchema82 = {
   required: ["text"],
   additionalProperties: false
 };
-var outputSchema81 = {
+var outputSchema80 = {
   type: "object",
   properties: {
     text: {
@@ -14573,16 +14922,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) };
@@ -14591,17 +14940,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: {
@@ -14613,7 +14962,7 @@ var inputSchema83 = {
   required: ["text"],
   additionalProperties: false
 };
-var outputSchema82 = {
+var outputSchema81 = {
   type: "object",
   properties: {
     text: {
@@ -14626,16 +14975,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) };
@@ -14644,12 +14993,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) => {
@@ -14669,7 +15018,7 @@ function renderTemplate(template, values) {
     return defaultValue !== undefined ? defaultValue : "";
   });
 }
-var inputSchema84 = {
+var inputSchema83 = {
   type: "object",
   properties: {
     template: {
@@ -14687,7 +15036,7 @@ var inputSchema84 = {
   required: ["template", "values"],
   additionalProperties: false
 };
-var outputSchema83 = {
+var outputSchema82 = {
   type: "object",
   properties: {
     result: {
@@ -14700,16 +15049,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) };
@@ -14718,13 +15067,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: {
@@ -14740,7 +15089,7 @@ var inputSchema85 = {
   required: ["vectors"],
   additionalProperties: false
 };
-var outputSchema84 = {
+var outputSchema83 = {
   type: "object",
   properties: {
     result: {
@@ -14753,16 +15102,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;
@@ -14780,13 +15129,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: {
@@ -14802,7 +15151,7 @@ var inputSchema86 = {
   required: ["vectors"],
   additionalProperties: false
 };
-var outputSchema85 = {
+var outputSchema84 = {
   type: "object",
   properties: {
     result: {
@@ -14815,16 +15164,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;
@@ -14839,14 +15188,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({
@@ -14857,7 +15206,7 @@ var inputSchema87 = {
   required: ["vector"],
   additionalProperties: false
 };
-var outputSchema86 = {
+var outputSchema85 = {
   type: "object",
   properties: {
     result: TypedArraySchema7({
@@ -14869,29 +15218,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({
@@ -14907,7 +15256,7 @@ var inputSchema88 = {
   required: ["vector", "scalar"],
   additionalProperties: false
 };
-var outputSchema87 = {
+var outputSchema86 = {
   type: "object",
   properties: {
     result: TypedArraySchema8({
@@ -14919,16 +15268,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;
@@ -14936,7 +15285,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";
@@ -15037,7 +15386,6 @@ var registerCommonTasks = () => {
     ImageBorderTask,
     ImageTransparencyTask,
     ImageBlurTask,
-    ImageWatermarkTask,
     ImagePixelateTask,
     ImageInvertTask,
     ImageBrightnessTask,
@@ -15054,10 +15402,10 @@ var registerCommonTasks = () => {
 };
 // 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() {
@@ -15071,7 +15419,7 @@ async function getPapaParse() {
   }
   return _papaParse;
 }
-var inputSchema89 = {
+var inputSchema88 = {
   type: "object",
   properties: {
     url: {
@@ -15091,7 +15439,7 @@ var inputSchema89 = {
   required: ["url"],
   additionalProperties: false
 };
-var outputSchema88 = {
+var outputSchema87 = {
   type: "object",
   properties: {
     text: {
@@ -15142,17 +15490,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;
@@ -15508,7 +15856,7 @@ class FileLoaderTask extends Task95 {
 var fileLoader = (input2, config) => {
   return new FileLoaderTask(config).run(input2);
 };
-Workflow71.prototype.fileLoader = CreateWorkflow70(FileLoaderTask);
+Workflow70.prototype.fileLoader = CreateWorkflow69(FileLoaderTask);
 // src/browser.ts
 import { TaskRegistry as TaskRegistry3 } from "@workglow/task-graph";
 registerMcpTaskDeps({
@@ -15550,9 +15898,9 @@ export {
   registerMcpTaskDeps,
   registerMcpServer,
   registerImageRasterCodec2 as registerImageRasterCodec,
+  registerFilterOp33 as registerFilterOp,
   registerCommonTasks2 as registerCommonTasks,
   registerBrowserDeps,
-  produceImageOutput,
   normalizeOutputMimeType,
   merge,
   mcpTransportTypes,
@@ -15570,11 +15918,12 @@ export {
   lambda,
   json,
   javaScript,
+  hasFilterOp2 as hasFilterOp,
   getSafeFetchImpl,
   getMcpTaskDeps,
   getMcpServerConfig,
   getMcpServer,
-  getImageRasterCodec2 as getImageRasterCodec,
+  getImageRasterCodec,
   getGlobalMcpServers,
   getGlobalMcpServerRepository,
   getBrowserDeps,
@@ -15591,6 +15940,8 @@ export {
   assertWithinPixelBudget,
   assertWithinByteBudget,
   assertIsDataUri,
+  applyFilter3 as applyFilter,
+  _resetFilterRegistryForTests,
   VectorSumTask,
   VectorSubtractTask,
   VectorScaleTask,
@@ -15651,7 +16002,6 @@ export {
   JavaScriptTask,
   InputTask,
   InMemoryMcpServerRepository,
-  ImageWatermarkTask,
   ImageTransparencyTask,
   ImageTintTask,
   ImageThresholdTask,
@@ -15664,14 +16014,12 @@ export {
   ImageInvertTask,
   ImageGrayscaleTask,
   ImageFlipTask,
+  ImageFilterTask,
   ImageCropTask,
   ImageContrastTask,
   ImageBrightnessTask,
   ImageBorderTask,
   ImageBlurTask,
-  ImageBinarySchemaOptions,
-  ImageBinarySchema,
-  ImageBinaryOrDataUriSchema,
   HumanInputTask,
   HumanApprovalTask,
   HexColorSchema,
@@ -15681,6 +16029,7 @@ export {
   DelayTask,
   DebugLogTask,
   DateFormatTask,
+  CssRgbColorSchema,
   CredentialStoreOAuthProvider,
   ColorValueSchema,
   ColorSchema,
@@ -15718,4 +16067,4 @@ export {
   ArrayTask
 };
 
-//# debugId=55A0E96F7226DD2664756E2164756E21
+//# debugId=D3AD9302546FF7B664756E2164756E21