@workglow/tasks 0.2.15 → 0.2.17

package/dist/node.js

@@ -2155,11 +2155,11 @@ class ArrayTaskRunner extends GraphAsTaskRunner {
   async executeTaskChildren(_input) {
     return super.executeTaskChildren({});
   }
-  async executeTaskChildrenReactive() {
-    return this.task.subGraph.runReactive({});
+  async executeTaskChildrenPreview() {
+    return this.task.subGraph.runPreview({});
   }
-  async executeTaskReactive(input, output) {
-    await super.executeTaskReactive(input, output);
+  async executeTaskPreview(input) {
+    await super.executeTaskPreview(input);
     if (this.task.hasChildren()) {
       this.task.runOutputData = this.task.executeMerge(input, this.task.runOutputData);
     }
@@ -4856,6 +4856,29 @@ import {
   Task as Task36,
   Workflow as Workflow11
 } from "@workglow/task-graph";
+function formatDate(input) {
+  const dateInput = /^\d+$/.test(input.value) ? Number(input.value) : input.value;
+  const date = new Date(dateInput);
+  if (isNaN(date.getTime())) {
+    throw new Error(`Invalid date: ${input.value}`);
+  }
+  const format = input.format ?? "iso";
+  const locale = input.locale;
+  const timeZone = input.timeZone;
+  switch (format) {
+    case "iso":
+      return date.toISOString();
+    case "date":
+      return date.toLocaleDateString(locale, timeZone ? { timeZone } : undefined);
+    case "time":
+      return date.toLocaleTimeString(locale, timeZone ? { timeZone } : undefined);
+    case "unix":
+      return String(date.getTime());
+    case "datetime":
+    default:
+      return date.toLocaleString(locale, timeZone ? { timeZone } : undefined);
+  }
+}
 var inputSchema36 = {
   type: "object",
   properties: {
@@ -4910,35 +4933,11 @@ class DateFormatTask extends Task36 {
   static outputSchema() {
     return outputSchema36;
   }
-  async executeReactive(input, _output, _context) {
-    const dateInput = /^\d+$/.test(input.value) ? Number(input.value) : input.value;
-    const date = new Date(dateInput);
-    if (isNaN(date.getTime())) {
-      throw new Error(`Invalid date: ${input.value}`);
-    }
-    const format = input.format ?? "iso";
-    const locale = input.locale;
-    const timeZone = input.timeZone;
-    let result;
-    switch (format) {
-      case "iso":
-        result = date.toISOString();
-        break;
-      case "date":
-        result = date.toLocaleDateString(locale, timeZone ? { timeZone } : undefined);
-        break;
-      case "time":
-        result = date.toLocaleTimeString(locale, timeZone ? { timeZone } : undefined);
-        break;
-      case "unix":
-        result = String(date.getTime());
-        break;
-      case "datetime":
-      default:
-        result = date.toLocaleString(locale, timeZone ? { timeZone } : undefined);
-        break;
-    }
-    return { result };
+  async execute(input, _context) {
+    return { result: formatDate(input) };
+  }
+  async executePreview(input, _context) {
+    return { result: formatDate(input) };
   }
 }
 Workflow11.prototype.dateFormat = CreateWorkflow10(DateFormatTask);
@@ -4970,6 +4969,17 @@ var outputSchema37 = {
   properties: {},
   additionalProperties: true
 };
+function logAndPassthrough(input, log_level) {
+  const inputRecord = input;
+  if (log_level === "dir") {
+    console.dir(inputRecord, { depth: null });
+  } else {
+    console[log_level](inputRecord);
+  }
+  const output = {};
+  Object.assign(output, inputRecord);
+  return output;
+}
 
 class DebugLogTask extends Task37 {
   static type = "DebugLogTask";
@@ -4989,16 +4999,11 @@ class DebugLogTask extends Task37 {
   static outputSchema() {
     return outputSchema37;
   }
-  async executeReactive(input, output) {
-    const log_level = this.config.log_level ?? DEFAULT_LOG_LEVEL;
-    const inputRecord = input;
-    if (log_level === "dir") {
-      console.dir(inputRecord, { depth: null });
-    } else {
-      console[log_level](inputRecord);
-    }
-    Object.assign(output, inputRecord);
-    return output;
+  async execute(input) {
+    return logAndPassthrough(input, this.config.log_level ?? DEFAULT_LOG_LEVEL);
+  }
+  async executePreview(input) {
+    return logAndPassthrough(input, this.config.log_level ?? DEFAULT_LOG_LEVEL);
   }
 }
 var debugLog = (input, config = {}) => {
@@ -5994,6 +5999,49 @@ async function produceImageOutput(inputImage, run) {
 }
 
 // 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: {
@@ -6030,48 +6078,11 @@ class ImageBlurTask extends Task42 {
   static outputSchema() {
     return outputSchema40;
   }
-  async executeReactive(input, _output, _context) {
-    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 };
+  async execute(input, _context) {
+    return await applyBlur(input);
+  }
+  async executePreview(input, _context) {
+    return await applyBlur(input);
   }
 }
 Workflow17.prototype.imageBlur = CreateWorkflow16(ImageBlurTask);
@@ -6082,6 +6093,39 @@ import {
   Workflow as Workflow18
 } from "@workglow/task-graph";
 import { resolveColor } from "@workglow/util/media";
+async function applyBorder(input) {
+  const { borderWidth: bw = 1 } = input;
+  const color = resolveColor(input.color);
+  const image = await produceImageOutput(input.image, (img) => {
+    const { data: src, width: srcW, height: srcH, channels: srcCh } = img;
+    const outCh = 4;
+    const dstW = srcW + bw * 2;
+    const dstH = srcH + bw * 2;
+    const dst = new Uint8ClampedArray(dstW * dstH * outCh);
+    const r = color.r;
+    const g = color.g;
+    const b = color.b;
+    const a = color.a;
+    for (let i = 0;i < dst.length; i += outCh) {
+      dst[i] = r;
+      dst[i + 1] = g;
+      dst[i + 2] = b;
+      dst[i + 3] = a;
+    }
+    for (let y = 0;y < srcH; y++) {
+      for (let x = 0;x < srcW; x++) {
+        const srcIdx = (y * srcW + x) * srcCh;
+        const dstIdx = ((y + bw) * dstW + (x + bw)) * outCh;
+        dst[dstIdx] = src[srcIdx];
+        dst[dstIdx + 1] = srcCh >= 3 ? src[srcIdx + 1] : src[srcIdx];
+        dst[dstIdx + 2] = srcCh >= 3 ? src[srcIdx + 2] : src[srcIdx];
+        dst[dstIdx + 3] = srcCh === 4 ? src[srcIdx + 3] : 255;
+      }
+    }
+    return { data: dst, width: dstW, height: dstH, channels: outCh };
+  });
+  return { image };
+}
 var inputSchema42 = {
   type: "object",
   properties: {
@@ -6118,38 +6162,11 @@ class ImageBorderTask extends Task43 {
   static outputSchema() {
     return outputSchema41;
   }
-  async executeReactive(input, _output, _context) {
-    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 };
+  async execute(input, _context) {
+    return await applyBorder(input);
+  }
+  async executePreview(input, _context) {
+    return await applyBorder(input);
   }
 }
 Workflow18.prototype.imageBorder = CreateWorkflow17(ImageBorderTask);
@@ -6159,6 +6176,27 @@ import {
   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 };
+}
 var inputSchema43 = {
   type: "object",
   properties: {
@@ -6195,26 +6233,11 @@ class ImageBrightnessTask extends Task44 {
   static outputSchema() {
     return outputSchema42;
   }
-  async executeReactive(input, _output, _context) {
-    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 };
+  async execute(input, _context) {
+    return await applyBrightness(input);
+  }
+  async executePreview(input, _context) {
+    return await applyBrightness(input);
   }
 }
 Workflow19.prototype.imageBrightness = CreateWorkflow18(ImageBrightnessTask);
@@ -6224,6 +6247,32 @@ import {
   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 };
+}
 var inputSchema44 = {
   type: "object",
   properties: {
@@ -6260,31 +6309,11 @@ class ImageContrastTask extends Task45 {
   static outputSchema() {
     return outputSchema43;
   }
-  async executeReactive(input, _output, _context) {
-    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 };
+  async execute(input, _context) {
+    return await applyContrast(input);
+  }
+  async executePreview(input, _context) {
+    return await applyContrast(input);
   }
 }
 Workflow20.prototype.imageContrast = CreateWorkflow19(ImageContrastTask);
@@ -6294,6 +6323,31 @@ import {
   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 };
+}
 var inputSchema45 = {
   type: "object",
   properties: {
@@ -6326,30 +6380,11 @@ class ImageCropTask extends Task46 {
   static outputSchema() {
     return outputSchema44;
   }
-  async executeReactive(input, _output, _context) {
-    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 };
+  async execute(input, _context) {
+    return await cropImage(input);
+  }
+  async executePreview(input, _context) {
+    return await cropImage(input);
   }
 }
 Workflow21.prototype.imageCrop = CreateWorkflow20(ImageCropTask);
@@ -6359,6 +6394,33 @@ import {
   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 };
+}
 var inputSchema46 = {
   type: "object",
   properties: {
@@ -6393,32 +6455,11 @@ class ImageFlipTask extends Task47 {
   static outputSchema() {
     return outputSchema45;
   }
-  async executeReactive(input, _output, _context) {
-    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 };
+  async execute(input, _context) {
+    return await flipImage(input);
+  }
+  async executePreview(input, _context) {
+    return await flipImage(input);
   }
 }
 Workflow22.prototype.imageFlip = CreateWorkflow21(ImageFlipTask);
@@ -6428,6 +6469,22 @@ import {
   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 };
+}
 var inputSchema47 = {
   type: "object",
   properties: {
@@ -6456,21 +6513,11 @@ class ImageGrayscaleTask extends Task48 {
   static outputSchema() {
     return outputSchema46;
   }
-  async executeReactive(input, _output, _context) {
-    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 };
+  async execute(input, _context) {
+    return await applyGrayscale(input);
+  }
+  async executePreview(input, _context) {
+    return await applyGrayscale(input);
   }
 }
 Workflow23.prototype.imageGrayscale = CreateWorkflow22(ImageGrayscaleTask);
@@ -6480,6 +6527,26 @@ import {
   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 };
+}
 var inputSchema48 = {
   type: "object",
   properties: {
@@ -6508,25 +6575,11 @@ class ImageInvertTask extends Task49 {
   static outputSchema() {
     return outputSchema47;
   }
-  async executeReactive(input, _output, _context) {
-    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 };
+  async execute(input, _context) {
+    return await invertImage(input);
+  }
+  async executePreview(input, _context) {
+    return await invertImage(input);
   }
 }
 Workflow24.prototype.imageInvert = CreateWorkflow23(ImageInvertTask);
@@ -6536,6 +6589,40 @@ import {
   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 };
+}
 var inputSchema49 = {
   type: "object",
   properties: {
@@ -6571,39 +6658,11 @@ class ImagePixelateTask extends Task50 {
   static outputSchema() {
     return outputSchema48;
   }
-  async executeReactive(input, _output, _context) {
-    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 };
+  async execute(input, _context) {
+    return await pixelateImage(input);
+  }
+  async executePreview(input, _context) {
+    return await pixelateImage(input);
   }
 }
 Workflow25.prototype.imagePixelate = CreateWorkflow24(ImagePixelateTask);
@@ -6613,6 +6672,32 @@ import {
   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 };
+}
 var inputSchema50 = {
   type: "object",
   properties: {
@@ -6649,31 +6734,11 @@ class ImagePosterizeTask extends Task51 {
   static outputSchema() {
     return outputSchema49;
   }
-  async executeReactive(input, _output, _context) {
-    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 };
+  async execute(input, _context) {
+    return await posterizeImage(input);
+  }
+  async executePreview(input, _context) {
+    return await posterizeImage(input);
   }
 }
 Workflow26.prototype.imagePosterize = CreateWorkflow25(ImagePosterizeTask);
@@ -6685,6 +6750,26 @@ import {
   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 };
+}
 var inputSchema51 = {
   type: "object",
   properties: {
@@ -6720,25 +6805,11 @@ class ImageResizeTask extends Task52 {
   static outputSchema() {
     return outputSchema50;
   }
-  async executeReactive(input, _output, _context) {
-    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 };
+  async execute(input, _context) {
+    return await resizeImage(input);
+  }
+  async executePreview(input, _context) {
+    return await resizeImage(input);
   }
 }
 Workflow27.prototype.imageResize = CreateWorkflow26(ImageResizeTask);
@@ -6748,6 +6819,38 @@ import {
   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 };
+}
 var inputSchema52 = {
   type: "object",
   properties: {
@@ -6782,37 +6885,11 @@ class ImageRotateTask extends Task53 {
   static outputSchema() {
     return outputSchema51;
   }
-  async executeReactive(input, _output, _context) {
-    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 };
+  async execute(input, _context) {
+    return await rotateImage(input);
+  }
+  async executePreview(input, _context) {
+    return await rotateImage(input);
   }
 }
 Workflow28.prototype.imageRotate = CreateWorkflow27(ImageRotateTask);
@@ -6822,6 +6899,32 @@ import {
   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];
+      }
+    }
+    return { data: dst, width, height, channels };
+  });
+  return { image };
+}
 var inputSchema53 = {
   type: "object",
   properties: {
@@ -6850,31 +6953,11 @@ class ImageSepiaTask extends Task54 {
   static outputSchema() {
     return outputSchema52;
   }
-  async executeReactive(input, _output, _context) {
-    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];
-        }
-      }
-      return { data: dst, width, height, channels };
-    });
-    return { image };
+  async execute(input, _context) {
+    return await applySepia(input);
+  }
+  async executePreview(input, _context) {
+    return await applySepia(input);
   }
 }
 Workflow29.prototype.imageSepia = CreateWorkflow28(ImageSepiaTask);
@@ -7039,6 +7122,48 @@ function hasUsableBackgroundImage(value) {
   const candidate = value;
   return typeof candidate.width === "number" && typeof candidate.height === "number" && typeof candidate.channels === "number" && candidate.data !== undefined;
 }
+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";
+  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
+    });
+  }
+  return { image };
+}
 
 class ImageTextTask extends Task55 {
   static type = "ImageTextTask";
@@ -7058,47 +7183,11 @@ class ImageTextTask extends Task55 {
     delete defaults.height;
     return defaults;
   }
-  async executeReactive(input, _output, _context) {
-    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";
-    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
-      });
-    }
-    return { image };
+  async execute(input, _context) {
+    return await renderImageText(input);
+  }
+  async executePreview(input, _context) {
+    return await renderImageText(input);
   }
 }
 Workflow30.prototype.imageText = CreateWorkflow29(ImageTextTask);
@@ -7108,6 +7197,26 @@ import {
   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 };
+}
 var inputSchema55 = {
   type: "object",
   properties: {
@@ -7144,25 +7253,11 @@ class ImageThresholdTask extends Task56 {
   static outputSchema() {
     return outputSchema54;
   }
-  async executeReactive(input, _output, _context) {
-    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 };
+  async execute(input, _context) {
+    return await applyThreshold(input);
+  }
+  async executePreview(input, _context) {
+    return await applyThreshold(input);
   }
 }
 Workflow31.prototype.imageThreshold = CreateWorkflow30(ImageThresholdTask);
@@ -7173,6 +7268,40 @@ import {
   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 };
+}
 var inputSchema56 = {
   type: "object",
   properties: {
@@ -7210,39 +7339,11 @@ class ImageTintTask extends Task57 {
   static outputSchema() {
     return outputSchema55;
   }
-  async executeReactive(input, _output, _context) {
-    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 };
+  async execute(input, _context) {
+    return await applyTint(input);
+  }
+  async executePreview(input, _context) {
+    return await applyTint(input);
   }
 }
 Workflow32.prototype.imageTint = CreateWorkflow31(ImageTintTask);
@@ -7252,6 +7353,26 @@ import {
   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 };
+}
 var inputSchema57 = {
   type: "object",
   properties: {
@@ -7290,25 +7411,11 @@ class ImageTransparencyTask extends Task58 {
   static outputSchema() {
     return outputSchema56;
   }
-  async executeReactive(input, _output, _context) {
-    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 };
+  async execute(input, _context) {
+    return await applyTransparency(input);
+  }
+  async executePreview(input, _context) {
+    return await applyTransparency(input);
   }
 }
 Workflow33.prototype.imageTransparency = CreateWorkflow32(ImageTransparencyTask);
@@ -7318,6 +7425,54 @@ import {
   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: {
@@ -7368,58 +7523,19 @@ class ImageWatermarkTask extends Task59 {
   static outputSchema() {
     return outputSchema57;
   }
-  async executeReactive(input, _output, _context) {
-    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 };
+  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";
+function passthroughInput(input) {
+  return input;
+}
 
 class InputTask extends Task60 {
   static type = "InputTask";
@@ -7449,8 +7565,11 @@ class InputTask extends Task60 {
   outputSchema() {
     return this.config?.outputSchema ?? this.constructor.outputSchema();
   }
-  async executeReactive(input) {
-    return input;
+  async execute(input, _context) {
+    return passthroughInput(input);
+  }
+  async executePreview(input) {
+    return passthroughInput(input);
   }
   async* executeStream(input, context) {
     if (context.inputStreams) {
@@ -11946,6 +12065,23 @@ Interpreter["Status"] = Interpreter.Status;
 
 // src/task/JavaScriptTask.ts
 var isValidIdentifier = (key) => /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key);
+function runJavaScript(input2, configuredCode) {
+  const output = {};
+  const code = input2.javascript_code || configuredCode;
+  if (code) {
+    try {
+      const inputVariables = Object.keys(input2).filter((key) => key !== "javascript_code").filter(isValidIdentifier);
+      const inputVariablesString = inputVariables.map((key) => `var ${key} = ${JSON.stringify(input2[key])};`).join(`
+`);
+      const myInterpreter = new Interpreter(`${inputVariablesString} ${code}`);
+      myInterpreter.run();
+      output.output = myInterpreter.value;
+    } catch (e) {
+      throw new TaskInvalidInputError3(`JavaScript execution failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  return output;
+}
 var configSchema = {
   type: "object",
   properties: {
@@ -12025,21 +12161,11 @@ class JavaScriptTask extends Task61 {
     }
     return inputSchema59;
   }
-  async executeReactive(input2, output) {
-    const code = input2.javascript_code || this.config.javascript_code;
-    if (code) {
-      try {
-        const inputVariables = Object.keys(input2).filter((key) => key !== "javascript_code").filter(isValidIdentifier);
-        const inputVariablesString = inputVariables.map((key) => `var ${key} = ${JSON.stringify(input2[key])};`).join(`
-`);
-        const myInterpreter = new Interpreter(`${inputVariablesString} ${code}`);
-        myInterpreter.run();
-        output.output = myInterpreter.value;
-      } catch (e) {
-        throw new TaskInvalidInputError3(`JavaScript execution failed: ${e instanceof Error ? e.message : String(e)}`);
-      }
-    }
-    return output;
+  async execute(input2) {
+    return runJavaScript(input2, this.config.javascript_code);
+  }
+  async executePreview(input2) {
+    return runJavaScript(input2, this.config.javascript_code);
   }
 }
 var javaScript = (input2, config = {}) => {
@@ -12100,6 +12226,10 @@ function resolvePath(obj, segments) {
   const next2 = obj[head];
   return resolvePath(next2, tail);
 }
+function extractJsonPath(value, path) {
+  const segments = path.split(".");
+  return resolvePath(value, segments);
+}
 
 class JsonPathTask extends Task62 {
   static type = "JsonPathTask";
@@ -12112,10 +12242,11 @@ class JsonPathTask extends Task62 {
   static outputSchema() {
     return outputSchema59;
   }
-  async executeReactive(input2, _output, _context) {
-    const segments = input2.path.split(".");
-    const result = resolvePath(input2.value, segments);
-    return { result };
+  async execute(input2, _context) {
+    return { result: extractJsonPath(input2.value, input2.path) };
+  }
+  async executePreview(input2, _context) {
+    return { result: extractJsonPath(input2.value, input2.path) };
   }
 }
 Workflow37.prototype.jsonPath = CreateWorkflow36(JsonPathTask);
@@ -12209,7 +12340,7 @@ var lambdaTaskConfigSchema = {
   properties: {
     ...TaskConfigSchema33["properties"],
     execute: {},
-    executeReactive: {}
+    executePreview: {}
   },
   additionalProperties: false
 };
@@ -12253,8 +12384,8 @@ class LambdaTask extends Task63 {
     return false;
   }
   constructor(config = {}) {
-    if (!config.execute && !config.executeReactive) {
-      throw new TaskConfigurationError4("LambdaTask must have either execute or executeReactive function in config");
+    if (!config.execute && !config.executePreview) {
+      throw new TaskConfigurationError4("LambdaTask must have either execute or executePreview function in config");
     }
     super(config);
   }
@@ -12264,11 +12395,11 @@ class LambdaTask extends Task63 {
     }
     return {};
   }
-  async executeReactive(input2, output, context) {
-    if (typeof this.config.executeReactive === "function") {
-      return await this.config.executeReactive(input2, output, context) ?? output;
+  async executePreview(input2, context) {
+    if (typeof this.config.executePreview === "function") {
+      return await this.config.executePreview(input2, context);
     }
-    return output;
+    return;
   }
 }
 function lambda(input2, config) {
@@ -13548,6 +13679,9 @@ var merge = (input2, config = {}) => {
 Workflow45.prototype.merge = CreateWorkflow44(MergeTask);
 // src/task/OutputTask.ts
 import { CreateWorkflow as CreateWorkflow45, Task as Task70, Workflow as Workflow46 } from "@workglow/task-graph";
+function passthroughInput2(input2) {
+  return input2;
+}
 
 class OutputTask extends Task70 {
   static type = "OutputTask";
@@ -13578,8 +13712,11 @@ class OutputTask extends Task70 {
   outputSchema() {
     return this.config?.outputSchema ?? this.constructor.outputSchema();
   }
-  async executeReactive(input2) {
-    return input2;
+  async execute(input2, _context) {
+    return passthroughInput2(input2);
+  }
+  async executePreview(input2) {
+    return passthroughInput2(input2);
   }
   async* executeStream(input2, context) {
     if (context.inputStreams) {
@@ -13615,6 +13752,32 @@ function hasNestedQuantifiers(pattern) {
   const withoutClasses = pattern.replace(/\[(?:[^\]\\]|\\.)*\]/g, "X");
   return /\([^)]*[+*][^)]*\)[+*?]|\([^)]*[+*][^)]*\)\{/.test(withoutClasses);
 }
+function executeRegex(input2) {
+  const bracketCount = (input2.pattern.match(/\[/g) ?? []).length;
+  if (bracketCount > MAX_BRACKET_COUNT) {
+    throw new TaskInvalidInputError4("Regex pattern rejected: too many '[' characters (potential ReDoS). " + "Simplify the pattern to reduce complexity.");
+  }
+  if (hasNestedQuantifiers(input2.pattern)) {
+    throw new TaskInvalidInputError4("Regex pattern rejected: nested quantifiers detected (potential ReDoS). " + "Simplify the pattern to avoid catastrophic backtracking.");
+  }
+  const flags = input2.flags ?? "";
+  const regex = new RegExp(input2.pattern, flags);
+  if (flags.includes("g")) {
+    const allMatches = Array.from(input2.value.matchAll(new RegExp(input2.pattern, flags)));
+    return {
+      match: allMatches.length > 0,
+      matches: allMatches.map((m) => m[0])
+    };
+  }
+  const result = regex.exec(input2.value);
+  if (!result) {
+    return { match: false, matches: [] };
+  }
+  return {
+    match: true,
+    matches: result.slice(0)
+  };
+}
 var inputSchema65 = {
   type: "object",
   properties: {
@@ -13668,31 +13831,11 @@ class RegexTask extends Task71 {
   static outputSchema() {
     return outputSchema64;
   }
-  async executeReactive(input2, _output, _context) {
-    const bracketCount = (input2.pattern.match(/\[/g) ?? []).length;
-    if (bracketCount > MAX_BRACKET_COUNT) {
-      throw new TaskInvalidInputError4("Regex pattern rejected: too many '[' characters (potential ReDoS). " + "Simplify the pattern to reduce complexity.");
-    }
-    if (hasNestedQuantifiers(input2.pattern)) {
-      throw new TaskInvalidInputError4("Regex pattern rejected: nested quantifiers detected (potential ReDoS). " + "Simplify the pattern to avoid catastrophic backtracking.");
-    }
-    const flags = input2.flags ?? "";
-    const regex = new RegExp(input2.pattern, flags);
-    if (flags.includes("g")) {
-      const allMatches = Array.from(input2.value.matchAll(new RegExp(input2.pattern, flags)));
-      return {
-        match: allMatches.length > 0,
-        matches: allMatches.map((m) => m[0])
-      };
-    }
-    const result = regex.exec(input2.value);
-    if (!result) {
-      return { match: false, matches: [] };
-    }
-    return {
-      match: true,
-      matches: result.slice(0)
-    };
+  async execute(input2, _context) {
+    return executeRegex(input2);
+  }
+  async executePreview(input2, _context) {
+    return executeRegex(input2);
   }
 }
 Workflow47.prototype.regex = CreateWorkflow46(RegexTask);
@@ -14016,6 +14159,17 @@ var outputSchema72 = {
   properties: {},
   additionalProperties: true
 };
+function fanoutToIndexedOutputs(inputValue) {
+  const output = {};
+  if (Array.isArray(inputValue)) {
+    inputValue.forEach((item, index) => {
+      output[`output_${index}`] = item;
+    });
+  } else {
+    output.output_0 = inputValue;
+  }
+  return output;
+}
 
 class SplitTask extends Task79 {
   static type = "SplitTask";
@@ -14029,17 +14183,11 @@ class SplitTask extends Task79 {
   static outputSchema() {
     return outputSchema72;
   }
-  async executeReactive(input2) {
-    const inputValue = input2.input;
-    const output = {};
-    if (Array.isArray(inputValue)) {
-      inputValue.forEach((item, index) => {
-        output[`output_${index}`] = item;
-      });
-    } else {
-      output.output_0 = inputValue;
-    }
-    return output;
+  async execute(input2, _context) {
+    return fanoutToIndexedOutputs(input2.input);
+  }
+  async executePreview(input2) {
+    return fanoutToIndexedOutputs(input2.input);
   }
 }
 var split = (input2, config = {}) => {
@@ -14053,6 +14201,9 @@ import {
   Task as Task80,
   Workflow as Workflow56
 } from "@workglow/task-graph";
+function concatStrings(input2) {
+  return Object.values(input2).join("");
+}
 var inputSchema74 = {
   type: "object",
   properties: {},
@@ -14082,8 +14233,11 @@ class StringConcatTask extends Task80 {
   static outputSchema() {
     return outputSchema73;
   }
-  async executeReactive(input2, _output, _context) {
-    return { text: Object.values(input2).join("") };
+  async execute(input2, _context) {
+    return { text: concatStrings(input2) };
+  }
+  async executePreview(input2, _context) {
+    return { text: concatStrings(input2) };
   }
 }
 Workflow56.prototype.stringConcat = CreateWorkflow55(StringConcatTask);
@@ -14093,6 +14247,9 @@ import {
   Task as Task81,
   Workflow as Workflow57
 } from "@workglow/task-graph";
+function stringIncludes(text, search) {
+  return text.includes(search);
+}
 var inputSchema75 = {
   type: "object",
   properties: {
@@ -14134,8 +14291,11 @@ class StringIncludesTask extends Task81 {
   static outputSchema() {
     return outputSchema74;
   }
-  async executeReactive(input2, _output, _context) {
-    return { included: input2.text.includes(input2.search) };
+  async execute(input2, _context) {
+    return { included: stringIncludes(input2.text, input2.search) };
+  }
+  async executePreview(input2, _context) {
+    return { included: stringIncludes(input2.text, input2.search) };
   }
 }
 Workflow57.prototype.stringIncludes = CreateWorkflow56(StringIncludesTask);
@@ -14145,6 +14305,9 @@ import {
   Task as Task82,
   Workflow as Workflow58
 } from "@workglow/task-graph";
+function joinStrings(texts, separator) {
+  return texts.join(separator ?? "");
+}
 var inputSchema76 = {
   type: "object",
   properties: {
@@ -14188,9 +14351,11 @@ class StringJoinTask extends Task82 {
   static outputSchema() {
     return outputSchema75;
   }
-  async executeReactive(input2, _output, _context) {
-    const separator = input2.separator ?? "";
-    return { text: input2.texts.join(separator) };
+  async execute(input2, _context) {
+    return { text: joinStrings(input2.texts, input2.separator) };
+  }
+  async executePreview(input2, _context) {
+    return { text: joinStrings(input2.texts, input2.separator) };
   }
 }
 Workflow58.prototype.stringJoin = CreateWorkflow57(StringJoinTask);
@@ -14200,6 +14365,9 @@ import {
   Task as Task83,
   Workflow as Workflow59
 } from "@workglow/task-graph";
+function stringLength(text) {
+  return text.length;
+}
 var inputSchema77 = {
   type: "object",
   properties: {
@@ -14236,8 +14404,11 @@ class StringLengthTask extends Task83 {
   static outputSchema() {
     return outputSchema76;
   }
-  async executeReactive(input2, _output, _context) {
-    return { length: input2.text.length };
+  async execute(input2, _context) {
+    return { length: stringLength(input2.text) };
+  }
+  async executePreview(input2, _context) {
+    return { length: stringLength(input2.text) };
   }
 }
 Workflow59.prototype.stringLength = CreateWorkflow58(StringLengthTask);
@@ -14247,6 +14418,9 @@ import {
   Task as Task84,
   Workflow as Workflow60
 } from "@workglow/task-graph";
+function toLowerCase(text) {
+  return text.toLowerCase();
+}
 var inputSchema78 = {
   type: "object",
   properties: {
@@ -14283,8 +14457,11 @@ class StringLowerCaseTask extends Task84 {
   static outputSchema() {
     return outputSchema77;
   }
-  async executeReactive(input2, _output, _context) {
-    return { text: input2.text.toLowerCase() };
+  async execute(input2, _context) {
+    return { text: toLowerCase(input2.text) };
+  }
+  async executePreview(input2, _context) {
+    return { text: toLowerCase(input2.text) };
   }
 }
 Workflow60.prototype.stringLowerCase = CreateWorkflow59(StringLowerCaseTask);
@@ -14294,6 +14471,9 @@ import {
   Task as Task85,
   Workflow as Workflow61
 } from "@workglow/task-graph";
+function replaceString(text, search, replace) {
+  return text.replaceAll(search, replace);
+}
 var inputSchema79 = {
   type: "object",
   properties: {
@@ -14340,8 +14520,11 @@ class StringReplaceTask extends Task85 {
   static outputSchema() {
     return outputSchema78;
   }
-  async executeReactive(input2, _output, _context) {
-    return { text: input2.text.replaceAll(input2.search, input2.replace) };
+  async execute(input2, _context) {
+    return { text: replaceString(input2.text, input2.search, input2.replace) };
+  }
+  async executePreview(input2, _context) {
+    return { text: replaceString(input2.text, input2.search, input2.replace) };
   }
 }
 Workflow61.prototype.stringReplace = CreateWorkflow60(StringReplaceTask);
@@ -14351,6 +14534,9 @@ import {
   Task as Task86,
   Workflow as Workflow62
 } from "@workglow/task-graph";
+function sliceString(text, start, end) {
+  return text.slice(start, end);
+}
 var inputSchema80 = {
   type: "object",
   properties: {
@@ -14397,8 +14583,11 @@ class StringSliceTask extends Task86 {
   static outputSchema() {
     return outputSchema79;
   }
-  async executeReactive(input2, _output, _context) {
-    return { text: input2.text.slice(input2.start, input2.end) };
+  async execute(input2, _context) {
+    return { text: sliceString(input2.text, input2.start, input2.end) };
+  }
+  async executePreview(input2, _context) {
+    return { text: sliceString(input2.text, input2.start, input2.end) };
   }
 }
 Workflow62.prototype.stringSlice = CreateWorkflow61(StringSliceTask);
@@ -14408,6 +14597,13 @@ import {
   Task as Task87,
   Workflow as Workflow63
 } from "@workglow/task-graph";
+function renderStringTemplate(template, values) {
+  let text = template;
+  for (const [key, value] of Object.entries(values)) {
+    text = text.replaceAll(`{{${key}}}`, String(value));
+  }
+  return text;
+}
 var inputSchema81 = {
   type: "object",
   properties: {
@@ -14450,12 +14646,11 @@ class StringTemplateTask extends Task87 {
   static outputSchema() {
     return outputSchema80;
   }
-  async executeReactive(input2, _output, _context) {
-    let text = input2.template;
-    for (const [key, value] of Object.entries(input2.values)) {
-      text = text.replaceAll(`{{${key}}}`, String(value));
-    }
-    return { text };
+  async execute(input2, _context) {
+    return { text: renderStringTemplate(input2.template, input2.values) };
+  }
+  async executePreview(input2, _context) {
+    return { text: renderStringTemplate(input2.template, input2.values) };
   }
 }
 Workflow63.prototype.stringTemplate = CreateWorkflow62(StringTemplateTask);
@@ -14465,6 +14660,9 @@ import {
   Task as Task88,
   Workflow as Workflow64
 } from "@workglow/task-graph";
+function trimString(text) {
+  return text.trim();
+}
 var inputSchema82 = {
   type: "object",
   properties: {
@@ -14501,8 +14699,11 @@ class StringTrimTask extends Task88 {
   static outputSchema() {
     return outputSchema81;
   }
-  async executeReactive(input2, _output, _context) {
-    return { text: input2.text.trim() };
+  async execute(input2, _context) {
+    return { text: trimString(input2.text) };
+  }
+  async executePreview(input2, _context) {
+    return { text: trimString(input2.text) };
   }
 }
 Workflow64.prototype.stringTrim = CreateWorkflow63(StringTrimTask);
@@ -14512,6 +14713,9 @@ import {
   Task as Task89,
   Workflow as Workflow65
 } from "@workglow/task-graph";
+function toUpperCase(text) {
+  return text.toUpperCase();
+}
 var inputSchema83 = {
   type: "object",
   properties: {
@@ -14548,8 +14752,11 @@ class StringUpperCaseTask extends Task89 {
   static outputSchema() {
     return outputSchema82;
   }
-  async executeReactive(input2, _output, _context) {
-    return { text: input2.text.toUpperCase() };
+  async execute(input2, _context) {
+    return { text: toUpperCase(input2.text) };
+  }
+  async executePreview(input2, _context) {
+    return { text: toUpperCase(input2.text) };
   }
 }
 Workflow65.prototype.stringUpperCase = CreateWorkflow64(StringUpperCaseTask);
@@ -14559,6 +14766,24 @@ import {
   Task as Task90,
   Workflow as Workflow66
 } from "@workglow/task-graph";
+function renderTemplate(template, values) {
+  return template.replace(/\{\{([^{}]+)\}\}/g, (_match, expr) => {
+    const [path, defaultValue] = expr.split("|").map((s) => s.trim());
+    const segments = path.split(".");
+    let current = values;
+    for (const segment of segments) {
+      if (current === null || current === undefined || typeof current !== "object") {
+        current = undefined;
+        break;
+      }
+      current = current[segment];
+    }
+    if (current !== undefined && current !== null) {
+      return String(current);
+    }
+    return defaultValue !== undefined ? defaultValue : "";
+  });
+}
 var inputSchema84 = {
   type: "object",
   properties: {
@@ -14601,24 +14826,11 @@ class TemplateTask extends Task90 {
   static outputSchema() {
     return outputSchema83;
   }
-  async executeReactive(input2, _output, _context) {
-    const result = input2.template.replace(/\{\{([^}]+)\}\}/g, (_match, expr) => {
-      const [path, defaultValue] = expr.split("|").map((s) => s.trim());
-      const segments = path.split(".");
-      let current = input2.values;
-      for (const segment of segments) {
-        if (current === null || current === undefined || typeof current !== "object") {
-          current = undefined;
-          break;
-        }
-        current = current[segment];
-      }
-      if (current !== undefined && current !== null) {
-        return String(current);
-      }
-      return defaultValue !== undefined ? defaultValue : "";
-    });
-    return { result };
+  async execute(input2, _context) {
+    return { result: renderTemplate(input2.template, input2.values) };
+  }
+  async executePreview(input2, _context) {
+    return { result: renderTemplate(input2.template, input2.values) };
   }
 }
 Workflow66.prototype.template = CreateWorkflow65(TemplateTask);
@@ -16326,4 +16538,4 @@ export {
   ArrayTask
 };
 
-//# debugId=0C340BEB980722A064756E2164756E21
+//# debugId=5A05433CE5000E5A64756E2164756E21