@workglow/tasks 0.2.0 → 0.2.1

package/dist/node.js

@@ -9940,6 +9940,1223 @@ class VectorScaleTask extends Task50 {
   }
 }
 Workflow52.prototype.vectorScale = CreateWorkflow51(VectorScaleTask);
+// 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 = {}) => ({
+  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",
+      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)"
+    }
+  },
+  additionalProperties: false,
+  required: ["data", "width", "height", "channels"],
+  format: "image:ImageBinary",
+  title: "Image",
+  description: "Raw pixel image data",
+  ...annotations
+});
+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"],
+  additionalProperties: false,
+  ...annotations
+});
+// src/task/image/ImageResizeTask.ts
+import {
+  CreateWorkflow as CreateWorkflow52,
+  Task as Task51,
+  Workflow as Workflow53
+} from "@workglow/task-graph";
+var inputSchema45 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ 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
+    }
+  },
+  required: ["image", "width", "height"],
+  additionalProperties: false
+};
+var outputSchema44 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Resized image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageResizeTask extends Task51 {
+  static type = "ImageResizeTask";
+  static category = "Image";
+  static title = "Resize Image";
+  static description = "Resizes an image using nearest-neighbor sampling";
+  static inputSchema() {
+    return inputSchema45;
+  }
+  static outputSchema() {
+    return outputSchema44;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { image, width: dstW, height: dstH } = input2;
+    const { data: src, width: srcW, height: srcH, channels } = image;
+    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 {
+      image: { data: dst, width: dstW, height: dstH, channels }
+    };
+  }
+}
+Workflow53.prototype.imageResize = CreateWorkflow52(ImageResizeTask);
+// src/task/image/ImageCropTask.ts
+import {
+  CreateWorkflow as CreateWorkflow53,
+  Task as Task52,
+  Workflow as Workflow54
+} from "@workglow/task-graph";
+var inputSchema46 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ 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 },
+    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"],
+  additionalProperties: false
+};
+var outputSchema45 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Cropped image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageCropTask extends Task52 {
+  static type = "ImageCropTask";
+  static category = "Image";
+  static title = "Crop Image";
+  static description = "Crops an image to a rectangular region";
+  static inputSchema() {
+    return inputSchema46;
+  }
+  static outputSchema() {
+    return outputSchema45;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { image, x: rawX, y: rawY, width: rawW, height: rawH } = input2;
+    const { data: src, width: srcW, height: srcH, channels } = image;
+    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 { image: { data: dst, width: w, height: h, channels } };
+  }
+}
+Workflow54.prototype.imageCrop = CreateWorkflow53(ImageCropTask);
+// src/task/image/ImageRotateTask.ts
+import {
+  CreateWorkflow as CreateWorkflow54,
+  Task as Task53,
+  Workflow as Workflow55
+} from "@workglow/task-graph";
+var inputSchema47 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    angle: {
+      type: "integer",
+      enum: [90, 180, 270],
+      title: "Angle",
+      description: "Rotation angle in degrees (clockwise)"
+    }
+  },
+  required: ["image", "angle"],
+  additionalProperties: false
+};
+var outputSchema46 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Rotated image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageRotateTask extends Task53 {
+  static type = "ImageRotateTask";
+  static category = "Image";
+  static title = "Rotate Image";
+  static description = "Rotates an image by 90, 180, or 270 degrees clockwise";
+  static inputSchema() {
+    return inputSchema47;
+  }
+  static outputSchema() {
+    return outputSchema46;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { image, angle } = input2;
+    const { data: src, width: srcW, height: srcH, channels } = image;
+    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 {
+      image: { data: dst, width: dstW, height: dstH, channels }
+    };
+  }
+}
+Workflow55.prototype.imageRotate = CreateWorkflow54(ImageRotateTask);
+// src/task/image/ImageFlipTask.ts
+import {
+  CreateWorkflow as CreateWorkflow55,
+  Task as Task54,
+  Workflow as Workflow56
+} from "@workglow/task-graph";
+var inputSchema48 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    direction: {
+      type: "string",
+      enum: ["horizontal", "vertical"],
+      title: "Direction",
+      description: "Flip direction"
+    }
+  },
+  required: ["image", "direction"],
+  additionalProperties: false
+};
+var outputSchema47 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Flipped image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageFlipTask extends Task54 {
+  static type = "ImageFlipTask";
+  static category = "Image";
+  static title = "Flip Image";
+  static description = "Flips an image horizontally or vertically";
+  static inputSchema() {
+    return inputSchema48;
+  }
+  static outputSchema() {
+    return outputSchema47;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { image, direction } = input2;
+    const { data: src, width, height, channels } = image;
+    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 { image: { data: dst, width, height, channels } };
+  }
+}
+Workflow56.prototype.imageFlip = CreateWorkflow55(ImageFlipTask);
+// src/task/image/ImageGrayscaleTask.ts
+import {
+  CreateWorkflow as CreateWorkflow56,
+  Task as Task55,
+  Workflow as Workflow57
+} from "@workglow/task-graph";
+var inputSchema49 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema48 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Grayscale image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageGrayscaleTask extends Task55 {
+  static type = "ImageGrayscaleTask";
+  static category = "Image";
+  static title = "Grayscale";
+  static description = "Converts an image to grayscale using luminance";
+  static inputSchema() {
+    return inputSchema49;
+  }
+  static outputSchema() {
+    return outputSchema48;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { data: src, width, height, channels } = input2.image;
+    if (channels === 1) {
+      return { image: { 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 { image: { data: dst, width, height, channels: 1 } };
+  }
+}
+Workflow57.prototype.imageGrayscale = CreateWorkflow56(ImageGrayscaleTask);
+// src/task/image/ImageBorderTask.ts
+import {
+  CreateWorkflow as CreateWorkflow57,
+  Task as Task56,
+  Workflow as Workflow58
+} from "@workglow/task-graph";
+var inputSchema50 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    borderWidth: {
+      type: "integer",
+      title: "Border Width",
+      description: "Border width in pixels",
+      minimum: 1,
+      default: 1
+    },
+    color: ColorSchema({ title: "Color", description: "Border color" })
+  },
+  required: ["image", "color"],
+  additionalProperties: false
+};
+var outputSchema49 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Image with border" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageBorderTask extends Task56 {
+  static type = "ImageBorderTask";
+  static category = "Image";
+  static title = "Add Border";
+  static description = "Adds a colored border around an image";
+  static inputSchema() {
+    return inputSchema50;
+  }
+  static outputSchema() {
+    return outputSchema49;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { image, borderWidth: bw = 1, color } = input2;
+    const { data: src, width: srcW, height: srcH, channels: srcCh } = image;
+    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 ?? 255;
+    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 {
+      image: { data: dst, width: dstW, height: dstH, channels: outCh }
+    };
+  }
+}
+Workflow58.prototype.imageBorder = CreateWorkflow57(ImageBorderTask);
+// src/task/image/ImageTransparencyTask.ts
+import {
+  CreateWorkflow as CreateWorkflow58,
+  Task as Task57,
+  Workflow as Workflow59
+} from "@workglow/task-graph";
+var inputSchema51 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    opacity: {
+      type: "number",
+      title: "Opacity",
+      description: "Opacity level (0.0 = fully transparent, 1.0 = fully opaque)",
+      minimum: 0,
+      maximum: 1
+    }
+  },
+  required: ["image", "opacity"],
+  additionalProperties: false
+};
+var outputSchema50 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Image with adjusted transparency" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageTransparencyTask extends Task57 {
+  static type = "ImageTransparencyTask";
+  static category = "Image";
+  static title = "Set Transparency";
+  static description = "Adjusts the opacity of an image";
+  static inputSchema() {
+    return inputSchema51;
+  }
+  static outputSchema() {
+    return outputSchema50;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { image, opacity } = input2;
+    const { data: src, width, height, channels: srcCh } = image;
+    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 {
+      image: { data: dst, width, height, channels: 4 }
+    };
+  }
+}
+Workflow59.prototype.imageTransparency = CreateWorkflow58(ImageTransparencyTask);
+// src/task/image/ImageBlurTask.ts
+import {
+  CreateWorkflow as CreateWorkflow59,
+  Task as Task58,
+  Workflow as Workflow60
+} from "@workglow/task-graph";
+var inputSchema52 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ 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 outputSchema51 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Blurred image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageBlurTask extends Task58 {
+  static type = "ImageBlurTask";
+  static category = "Image";
+  static title = "Blur Image";
+  static description = "Applies a box blur to an image";
+  static inputSchema() {
+    return inputSchema52;
+  }
+  static outputSchema() {
+    return outputSchema51;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { image, radius = 1 } = input2;
+    const { data: src, width, height, channels } = image;
+    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 { image: { data: dst, width, height, channels } };
+  }
+}
+Workflow60.prototype.imageBlur = CreateWorkflow59(ImageBlurTask);
+// src/task/image/ImageWatermarkTask.ts
+import {
+  CreateWorkflow as CreateWorkflow60,
+  Task as Task59,
+  Workflow as Workflow61
+} from "@workglow/task-graph";
+var inputSchema53 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ 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 outputSchema52 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ 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 inputSchema53;
+  }
+  static outputSchema() {
+    return outputSchema52;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { image, spacing = 64, opacity = 0.3, pattern = "diagonal-lines" } = input2;
+    const { data: src, width, height, channels: srcCh } = image;
+    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 {
+      image: { data: dst, width, height, channels: outCh }
+    };
+  }
+}
+Workflow61.prototype.imageWatermark = CreateWorkflow60(ImageWatermarkTask);
+// src/task/image/ImagePixelateTask.ts
+import {
+  CreateWorkflow as CreateWorkflow61,
+  Task as Task60,
+  Workflow as Workflow62
+} from "@workglow/task-graph";
+var inputSchema54 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    blockSize: {
+      type: "integer",
+      title: "Block Size",
+      description: "Size of each pixelation block",
+      minimum: 2,
+      default: 8
+    }
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema53 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Pixelated image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImagePixelateTask extends Task60 {
+  static type = "ImagePixelateTask";
+  static category = "Image";
+  static title = "Pixelate Image";
+  static description = "Pixelates an image by averaging blocks of pixels";
+  static inputSchema() {
+    return inputSchema54;
+  }
+  static outputSchema() {
+    return outputSchema53;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { image, blockSize = 8 } = input2;
+    const { data: src, width, height, channels } = image;
+    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 { image: { data: dst, width, height, channels } };
+  }
+}
+Workflow62.prototype.imagePixelate = CreateWorkflow61(ImagePixelateTask);
+// src/task/image/ImageInvertTask.ts
+import {
+  CreateWorkflow as CreateWorkflow62,
+  Task as Task61,
+  Workflow as Workflow63
+} from "@workglow/task-graph";
+var inputSchema55 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema54 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Inverted image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageInvertTask extends Task61 {
+  static type = "ImageInvertTask";
+  static category = "Image";
+  static title = "Invert Colors";
+  static description = "Inverts the colors of an image";
+  static inputSchema() {
+    return inputSchema55;
+  }
+  static outputSchema() {
+    return outputSchema54;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { data: src, width, height, channels } = input2.image;
+    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 { image: { data: dst, width, height, channels } };
+  }
+}
+Workflow63.prototype.imageInvert = CreateWorkflow62(ImageInvertTask);
+// src/task/image/ImageBrightnessTask.ts
+import {
+  CreateWorkflow as CreateWorkflow63,
+  Task as Task62,
+  Workflow as Workflow64
+} from "@workglow/task-graph";
+var inputSchema56 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    amount: {
+      type: "number",
+      title: "Amount",
+      description: "Brightness adjustment (-255 to 255)",
+      minimum: -255,
+      maximum: 255,
+      default: 0
+    }
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema55 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Brightness-adjusted image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageBrightnessTask extends Task62 {
+  static type = "ImageBrightnessTask";
+  static category = "Image";
+  static title = "Adjust Brightness";
+  static description = "Adjusts the brightness of an image";
+  static inputSchema() {
+    return inputSchema56;
+  }
+  static outputSchema() {
+    return outputSchema55;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { data: src, width, height, channels } = input2.image;
+    const amount = input2.amount ?? 0;
+    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 { image: { data: dst, width, height, channels } };
+  }
+}
+Workflow64.prototype.imageBrightness = CreateWorkflow63(ImageBrightnessTask);
+// src/task/image/ImageContrastTask.ts
+import {
+  CreateWorkflow as CreateWorkflow64,
+  Task as Task63,
+  Workflow as Workflow65
+} from "@workglow/task-graph";
+var inputSchema57 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    amount: {
+      type: "number",
+      title: "Amount",
+      description: "Contrast adjustment (-100 to 100)",
+      minimum: -100,
+      maximum: 100,
+      default: 0
+    }
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema56 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Contrast-adjusted image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageContrastTask extends Task63 {
+  static type = "ImageContrastTask";
+  static category = "Image";
+  static title = "Adjust Contrast";
+  static description = "Adjusts the contrast of an image";
+  static inputSchema() {
+    return inputSchema57;
+  }
+  static outputSchema() {
+    return outputSchema56;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { data: src, width, height, channels } = input2.image;
+    const amount = input2.amount ?? 0;
+    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 { image: { data: dst, width, height, channels } };
+  }
+}
+Workflow65.prototype.imageContrast = CreateWorkflow64(ImageContrastTask);
+// src/task/image/ImageSepiaTask.ts
+import {
+  CreateWorkflow as CreateWorkflow65,
+  Task as Task64,
+  Workflow as Workflow66
+} from "@workglow/task-graph";
+var inputSchema58 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema57 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Sepia-toned image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageSepiaTask extends Task64 {
+  static type = "ImageSepiaTask";
+  static category = "Image";
+  static title = "Sepia Tone";
+  static description = "Applies a sepia tone filter to an image";
+  static inputSchema() {
+    return inputSchema58;
+  }
+  static outputSchema() {
+    return outputSchema57;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { data: src, width, height, channels } = input2.image;
+    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];
+      }
+    }
+    return { image: { data: dst, width, height, channels } };
+  }
+}
+Workflow66.prototype.imageSepia = CreateWorkflow65(ImageSepiaTask);
+// src/task/image/ImageThresholdTask.ts
+import {
+  CreateWorkflow as CreateWorkflow66,
+  Task as Task65,
+  Workflow as Workflow67
+} from "@workglow/task-graph";
+var inputSchema59 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    threshold: {
+      type: "integer",
+      title: "Threshold",
+      description: "Threshold value (0-255)",
+      minimum: 0,
+      maximum: 255,
+      default: 128
+    }
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema58 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Thresholded binary image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageThresholdTask extends Task65 {
+  static type = "ImageThresholdTask";
+  static category = "Image";
+  static title = "Threshold";
+  static description = "Converts an image to binary black and white";
+  static inputSchema() {
+    return inputSchema59;
+  }
+  static outputSchema() {
+    return outputSchema58;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { data: src, width, height, channels } = input2.image;
+    const threshold = input2.threshold ?? 128;
+    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 { image: { data: dst, width, height, channels: 1 } };
+  }
+}
+Workflow67.prototype.imageThreshold = CreateWorkflow66(ImageThresholdTask);
+// src/task/image/ImagePosterizeTask.ts
+import {
+  CreateWorkflow as CreateWorkflow67,
+  Task as Task66,
+  Workflow as Workflow68
+} from "@workglow/task-graph";
+var inputSchema60 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    levels: {
+      type: "integer",
+      title: "Levels",
+      description: "Number of color levels per channel (2-32)",
+      minimum: 2,
+      maximum: 32,
+      default: 4
+    }
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema59 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Posterized image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImagePosterizeTask extends Task66 {
+  static type = "ImagePosterizeTask";
+  static category = "Image";
+  static title = "Posterize";
+  static description = "Reduces the number of color levels in an image";
+  static inputSchema() {
+    return inputSchema60;
+  }
+  static outputSchema() {
+    return outputSchema59;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { data: src, width, height, channels } = input2.image;
+    const levels = input2.levels ?? 4;
+    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 { image: { data: dst, width, height, channels } };
+  }
+}
+Workflow68.prototype.imagePosterize = CreateWorkflow67(ImagePosterizeTask);
+// src/task/image/ImageTintTask.ts
+import {
+  CreateWorkflow as CreateWorkflow68,
+  Task as Task67,
+  Workflow as Workflow69
+} from "@workglow/task-graph";
+var inputSchema61 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    color: ColorSchema({ title: "Color", description: "Tint color" }),
+    amount: {
+      type: "number",
+      title: "Amount",
+      description: "Tint strength (0.0 = no tint, 1.0 = full tint color)",
+      minimum: 0,
+      maximum: 1,
+      default: 0.5
+    }
+  },
+  required: ["image", "color"],
+  additionalProperties: false
+};
+var outputSchema60 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Tinted image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageTintTask extends Task67 {
+  static type = "ImageTintTask";
+  static category = "Image";
+  static title = "Tint Image";
+  static description = "Applies a color tint to an image";
+  static inputSchema() {
+    return inputSchema61;
+  }
+  static outputSchema() {
+    return outputSchema60;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { data: src, width, height, channels } = input2.image;
+    const { r: tr, g: tg, b: tb } = input2.color;
+    const amount = input2.amount ?? 0.5;
+    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 { image: { 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 { image: { data: dst, width, height, channels } };
+  }
+}
+Workflow69.prototype.imageTint = CreateWorkflow68(ImageTintTask);
 
 // src/common.ts
 import { TaskRegistry } from "@workglow/task-graph";
@@ -9995,28 +11212,45 @@ var registerCommonTasks = () => {
     JsonPathTask,
     TemplateTask,
     DateFormatTask,
-    RegexTask
+    RegexTask,
+    ImageResizeTask,
+    ImageCropTask,
+    ImageRotateTask,
+    ImageFlipTask,
+    ImageGrayscaleTask,
+    ImageBorderTask,
+    ImageTransparencyTask,
+    ImageBlurTask,
+    ImageWatermarkTask,
+    ImagePixelateTask,
+    ImageInvertTask,
+    ImageBrightnessTask,
+    ImageContrastTask,
+    ImageSepiaTask,
+    ImageThresholdTask,
+    ImagePosterizeTask,
+    ImageTintTask
   ];
   tasks.map(TaskRegistry.registerTask);
   return tasks;
 };
 // src/task/FileLoaderTask.server.ts
 import {
-  CreateWorkflow as CreateWorkflow53,
+  CreateWorkflow as CreateWorkflow70,
   TaskAbortedError as TaskAbortedError5,
-  Workflow as Workflow54
+  Workflow as Workflow71
 } from "@workglow/task-graph";
 import { readFile } from "node:fs/promises";
 
 // src/task/FileLoaderTask.ts
 import {
-  CreateWorkflow as CreateWorkflow52,
-  Task as Task51,
+  CreateWorkflow as CreateWorkflow69,
+  Task as Task68,
   TaskAbortedError as TaskAbortedError4,
-  Workflow as Workflow53
+  Workflow as Workflow70
 } from "@workglow/task-graph";
 import Papa from "papaparse";
-var inputSchema45 = {
+var inputSchema62 = {
   type: "object",
   properties: {
     url: {
@@ -10036,7 +11270,7 @@ var inputSchema45 = {
   required: ["url"],
   additionalProperties: false
 };
-var outputSchema44 = {
+var outputSchema61 = {
   type: "object",
   properties: {
     text: {
@@ -10087,17 +11321,17 @@ var outputSchema44 = {
   additionalProperties: false
 };
 
-class FileLoaderTask extends Task51 {
+class FileLoaderTask extends Task68 {
   static type = "FileLoaderTask";
   static category = "Document";
   static title = "File Loader";
   static description = "Load documents from URLs (http://, https://)";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema45;
+    return inputSchema62;
   }
   static outputSchema() {
-    return outputSchema44;
+    return outputSchema61;
   }
   async execute(input2, context) {
     const { url, format = "auto" } = input2;
@@ -10446,7 +11680,7 @@ class FileLoaderTask extends Task51 {
     });
   }
 }
-Workflow53.prototype.fileLoader = CreateWorkflow52(FileLoaderTask);
+Workflow70.prototype.fileLoader = CreateWorkflow69(FileLoaderTask);
 
 // src/task/FileLoaderTask.server.ts
 class FileLoaderTask2 extends FileLoaderTask {
@@ -10635,7 +11869,7 @@ class FileLoaderTask2 extends FileLoaderTask {
 var fileLoader = (input2, config) => {
   return new FileLoaderTask2(config).run(input2);
 };
-Workflow54.prototype.fileLoader = CreateWorkflow53(FileLoaderTask2);
+Workflow71.prototype.fileLoader = CreateWorkflow70(FileLoaderTask2);
 
 // src/node.ts
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -10747,6 +11981,25 @@ export {
   JavaScriptTask,
   InputTask,
   InMemoryMcpServerRepository,
+  ImageWatermarkTask,
+  ImageTransparencyTask,
+  ImageTintTask,
+  ImageThresholdTask,
+  ImageSepiaTask,
+  ImageRotateTask,
+  ImageResizeTask,
+  ImagePosterizeTask,
+  ImagePixelateTask,
+  ImageInvertTask,
+  ImageGrayscaleTask,
+  ImageFlipTask,
+  ImageCropTask,
+  ImageContrastTask,
+  ImageBrightnessTask,
+  ImageBorderTask,
+  ImageBlurTask,
+  ImageBinarySchemaOptions,
+  ImageBinarySchema,
   HumanInputTask,
   HumanApprovalTask,
   HUMAN_CONNECTOR,
@@ -10757,7 +12010,8 @@ export {
   DebugLogTask,
   DateFormatTask,
   CredentialStoreOAuthProvider,
+  ColorSchema,
   ArrayTask
 };
 
-//# debugId=3BCE616299E7CD4F64756E2164756E21
+//# debugId=B36303F8AC2A2F5B64756E2164756E21