@workglow/tasks 0.0.102 → 0.0.104

package/dist/bun.js

@@ -4,1090 +4,436 @@ var __require = import.meta.require;
 // src/bun.ts
 import { TaskRegistry as TaskRegistry2 } from "@workglow/task-graph";
 
-// src/task/FileLoaderTask.server.ts
-import {
-  CreateWorkflow as CreateWorkflow3,
-  TaskAbortedError as TaskAbortedError2,
-  Workflow as Workflow3
-} from "@workglow/task-graph";
-import { readFile } from "fs/promises";
+// src/task/adaptive.ts
+import { CreateAdaptiveWorkflow, Workflow as Workflow10 } from "@workglow/task-graph";
 
-// src/task/FileLoaderTask.ts
-import {
-  CreateWorkflow as CreateWorkflow2,
-  Task,
-  TaskAbortedError,
-  Workflow as Workflow2
-} from "@workglow/task-graph";
-import Papa from "papaparse";
+// src/task/scalar/ScalarAddTask.ts
+import { CreateWorkflow, Task, Workflow } from "@workglow/task-graph";
 
-// src/task/FetchUrlTask.ts
-import {
-  AbortSignalJobError,
-  Job,
-  PermanentJobError,
-  RetryableJobError
-} from "@workglow/job-queue";
-import {
-  CreateWorkflow,
-  JobQueueTask,
-  TaskConfigurationError,
-  TaskInvalidInputError,
-  Workflow
-} from "@workglow/task-graph";
+// src/task/scalar/sumPrecise.ts
+function kahanSum(values) {
+  let sum = 0;
+  let compensation = 0;
+  for (const value of values) {
+    const y = value - compensation;
+    const t = sum + y;
+    compensation = t - sum - y;
+    sum = t;
+  }
+  return sum;
+}
+var nativeSumPrecise = typeof Math.sumPrecise === "function" ? Math.sumPrecise : undefined;
+var sumPrecise = nativeSumPrecise ? nativeSumPrecise.bind(Math) : kahanSum;
+
+// src/task/scalar/ScalarAddTask.ts
 var inputSchema = {
   type: "object",
   properties: {
-    url: {
-      type: "string",
-      title: "URL",
-      description: "The URL to fetch from",
-      format: "uri"
-    },
-    method: {
-      enum: ["GET", "POST", "PUT", "DELETE", "PATCH"],
-      title: "Method",
-      description: "The HTTP method to use",
-      default: "GET"
-    },
-    headers: {
-      type: "object",
-      additionalProperties: {
-        type: "string"
-      },
-      title: "Headers",
-      description: "The headers to send with the request"
-    },
-    body: {
-      type: "string",
-      title: "Body",
-      description: "The body of the request"
-    },
-    response_type: {
-      anyOf: [{ type: "null" }, { enum: ["json", "text", "blob", "arraybuffer"] }],
-      title: "Response Type",
-      description: "The forced type of response to return. If null, the response type is inferred from the Content-Type header.",
-      default: null
-    },
-    timeout: {
+    a: {
       type: "number",
-      title: "Timeout",
-      description: "Request timeout in milliseconds"
+      title: "A",
+      description: "First number"
     },
-    queue: {
-      oneOf: [{ type: "boolean" }, { type: "string" }],
-      description: "Queue handling: false=run inline, true=use default, string=explicit queue name",
-      default: true,
-      "x-ui-hidden": true
+    b: {
+      type: "number",
+      title: "B",
+      description: "Second number"
     }
   },
-  required: ["url"],
+  required: ["a", "b"],
   additionalProperties: false
 };
 var outputSchema = {
   type: "object",
   properties: {
-    json: {
-      title: "JSON",
-      description: "The JSON response"
-    },
-    text: {
-      type: "string",
-      title: "Text",
-      description: "The text response"
-    },
-    blob: {
-      title: "Blob",
-      description: "The blob response"
-    },
-    arraybuffer: {
-      title: "ArrayBuffer",
-      description: "The arraybuffer response"
-    },
-    metadata: {
-      type: "object",
-      properties: {
-        contentType: { type: "string" },
-        headers: { type: "object", additionalProperties: { type: "string" } }
-      },
-      additionalProperties: false,
-      title: "Response Metadata",
-      description: "HTTP response metadata including content type and headers"
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Sum of a and b"
     }
   },
+  required: ["result"],
   additionalProperties: false
 };
-async function fetchWithProgress(url, options = {}, onProgress) {
-  if (!options.signal) {
-    throw new TaskConfigurationError("An AbortSignal must be provided.");
-  }
-  const response = await globalThis.fetch(url, options);
-  if (!response.body) {
-    throw new Error("ReadableStream not supported in this environment.");
-  }
-  const contentLength = response.headers.get("Content-Length");
-  const totalBytes = contentLength ? parseInt(contentLength, 10) : 0;
-  let receivedBytes = 0;
-  const reader = response.body.getReader();
-  const stream = new ReadableStream({
-    start(controller) {
-      async function push() {
-        try {
-          while (true) {
-            if (options.signal?.aborted) {
-              controller.error(new AbortSignalJobError("Fetch aborted"));
-              reader.cancel();
-              return;
-            }
-            const { done, value } = await reader.read();
-            if (done) {
-              controller.close();
-              break;
-            }
-            controller.enqueue(value);
-            receivedBytes += value.length;
-            if (onProgress && totalBytes) {
-              await onProgress(receivedBytes / totalBytes * 100);
-            }
-          }
-        } catch (error) {
-          controller.error(error);
-        }
-      }
-      push();
-    },
-    cancel() {
-      reader.cancel();
-    }
-  });
-  return new Response(stream, {
-    headers: response.headers,
-    status: response.status,
-    statusText: response.statusText
-  });
-}
-
-class FetchUrlJob extends Job {
-  constructor(config = { input: {} }) {
-    super(config);
-  }
-  static type = "FetchUrlJob";
-  async execute(input, context) {
-    const response = await fetchWithProgress(input.url, {
-      method: input.method,
-      headers: input.headers,
-      body: input.body,
-      signal: context.signal
-    }, async (progress) => await context.updateProgress(progress));
-    if (response.ok) {
-      const contentType = response.headers.get("content-type") ?? "";
-      const headers = {};
-      response.headers.forEach((value, key) => {
-        headers[key] = value;
-      });
-      const metadata = {
-        contentType,
-        headers
-      };
-      let responseType = input.response_type;
-      if (!responseType) {
-        if (contentType.includes("application/json")) {
-          responseType = "json";
-        } else if (contentType.includes("text/")) {
-          responseType = "text";
-        } else if (contentType.includes("application/octet-stream")) {
-          responseType = "arraybuffer";
-        } else if (contentType.includes("application/pdf") || contentType.includes("image/") || contentType.includes("application/zip")) {
-          responseType = "blob";
-        } else {
-          responseType = "json";
-        }
-        input.response_type = responseType;
-      }
-      if (responseType === "json") {
-        return { json: await response.json(), metadata };
-      } else if (responseType === "text") {
-        return { text: await response.text(), metadata };
-      } else if (responseType === "blob") {
-        return { blob: await response.blob(), metadata };
-      } else if (responseType === "arraybuffer") {
-        return { arraybuffer: await response.arrayBuffer(), metadata };
-      }
-      throw new TaskInvalidInputError(`Invalid response type: ${responseType}`);
-    } else {
-      if (response.status === 429 || response.status === 503 || response.headers.get("Retry-After")) {
-        let retryDate;
-        const retryAfterStr = response.headers.get("Retry-After");
-        if (retryAfterStr) {
-          const parsedDate = new Date(retryAfterStr);
-          if (!isNaN(parsedDate.getTime()) && parsedDate > new Date) {
-            retryDate = parsedDate;
-          } else {
-            const retryAfterSeconds = parseInt(retryAfterStr) * 1000;
-            if (!isNaN(retryAfterSeconds)) {
-              retryDate = new Date(Date.now() + retryAfterSeconds);
-            }
-          }
-        }
-        throw new RetryableJobError(`Failed to fetch ${input.url}: ${response.status} ${response.statusText}`, retryDate);
-      } else {
-        throw new PermanentJobError(`Failed to fetch ${input.url}: ${response.status} ${response.statusText}`);
-      }
-    }
-  }
-}
 
-class FetchUrlTask extends JobQueueTask {
-  static type = "FetchUrlTask";
-  static category = "Input";
-  static title = "Fetch";
-  static description = "Fetches data from a URL with progress tracking and automatic retry handling";
-  static hasDynamicSchemas = true;
+class ScalarAddTask extends Task {
+  static type = "ScalarAddTask";
+  static category = "Math";
+  static title = "Add";
+  static description = "Returns the sum of two numbers";
   static inputSchema() {
     return inputSchema;
   }
   static outputSchema() {
     return outputSchema;
   }
-  outputSchema() {
-    const responseType = this.runInputData?.response_type ?? this.defaults?.response_type ?? null;
-    if (responseType === null || responseType === undefined) {
-      return this.constructor.outputSchema();
-    }
-    const staticSchema = this.constructor.outputSchema();
-    if (typeof staticSchema === "boolean") {
-      return staticSchema;
-    }
-    if (!staticSchema.properties) {
-      return staticSchema;
-    }
-    const properties = {};
-    if (responseType === "json" && staticSchema.properties.json) {
-      properties.json = staticSchema.properties.json;
-    } else if (responseType === "text" && staticSchema.properties.text) {
-      properties.text = staticSchema.properties.text;
-    } else if (responseType === "blob" && staticSchema.properties.blob) {
-      properties.blob = staticSchema.properties.blob;
-    } else if (responseType === "arraybuffer" && staticSchema.properties.arraybuffer) {
-      properties.arraybuffer = staticSchema.properties.arraybuffer;
-    }
-    if (staticSchema.properties.metadata) {
-      properties.metadata = staticSchema.properties.metadata;
-    }
-    if (Object.keys(properties).length === 0) {
-      return staticSchema;
-    }
-    return {
-      type: "object",
-      properties,
-      additionalProperties: false
-    };
-  }
-  constructor(input = {}, config = {}) {
-    config.queue = input?.queue ?? config.queue;
-    if (config.queue === undefined) {
-      config.queue = false;
-    }
-    super(input, config);
-    this.jobClass = FetchUrlJob;
-  }
-  setInput(input) {
-    if (!("response_type" in input)) {
-      super.setInput(input);
-      return;
-    }
-    const getCurrentResponseType = () => {
-      return this.runInputData?.response_type ?? this.defaults?.response_type ?? null;
-    };
-    const previousResponseType = getCurrentResponseType();
-    super.setInput(input);
-    const newResponseType = getCurrentResponseType();
-    if (previousResponseType !== newResponseType) {
-      this.emitSchemaChange();
-    }
-  }
-  async getDefaultQueueName(input) {
-    if (!input.url) {
-      return `fetch:${this.type}`;
-    }
-    try {
-      const hostname = new URL(input.url).hostname.toLowerCase();
-      const parts = hostname.split(".").filter(Boolean);
-      if (parts.length === 0) {
-        return `fetch:${this.type}`;
-      }
-      const domain = parts.length <= 2 ? parts.join(".") : parts.slice(-2).join(".");
-      return `fetch:${domain}`;
-    } catch {
-      return `fetch:${this.type}`;
-    }
+  async execute(input, _context) {
+    return { result: sumPrecise([input.a, input.b]) };
   }
 }
-var fetchUrl = async (input, config = {}) => {
-  const result = await new FetchUrlTask({}, config).run(input);
-  return result;
-};
-Workflow.prototype.fetch = CreateWorkflow(FetchUrlTask);
+Workflow.prototype.scalarAdd = CreateWorkflow(ScalarAddTask);
 
-// src/task/FileLoaderTask.ts
+// src/task/scalar/ScalarDivideTask.ts
+import { CreateWorkflow as CreateWorkflow2, Task as Task2, Workflow as Workflow2 } from "@workglow/task-graph";
 var inputSchema2 = {
   type: "object",
   properties: {
-    url: {
-      type: "string",
-      title: "URL",
-      description: "URL to load document from (http://, https://)",
-      format: "uri"
+    a: {
+      type: "number",
+      title: "A",
+      description: "Numerator"
     },
-    format: {
-      type: "string",
-      enum: ["text", "markdown", "json", "csv", "pdf", "image", "html", "auto"],
-      title: "Format",
-      description: "File format (auto-detected from URL if 'auto')",
-      default: "auto"
+    b: {
+      type: "number",
+      title: "B",
+      description: "Denominator"
     }
   },
-  required: ["url"],
+  required: ["a", "b"],
   additionalProperties: false
 };
 var outputSchema2 = {
   type: "object",
   properties: {
-    text: {
-      type: "string",
-      title: "Text",
-      description: "Text content (for text, markdown, html formats)"
-    },
-    json: {
-      title: "JSON",
-      description: "Parsed JSON object or array"
-    },
-    csv: {
-      type: "array",
-      title: "CSV",
-      description: "Parsed CSV data as array of objects"
-    },
-    image: {
-      type: "string",
-      title: "Image",
-      description: "Base64 data URL for image files",
-      format: "image:data-uri"
-    },
-    pdf: {
-      type: "string",
-      title: "PDF",
-      description: "Base64 data URL for PDF files"
-    },
-    metadata: {
-      type: "object",
-      properties: {
-        url: { type: "string" },
-        format: { type: "string" },
-        size: { type: "number" },
-        title: { type: "string" },
-        mimeType: { type: "string" }
-      },
-      additionalProperties: false,
-      title: "Metadata",
-      description: "File metadata"
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Quotient (a / b)"
     }
   },
-  required: ["metadata"],
+  required: ["result"],
   additionalProperties: false
 };
 
-class FileLoaderTask extends Task {
-  static type = "FileLoaderTask";
-  static category = "Document";
-  static title = "File Loader";
-  static description = "Load documents from URLs (http://, https://)";
-  static cacheable = true;
+class ScalarDivideTask extends Task2 {
+  static type = "ScalarDivideTask";
+  static category = "Math";
+  static title = "Divide";
+  static description = "Returns the quotient of two numbers (a / b)";
   static inputSchema() {
     return inputSchema2;
   }
   static outputSchema() {
     return outputSchema2;
   }
-  async execute(input, context) {
-    const { url, format = "auto" } = input;
-    if (context.signal.aborted) {
-      throw new TaskAbortedError("Task aborted");
-    }
-    await context.updateProgress(0, "Detecting file format");
-    const detectedFormat = this.detectFormat(url, format);
-    const responseType = this.detectResponseType(detectedFormat);
-    if (context.signal.aborted) {
-      throw new TaskAbortedError("Task aborted");
-    }
-    await context.updateProgress(10, `Fetching ${detectedFormat} file from ${url}`);
-    const fetchTask = context.own(new FetchUrlTask({
-      url,
-      response_type: responseType,
-      queue: false
-    }));
-    const response = await fetchTask.run();
-    if (context.signal.aborted) {
-      throw new TaskAbortedError("Task aborted");
+  async execute(input, _context) {
+    return { result: input.a / input.b };
+  }
+}
+Workflow2.prototype.scalarDivide = CreateWorkflow2(ScalarDivideTask);
+
+// src/task/scalar/ScalarMultiplyTask.ts
+import { CreateWorkflow as CreateWorkflow3, Task as Task3, Workflow as Workflow3 } from "@workglow/task-graph";
+var inputSchema3 = {
+  type: "object",
+  properties: {
+    a: {
+      type: "number",
+      title: "A",
+      description: "First number"
+    },
+    b: {
+      type: "number",
+      title: "B",
+      description: "Second number"
     }
-    await context.updateProgress(60, "Parsing file content");
-    const title = url.split("/").pop() || url;
-    const { text, json, csv, image, pdf, size, mimeType } = await this.parseResponse(response, url, detectedFormat);
-    if (context.signal.aborted) {
-      throw new TaskAbortedError("Task aborted");
+  },
+  required: ["a", "b"],
+  additionalProperties: false
+};
+var outputSchema3 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Product of a and b"
     }
-    await context.updateProgress(100, "File loaded successfully");
-    return {
-      text,
-      json,
-      csv,
-      image,
-      pdf,
-      metadata: {
-        url,
-        format: detectedFormat,
-        size,
-        title,
-        mimeType
-      }
-    };
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarMultiplyTask extends Task3 {
+  static type = "ScalarMultiplyTask";
+  static category = "Math";
+  static title = "Multiply";
+  static description = "Returns the product of two numbers";
+  static inputSchema() {
+    return inputSchema3;
   }
-  parseJsonContent(content) {
-    return JSON.parse(content);
+  static outputSchema() {
+    return outputSchema3;
   }
-  parseCsvContent(content) {
-    try {
-      const result = Papa.parse(content, {
-        header: true,
-        skipEmptyLines: true,
-        transformHeader: (header) => header.trim()
-      });
-      return result.data;
-    } catch (error) {
-      throw new Error(`Failed to parse CSV: ${error}`);
-    }
+  async execute(input, _context) {
+    return { result: input.a * input.b };
   }
-  async parseResponse(response, url, detectedFormat) {
-    const responseMimeType = response.metadata?.contentType || "";
-    if (detectedFormat === "json") {
-      if (!response.json) {
-        throw new Error(`Failed to load JSON from ${url}`);
-      }
-      const jsonData = response.json;
-      const content2 = JSON.stringify(jsonData, null, 2);
-      return {
-        text: undefined,
-        json: jsonData,
-        csv: undefined,
-        image: undefined,
-        pdf: undefined,
-        size: content2.length,
-        mimeType: responseMimeType || "application/json"
-      };
-    }
-    if (detectedFormat === "csv") {
-      const content2 = response.text || "";
-      if (!content2) {
-        throw new Error(`Failed to load CSV from ${url}`);
-      }
-      const csvData = this.parseCsvContent(content2);
-      return {
-        text: undefined,
-        json: undefined,
-        csv: csvData,
-        image: undefined,
-        pdf: undefined,
-        size: content2.length,
-        mimeType: responseMimeType || "text/csv"
-      };
-    }
-    if (detectedFormat === "image") {
-      if (!response.blob) {
-        throw new Error(`Failed to load image from ${url}`);
-      }
-      const blob = response.blob;
-      const mimeType2 = responseMimeType || (blob.type && blob.type !== "" ? blob.type : this.getImageMimeType(url));
-      const imageData = await this.blobToBase64DataURL(blob, mimeType2);
-      return {
-        text: undefined,
-        json: undefined,
-        csv: undefined,
-        image: imageData,
-        pdf: undefined,
-        size: blob.size,
-        mimeType: mimeType2
-      };
-    }
-    if (detectedFormat === "pdf") {
-      if (!response.blob) {
-        throw new Error(`Failed to load PDF from ${url}`);
-      }
-      const blob = response.blob;
-      const mimeType2 = responseMimeType || "application/pdf";
-      const pdfData = await this.blobToBase64DataURL(blob, mimeType2);
-      return {
-        text: undefined,
-        json: undefined,
-        csv: undefined,
-        image: undefined,
-        pdf: pdfData,
-        size: blob.size,
-        mimeType: mimeType2
-      };
+}
+Workflow3.prototype.scalarMultiply = CreateWorkflow3(ScalarMultiplyTask);
+
+// src/task/scalar/ScalarSubtractTask.ts
+import { CreateWorkflow as CreateWorkflow4, Task as Task4, Workflow as Workflow4 } from "@workglow/task-graph";
+var inputSchema4 = {
+  type: "object",
+  properties: {
+    a: {
+      type: "number",
+      title: "A",
+      description: "First number"
+    },
+    b: {
+      type: "number",
+      title: "B",
+      description: "Second number"
     }
-    const content = response.text || "";
-    if (!content) {
-      throw new Error(`Failed to load content from ${url}`);
+  },
+  required: ["a", "b"],
+  additionalProperties: false
+};
+var outputSchema4 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Difference (a - b)"
     }
-    const mimeType = responseMimeType || (detectedFormat === "markdown" ? "text/markdown" : detectedFormat === "html" ? "text/html" : "text/plain");
-    return {
-      text: content,
-      json: undefined,
-      csv: undefined,
-      image: undefined,
-      pdf: undefined,
-      size: content.length,
-      mimeType
-    };
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarSubtractTask extends Task4 {
+  static type = "ScalarSubtractTask";
+  static category = "Math";
+  static title = "Subtract";
+  static description = "Returns the difference of two numbers (a - b)";
+  static inputSchema() {
+    return inputSchema4;
   }
-  detectResponseType(detectedFormat) {
-    let responseType = "text";
-    if (detectedFormat === "json") {
-      responseType = "json";
-    } else if (detectedFormat === "image" || detectedFormat === "pdf") {
-      responseType = "blob";
-    } else if (detectedFormat === "csv" || detectedFormat === "text" || detectedFormat === "markdown" || detectedFormat === "html") {
-      responseType = "text";
-    }
-    return responseType;
+  static outputSchema() {
+    return outputSchema4;
   }
-  detectFormat(url, format) {
-    if (format === "auto") {
-      const urlLower = url.toLowerCase();
-      if (urlLower.endsWith(".md") || urlLower.endsWith(".markdown")) {
-        return "markdown";
-      } else if (urlLower.endsWith(".json")) {
-        return "json";
-      } else if (urlLower.endsWith(".csv")) {
-        return "csv";
-      } else if (urlLower.endsWith(".pdf")) {
-        return "pdf";
-      } else if (urlLower.match(/\.(jpg|jpeg|png|gif|bmp|webp|svg|ico)$/)) {
-        return "image";
-      } else if (urlLower.endsWith(".html") || urlLower.endsWith(".htm")) {
-        return "html";
-      } else {
-        return "text";
-      }
+  async execute(input, _context) {
+    return { result: input.a - input.b };
+  }
+}
+Workflow4.prototype.scalarSubtract = CreateWorkflow4(ScalarSubtractTask);
+
+// src/task/scalar/ScalarSumTask.ts
+import { CreateWorkflow as CreateWorkflow5, Task as Task5, Workflow as Workflow5 } from "@workglow/task-graph";
+var inputSchema5 = {
+  type: "object",
+  properties: {
+    values: {
+      type: "array",
+      items: { type: "number" },
+      title: "Values",
+      description: "Array of numbers to sum"
     }
-    return format;
+  },
+  required: ["values"],
+  additionalProperties: false
+};
+var outputSchema5 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Sum of all values"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarSumTask extends Task5 {
+  static type = "ScalarSumTask";
+  static category = "Math";
+  static title = "Sum";
+  static description = "Returns the sum of an array of numbers";
+  static inputSchema() {
+    return inputSchema5;
   }
-  getImageMimeType(url) {
-    const urlLower = url.toLowerCase();
-    if (urlLower.endsWith(".png"))
-      return "image/png";
-    if (urlLower.endsWith(".jpg") || urlLower.endsWith(".jpeg"))
-      return "image/jpeg";
-    if (urlLower.endsWith(".gif"))
-      return "image/gif";
-    if (urlLower.endsWith(".webp"))
-      return "image/webp";
-    if (urlLower.endsWith(".bmp"))
-      return "image/bmp";
-    if (urlLower.endsWith(".svg"))
-      return "image/svg+xml";
-    if (urlLower.endsWith(".ico"))
-      return "image/x-icon";
-    return "image/jpeg";
+  static outputSchema() {
+    return outputSchema5;
   }
-  async blobToBase64DataURL(blob, mimeType) {
-    if (typeof Buffer !== "undefined") {
-      const arrayBuffer = await blob.arrayBuffer();
-      const buffer = Buffer.from(arrayBuffer);
-      return `data:${mimeType};base64,${buffer.toString("base64")}`;
-    }
-    return new Promise((resolve, reject) => {
-      const reader = new FileReader;
-      reader.onloadend = () => {
-        const result = reader.result;
-        if (result.startsWith("data:;base64,")) {
-          resolve(`data:${mimeType};base64,${result.substring(13)}`);
-        } else {
-          resolve(result);
-        }
-      };
-      reader.onerror = reject;
-      reader.readAsDataURL(blob);
-    });
+  async execute(input, _context) {
+    return { result: sumPrecise(input.values) };
   }
 }
-Workflow2.prototype.fileLoader = CreateWorkflow2(FileLoaderTask);
+Workflow5.prototype.scalarSum = CreateWorkflow5(ScalarSumTask);
 
-// src/task/FileLoaderTask.server.ts
-class FileLoaderTask2 extends FileLoaderTask {
-  async execute(input, context) {
-    let { url, format = "auto" } = input;
-    if (url.startsWith("http://") || url.startsWith("https://")) {
-      return super.execute(input, context);
-    }
-    if (context.signal.aborted) {
-      throw new TaskAbortedError2("Task aborted");
+// src/task/vector/VectorDivideTask.ts
+import { CreateWorkflow as CreateWorkflow6, Task as Task6, Workflow as Workflow6 } from "@workglow/task-graph";
+import {
+  createTypedArrayFrom,
+  TypedArraySchema
+} from "@workglow/util";
+var inputSchema6 = {
+  type: "object",
+  properties: {
+    vectors: {
+      type: "array",
+      items: TypedArraySchema({
+        title: "Vector",
+        description: "Vector (first is numerator, rest are denominators)"
+      }),
+      title: "Vectors",
+      description: "Array of vectors: vectors[0] / vectors[1] / vectors[2] / ..."
     }
-    await context.updateProgress(0, "Detecting file format");
-    if (url.startsWith("file://")) {
-      url = url.slice(7);
+  },
+  required: ["vectors"],
+  additionalProperties: false
+};
+var outputSchema6 = {
+  type: "object",
+  properties: {
+    result: TypedArraySchema({
+      title: "Result",
+      description: "Component-wise quotient"
+    })
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class VectorDivideTask extends Task6 {
+  static type = "VectorDivideTask";
+  static category = "Vector";
+  static title = "Divide";
+  static description = "Returns component-wise quotient: vectors[0] / vectors[1] / vectors[2] / ...";
+  static inputSchema() {
+    return inputSchema6;
+  }
+  static outputSchema() {
+    return outputSchema6;
+  }
+  async execute(input, _context) {
+    const { vectors } = input;
+    if (vectors.length < 2) {
+      throw new Error("At least two vectors are required");
     }
-    const detectedFormat = this.detectFormat(url, format);
-    const title = url.split("/").pop() || url;
-    if (context.signal.aborted) {
-      throw new TaskAbortedError2("Task aborted");
-    }
-    await context.updateProgress(10, `Reading ${detectedFormat} file from filesystem`);
-    if (detectedFormat === "json") {
-      const fileContent2 = await readFile(url, { encoding: "utf-8" });
-      if (context.signal.aborted) {
-        throw new TaskAbortedError2("Task aborted");
-      }
-      await context.updateProgress(50, "Parsing JSON content");
-      const jsonData = this.parseJsonContent(fileContent2);
-      const content = JSON.stringify(jsonData, null, 2);
-      if (context.signal.aborted) {
-        throw new TaskAbortedError2("Task aborted");
-      }
-      await context.updateProgress(100, "File loaded successfully");
-      return {
-        text: undefined,
-        json: jsonData,
-        csv: undefined,
-        image: undefined,
-        pdf: undefined,
-        metadata: {
-          url,
-          format: detectedFormat,
-          size: content.length,
-          title,
-          mimeType: "application/json"
-        }
-      };
-    }
-    if (detectedFormat === "csv") {
-      const fileContent2 = await readFile(url, { encoding: "utf-8" });
-      if (!fileContent2) {
-        throw new Error(`Failed to load CSV from ${url}`);
-      }
-      if (context.signal.aborted) {
-        throw new TaskAbortedError2("Task aborted");
-      }
-      await context.updateProgress(50, "Parsing CSV content");
-      const csvData = this.parseCsvContent(fileContent2);
-      if (context.signal.aborted) {
-        throw new TaskAbortedError2("Task aborted");
-      }
-      await context.updateProgress(100, "File loaded successfully");
-      return {
-        text: undefined,
-        json: undefined,
-        csv: csvData,
-        image: undefined,
-        pdf: undefined,
-        metadata: {
-          url,
-          format: detectedFormat,
-          size: fileContent2.length,
-          title,
-          mimeType: "text/csv"
-        }
-      };
-    }
-    if (detectedFormat === "image") {
-      const fileBuffer = await readFile(url);
-      if (context.signal.aborted) {
-        throw new TaskAbortedError2("Task aborted");
-      }
-      await context.updateProgress(50, "Converting image to base64");
-      const mimeType2 = this.getImageMimeType(url);
-      const blob = new Blob([fileBuffer], { type: mimeType2 });
-      const imageData = await this.blobToBase64DataURL(blob, mimeType2);
-      if (context.signal.aborted) {
-        throw new TaskAbortedError2("Task aborted");
-      }
-      await context.updateProgress(100, "File loaded successfully");
-      return {
-        text: undefined,
-        json: undefined,
-        csv: undefined,
-        image: imageData,
-        pdf: undefined,
-        metadata: {
-          url,
-          format: detectedFormat,
-          size: fileBuffer.length,
-          title,
-          mimeType: mimeType2
-        }
-      };
-    }
-    if (detectedFormat === "pdf") {
-      const fileBuffer = await readFile(url);
-      if (context.signal.aborted) {
-        throw new TaskAbortedError2("Task aborted");
-      }
-      await context.updateProgress(50, "Converting PDF to base64");
-      const mimeType2 = "application/pdf";
-      const blob = new Blob([fileBuffer], { type: mimeType2 });
-      const pdfData = await this.blobToBase64DataURL(blob, mimeType2);
-      if (context.signal.aborted) {
-        throw new TaskAbortedError2("Task aborted");
+    const len = vectors[0].length;
+    for (let i = 1;i < vectors.length; i++) {
+      if (vectors[i].length !== len) {
+        throw new Error("All vectors must have the same length");
       }
-      await context.updateProgress(100, "File loaded successfully");
-      return {
-        text: undefined,
-        json: undefined,
-        csv: undefined,
-        image: undefined,
-        pdf: pdfData,
-        metadata: {
-          url,
-          format: detectedFormat,
-          size: fileBuffer.length,
-          title,
-          mimeType: mimeType2
-        }
-      };
     }
-    const fileContent = await readFile(url, { encoding: "utf-8" });
-    if (!fileContent) {
-      throw new Error(`Failed to load content from ${url}`);
-    }
-    if (context.signal.aborted) {
-      throw new TaskAbortedError2("Task aborted");
-    }
-    await context.updateProgress(50, `Parsing ${detectedFormat} content`);
-    const mimeType = detectedFormat === "markdown" ? "text/markdown" : detectedFormat === "html" ? "text/html" : "text/plain";
-    if (context.signal.aborted) {
-      throw new TaskAbortedError2("Task aborted");
-    }
-    await context.updateProgress(100, "File loaded successfully");
-    return {
-      text: fileContent,
-      json: undefined,
-      csv: undefined,
-      image: undefined,
-      pdf: undefined,
-      metadata: {
-        url,
-        format: detectedFormat,
-        size: fileContent.length,
-        title,
-        mimeType
+    const values = Array.from({ length: len }, (_, i) => {
+      let acc = Number(vectors[0][i]);
+      for (let j = 1;j < vectors.length; j++) {
+        acc /= Number(vectors[j][i]);
       }
-    };
-  }
-}
-var fileLoader = (input, config) => {
-  return new FileLoaderTask2({}, config).run(input);
-};
-Workflow3.prototype.fileLoader = CreateWorkflow3(FileLoaderTask2);
-
-// src/task/adaptive.ts
-import { CreateAdaptiveWorkflow, Workflow as Workflow13 } from "@workglow/task-graph";
-
-// src/task/scalar/ScalarAddTask.ts
-import { CreateWorkflow as CreateWorkflow4, Task as Task2, Workflow as Workflow4 } from "@workglow/task-graph";
-
-// src/task/scalar/sumPrecise.ts
-function kahanSum(values) {
-  let sum = 0;
-  let compensation = 0;
-  for (const value of values) {
-    const y = value - compensation;
-    const t = sum + y;
-    compensation = t - sum - y;
-    sum = t;
+      return acc;
+    });
+    return { result: createTypedArrayFrom(vectors, values) };
   }
-  return sum;
 }
-var nativeSumPrecise = typeof Math.sumPrecise === "function" ? Math.sumPrecise : undefined;
-var sumPrecise = nativeSumPrecise ? nativeSumPrecise.bind(Math) : kahanSum;
+Workflow6.prototype.vectorDivide = CreateWorkflow6(VectorDivideTask);
 
-// src/task/scalar/ScalarAddTask.ts
-var inputSchema3 = {
+// src/task/vector/VectorMultiplyTask.ts
+import { CreateWorkflow as CreateWorkflow7, Task as Task7, Workflow as Workflow7 } from "@workglow/task-graph";
+import {
+  createTypedArrayFrom as createTypedArrayFrom2,
+  TypedArraySchema as TypedArraySchema2
+} from "@workglow/util";
+var inputSchema7 = {
   type: "object",
   properties: {
-    a: {
-      type: "number",
-      title: "A",
-      description: "First number"
-    },
-    b: {
-      type: "number",
-      title: "B",
-      description: "Second number"
+    vectors: {
+      type: "array",
+      items: TypedArraySchema2({
+        title: "Vector",
+        description: "Vector for component-wise product"
+      }),
+      title: "Vectors",
+      description: "Array of vectors to multiply component-wise"
     }
   },
-  required: ["a", "b"],
+  required: ["vectors"],
   additionalProperties: false
 };
-var outputSchema3 = {
+var outputSchema7 = {
   type: "object",
   properties: {
-    result: {
-      type: "number",
+    result: TypedArraySchema2({
       title: "Result",
-      description: "Sum of a and b"
-    }
+      description: "Component-wise product (Hadamard product)"
+    })
   },
   required: ["result"],
   additionalProperties: false
 };
 
-class ScalarAddTask extends Task2 {
-  static type = "ScalarAddTask";
-  static category = "Math";
-  static title = "Add";
-  static description = "Returns the sum of two numbers";
+class VectorMultiplyTask extends Task7 {
+  static type = "VectorMultiplyTask";
+  static category = "Vector";
+  static title = "Multiply";
+  static description = "Returns the component-wise product (Hadamard product) of all vectors";
   static inputSchema() {
-    return inputSchema3;
+    return inputSchema7;
   }
   static outputSchema() {
-    return outputSchema3;
+    return outputSchema7;
   }
   async execute(input, _context) {
-    return { result: sumPrecise([input.a, input.b]) };
+    const { vectors } = input;
+    if (vectors.length === 0) {
+      throw new Error("At least one vector is required");
+    }
+    const len = vectors[0].length;
+    for (let i = 1;i < vectors.length; i++) {
+      if (vectors[i].length !== len) {
+        throw new Error("All vectors must have the same length");
+      }
+    }
+    const values = Array.from({ length: len }, (_, i) => vectors.reduce((acc, v) => acc * Number(v[i]), 1));
+    return { result: createTypedArrayFrom2(vectors, values) };
   }
 }
-Workflow4.prototype.scalarAdd = CreateWorkflow4(ScalarAddTask);
+Workflow7.prototype.vectorMultiply = CreateWorkflow7(VectorMultiplyTask);
 
-// src/task/scalar/ScalarDivideTask.ts
-import { CreateWorkflow as CreateWorkflow5, Task as Task3, Workflow as Workflow5 } from "@workglow/task-graph";
-var inputSchema4 = {
+// src/task/vector/VectorSubtractTask.ts
+import { CreateWorkflow as CreateWorkflow8, Task as Task8, Workflow as Workflow8 } from "@workglow/task-graph";
+import {
+  createTypedArrayFrom as createTypedArrayFrom3,
+  TypedArraySchema as TypedArraySchema3
+} from "@workglow/util";
+var inputSchema8 = {
   type: "object",
   properties: {
-    a: {
-      type: "number",
-      title: "A",
-      description: "Numerator"
-    },
-    b: {
-      type: "number",
-      title: "B",
-      description: "Denominator"
+    vectors: {
+      type: "array",
+      items: TypedArraySchema3({
+        title: "Vector",
+        description: "Vector (first is minuend, rest are subtrahends)"
+      }),
+      title: "Vectors",
+      description: "Array of vectors: vectors[0] - vectors[1] - vectors[2] - ..."
     }
   },
-  required: ["a", "b"],
+  required: ["vectors"],
   additionalProperties: false
 };
-var outputSchema4 = {
+var outputSchema8 = {
   type: "object",
   properties: {
-    result: {
-      type: "number",
-      title: "Result",
-      description: "Quotient (a / b)"
-    }
-  },
-  required: ["result"],
-  additionalProperties: false
-};
-
-class ScalarDivideTask extends Task3 {
-  static type = "ScalarDivideTask";
-  static category = "Math";
-  static title = "Divide";
-  static description = "Returns the quotient of two numbers (a / b)";
-  static inputSchema() {
-    return inputSchema4;
-  }
-  static outputSchema() {
-    return outputSchema4;
-  }
-  async execute(input, _context) {
-    return { result: input.a / input.b };
-  }
-}
-Workflow5.prototype.scalarDivide = CreateWorkflow5(ScalarDivideTask);
-
-// src/task/scalar/ScalarMultiplyTask.ts
-import { CreateWorkflow as CreateWorkflow6, Task as Task4, Workflow as Workflow6 } from "@workglow/task-graph";
-var inputSchema5 = {
-  type: "object",
-  properties: {
-    a: {
-      type: "number",
-      title: "A",
-      description: "First number"
-    },
-    b: {
-      type: "number",
-      title: "B",
-      description: "Second number"
-    }
-  },
-  required: ["a", "b"],
-  additionalProperties: false
-};
-var outputSchema5 = {
-  type: "object",
-  properties: {
-    result: {
-      type: "number",
-      title: "Result",
-      description: "Product of a and b"
-    }
-  },
-  required: ["result"],
-  additionalProperties: false
-};
-
-class ScalarMultiplyTask extends Task4 {
-  static type = "ScalarMultiplyTask";
-  static category = "Math";
-  static title = "Multiply";
-  static description = "Returns the product of two numbers";
-  static inputSchema() {
-    return inputSchema5;
-  }
-  static outputSchema() {
-    return outputSchema5;
-  }
-  async execute(input, _context) {
-    return { result: input.a * input.b };
-  }
-}
-Workflow6.prototype.scalarMultiply = CreateWorkflow6(ScalarMultiplyTask);
-
-// src/task/scalar/ScalarSubtractTask.ts
-import { CreateWorkflow as CreateWorkflow7, Task as Task5, Workflow as Workflow7 } from "@workglow/task-graph";
-var inputSchema6 = {
-  type: "object",
-  properties: {
-    a: {
-      type: "number",
-      title: "A",
-      description: "First number"
-    },
-    b: {
-      type: "number",
-      title: "B",
-      description: "Second number"
-    }
-  },
-  required: ["a", "b"],
-  additionalProperties: false
-};
-var outputSchema6 = {
-  type: "object",
-  properties: {
-    result: {
-      type: "number",
-      title: "Result",
-      description: "Difference (a - b)"
-    }
-  },
-  required: ["result"],
-  additionalProperties: false
-};
-
-class ScalarSubtractTask extends Task5 {
-  static type = "ScalarSubtractTask";
-  static category = "Math";
-  static title = "Subtract";
-  static description = "Returns the difference of two numbers (a - b)";
-  static inputSchema() {
-    return inputSchema6;
-  }
-  static outputSchema() {
-    return outputSchema6;
-  }
-  async execute(input, _context) {
-    return { result: input.a - input.b };
-  }
-}
-Workflow7.prototype.scalarSubtract = CreateWorkflow7(ScalarSubtractTask);
-
-// src/task/scalar/ScalarSumTask.ts
-import { CreateWorkflow as CreateWorkflow8, Task as Task6, Workflow as Workflow8 } from "@workglow/task-graph";
-var inputSchema7 = {
-  type: "object",
-  properties: {
-    values: {
-      type: "array",
-      items: { type: "number" },
-      title: "Values",
-      description: "Array of numbers to sum"
-    }
-  },
-  required: ["values"],
-  additionalProperties: false
-};
-var outputSchema7 = {
-  type: "object",
-  properties: {
-    result: {
-      type: "number",
-      title: "Result",
-      description: "Sum of all values"
-    }
-  },
-  required: ["result"],
-  additionalProperties: false
-};
-
-class ScalarSumTask extends Task6 {
-  static type = "ScalarSumTask";
-  static category = "Math";
-  static title = "Sum";
-  static description = "Returns the sum of an array of numbers";
-  static inputSchema() {
-    return inputSchema7;
-  }
-  static outputSchema() {
-    return outputSchema7;
-  }
-  async execute(input, _context) {
-    return { result: sumPrecise(input.values) };
-  }
-}
-Workflow8.prototype.scalarSum = CreateWorkflow8(ScalarSumTask);
-
-// src/task/vector/VectorDivideTask.ts
-import { CreateWorkflow as CreateWorkflow9, Task as Task7, Workflow as Workflow9 } from "@workglow/task-graph";
-import {
-  createTypedArrayFrom,
-  TypedArraySchema
-} from "@workglow/util";
-var inputSchema8 = {
-  type: "object",
-  properties: {
-    vectors: {
-      type: "array",
-      items: TypedArraySchema({
-        title: "Vector",
-        description: "Vector (first is numerator, rest are denominators)"
-      }),
-      title: "Vectors",
-      description: "Array of vectors: vectors[0] / vectors[1] / vectors[2] / ..."
-    }
-  },
-  required: ["vectors"],
-  additionalProperties: false
-};
-var outputSchema8 = {
-  type: "object",
-  properties: {
-    result: TypedArraySchema({
+    result: TypedArraySchema3({
       title: "Result",
-      description: "Component-wise quotient"
+      description: "Difference of vectors"
     })
   },
   required: ["result"],
   additionalProperties: false
 };
 
-class VectorDivideTask extends Task7 {
-  static type = "VectorDivideTask";
+class VectorSubtractTask extends Task8 {
+  static type = "VectorSubtractTask";
   static category = "Vector";
-  static title = "Divide";
-  static description = "Returns component-wise quotient: vectors[0] / vectors[1] / vectors[2] / ...";
+  static title = "Subtract";
+  static description = "Returns component-wise difference: vectors[0] - vectors[1] - vectors[2] - ...";
   static inputSchema() {
     return inputSchema8;
   }
@@ -1108,32 +454,32 @@ class VectorDivideTask extends Task7 {
     const values = Array.from({ length: len }, (_, i) => {
       let acc = Number(vectors[0][i]);
       for (let j = 1;j < vectors.length; j++) {
-        acc /= Number(vectors[j][i]);
+        acc -= Number(vectors[j][i]);
       }
       return acc;
     });
-    return { result: createTypedArrayFrom(vectors, values) };
+    return { result: createTypedArrayFrom3(vectors, values) };
   }
 }
-Workflow9.prototype.vectorDivide = CreateWorkflow9(VectorDivideTask);
+Workflow8.prototype.vectorSubtract = CreateWorkflow8(VectorSubtractTask);
 
-// src/task/vector/VectorMultiplyTask.ts
-import { CreateWorkflow as CreateWorkflow10, Task as Task8, Workflow as Workflow10 } from "@workglow/task-graph";
+// src/task/vector/VectorSumTask.ts
+import { CreateWorkflow as CreateWorkflow9, Task as Task9, Workflow as Workflow9 } from "@workglow/task-graph";
 import {
-  createTypedArrayFrom as createTypedArrayFrom2,
-  TypedArraySchema as TypedArraySchema2
+  createTypedArrayFrom as createTypedArrayFrom4,
+  TypedArraySchema as TypedArraySchema4
 } from "@workglow/util";
 var inputSchema9 = {
   type: "object",
   properties: {
     vectors: {
       type: "array",
-      items: TypedArraySchema2({
+      items: TypedArraySchema4({
         title: "Vector",
-        description: "Vector for component-wise product"
+        description: "Vector to sum"
       }),
       title: "Vectors",
-      description: "Array of vectors to multiply component-wise"
+      description: "Array of vectors to sum component-wise"
     }
   },
   required: ["vectors"],
@@ -1142,20 +488,20 @@ var inputSchema9 = {
 var outputSchema9 = {
   type: "object",
   properties: {
-    result: TypedArraySchema2({
+    result: TypedArraySchema4({
       title: "Result",
-      description: "Component-wise product (Hadamard product)"
+      description: "Sum of vectors"
     })
   },
   required: ["result"],
   additionalProperties: false
 };
 
-class VectorMultiplyTask extends Task8 {
-  static type = "VectorMultiplyTask";
+class VectorSumTask extends Task9 {
+  static type = "VectorSumTask";
   static category = "Vector";
-  static title = "Multiply";
-  static description = "Returns the component-wise product (Hadamard product) of all vectors";
+  static title = "Sum";
+  static description = "Returns the component-wise sum of an array of vectors";
   static inputSchema() {
     return inputSchema9;
   }
@@ -1173,152 +519,22 @@ class VectorMultiplyTask extends Task8 {
         throw new Error("All vectors must have the same length");
       }
     }
-    const values = Array.from({ length: len }, (_, i) => vectors.reduce((acc, v) => acc * Number(v[i]), 1));
-    return { result: createTypedArrayFrom2(vectors, values) };
+    const values = Array.from({ length: len }, (_, i) => sumPrecise(vectors.map((v) => Number(v[i]))));
+    return { result: createTypedArrayFrom4(vectors, values) };
   }
 }
-Workflow10.prototype.vectorMultiply = CreateWorkflow10(VectorMultiplyTask);
+Workflow9.prototype.vectorSum = CreateWorkflow9(VectorSumTask);
 
-// src/task/vector/VectorSubtractTask.ts
-import { CreateWorkflow as CreateWorkflow11, Task as Task9, Workflow as Workflow11 } from "@workglow/task-graph";
+// src/task/adaptive.ts
+Workflow10.prototype.add = CreateAdaptiveWorkflow(ScalarAddTask, VectorSumTask);
+Workflow10.prototype.subtract = CreateAdaptiveWorkflow(ScalarSubtractTask, VectorSubtractTask);
+Workflow10.prototype.multiply = CreateAdaptiveWorkflow(ScalarMultiplyTask, VectorMultiplyTask);
+Workflow10.prototype.divide = CreateAdaptiveWorkflow(ScalarDivideTask, VectorDivideTask);
+Workflow10.prototype.sum = CreateAdaptiveWorkflow(ScalarSumTask, VectorSumTask);
+
+// src/task/ArrayTask.ts
 import {
-  createTypedArrayFrom as createTypedArrayFrom3,
-  TypedArraySchema as TypedArraySchema3
-} from "@workglow/util";
-var inputSchema10 = {
-  type: "object",
-  properties: {
-    vectors: {
-      type: "array",
-      items: TypedArraySchema3({
-        title: "Vector",
-        description: "Vector (first is minuend, rest are subtrahends)"
-      }),
-      title: "Vectors",
-      description: "Array of vectors: vectors[0] - vectors[1] - vectors[2] - ..."
-    }
-  },
-  required: ["vectors"],
-  additionalProperties: false
-};
-var outputSchema10 = {
-  type: "object",
-  properties: {
-    result: TypedArraySchema3({
-      title: "Result",
-      description: "Difference of vectors"
-    })
-  },
-  required: ["result"],
-  additionalProperties: false
-};
-
-class VectorSubtractTask extends Task9 {
-  static type = "VectorSubtractTask";
-  static category = "Vector";
-  static title = "Subtract";
-  static description = "Returns component-wise difference: vectors[0] - vectors[1] - vectors[2] - ...";
-  static inputSchema() {
-    return inputSchema10;
-  }
-  static outputSchema() {
-    return outputSchema10;
-  }
-  async execute(input, _context) {
-    const { vectors } = input;
-    if (vectors.length < 2) {
-      throw new Error("At least two vectors are required");
-    }
-    const len = vectors[0].length;
-    for (let i = 1;i < vectors.length; i++) {
-      if (vectors[i].length !== len) {
-        throw new Error("All vectors must have the same length");
-      }
-    }
-    const values = Array.from({ length: len }, (_, i) => {
-      let acc = Number(vectors[0][i]);
-      for (let j = 1;j < vectors.length; j++) {
-        acc -= Number(vectors[j][i]);
-      }
-      return acc;
-    });
-    return { result: createTypedArrayFrom3(vectors, values) };
-  }
-}
-Workflow11.prototype.vectorSubtract = CreateWorkflow11(VectorSubtractTask);
-
-// src/task/vector/VectorSumTask.ts
-import { CreateWorkflow as CreateWorkflow12, Task as Task10, Workflow as Workflow12 } from "@workglow/task-graph";
-import {
-  createTypedArrayFrom as createTypedArrayFrom4,
-  TypedArraySchema as TypedArraySchema4
-} from "@workglow/util";
-var inputSchema11 = {
-  type: "object",
-  properties: {
-    vectors: {
-      type: "array",
-      items: TypedArraySchema4({
-        title: "Vector",
-        description: "Vector to sum"
-      }),
-      title: "Vectors",
-      description: "Array of vectors to sum component-wise"
-    }
-  },
-  required: ["vectors"],
-  additionalProperties: false
-};
-var outputSchema11 = {
-  type: "object",
-  properties: {
-    result: TypedArraySchema4({
-      title: "Result",
-      description: "Sum of vectors"
-    })
-  },
-  required: ["result"],
-  additionalProperties: false
-};
-
-class VectorSumTask extends Task10 {
-  static type = "VectorSumTask";
-  static category = "Vector";
-  static title = "Sum";
-  static description = "Returns the component-wise sum of an array of vectors";
-  static inputSchema() {
-    return inputSchema11;
-  }
-  static outputSchema() {
-    return outputSchema11;
-  }
-  async execute(input, _context) {
-    const { vectors } = input;
-    if (vectors.length === 0) {
-      throw new Error("At least one vector is required");
-    }
-    const len = vectors[0].length;
-    for (let i = 1;i < vectors.length; i++) {
-      if (vectors[i].length !== len) {
-        throw new Error("All vectors must have the same length");
-      }
-    }
-    const values = Array.from({ length: len }, (_, i) => sumPrecise(vectors.map((v) => Number(v[i]))));
-    return { result: createTypedArrayFrom4(vectors, values) };
-  }
-}
-Workflow12.prototype.vectorSum = CreateWorkflow12(VectorSumTask);
-
-// src/task/adaptive.ts
-Workflow13.prototype.add = CreateAdaptiveWorkflow(ScalarAddTask, VectorSumTask);
-Workflow13.prototype.subtract = CreateAdaptiveWorkflow(ScalarSubtractTask, VectorSubtractTask);
-Workflow13.prototype.multiply = CreateAdaptiveWorkflow(ScalarMultiplyTask, VectorMultiplyTask);
-Workflow13.prototype.divide = CreateAdaptiveWorkflow(ScalarDivideTask, VectorDivideTask);
-Workflow13.prototype.sum = CreateAdaptiveWorkflow(ScalarSumTask, VectorSumTask);
-
-// src/task/ArrayTask.ts
-import {
-  uuid4
+  uuid4
 } from "@workglow/util";
 import {
   GraphAsTask,
@@ -1350,12 +566,12 @@ class ArrayTask extends GraphAsTask {
   regenerateGraph() {
     const arrayInputs = new Map;
     let hasArrayInputs = false;
-    const inputSchema12 = this.inputSchema();
-    if (typeof inputSchema12 !== "boolean") {
-      const keys = Object.keys(inputSchema12.properties || {});
+    const inputSchema10 = this.inputSchema();
+    if (typeof inputSchema10 !== "boolean") {
+      const keys = Object.keys(inputSchema10.properties || {});
       for (const inputId of keys) {
         const inputValue = this.runInputData[inputId];
-        const inputDef = inputSchema12.properties?.[inputId];
+        const inputDef = inputSchema10.properties?.[inputId];
         if (typeof inputDef === "object" && inputDef !== null && "x-replicate" in inputDef && inputDef["x-replicate"] === true && Array.isArray(inputValue) && inputValue.length > 1) {
           arrayInputs.set(inputId, inputValue);
           hasArrayInputs = true;
@@ -1444,7 +660,7 @@ class ArrayTaskRunner extends GraphAsTaskRunner {
   }
 }
 // src/task/DebugLogTask.ts
-import { CreateWorkflow as CreateWorkflow13, Task as Task11, TaskConfigSchema, Workflow as Workflow14 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow10, Task as Task10, TaskConfigSchema, Workflow as Workflow11 } from "@workglow/task-graph";
 var log_levels = ["dir", "log", "debug", "info", "warn", "error"];
 var DEFAULT_LOG_LEVEL = "log";
 var debugLogTaskConfigSchema = {
@@ -1461,18 +677,18 @@ var debugLogTaskConfigSchema = {
   },
   additionalProperties: false
 };
-var inputSchema12 = {
+var inputSchema10 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
-var outputSchema12 = {
+var outputSchema10 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
 
-class DebugLogTask extends Task11 {
+class DebugLogTask extends Task10 {
   static type = "DebugLogTask";
   static category = "Utility";
   static title = "Debug Log";
@@ -1484,10 +700,10 @@ class DebugLogTask extends Task11 {
     return debugLogTaskConfigSchema;
   }
   static inputSchema() {
-    return inputSchema12;
+    return inputSchema10;
   }
   static outputSchema() {
-    return outputSchema12;
+    return outputSchema10;
   }
   async executeReactive(input, output) {
     const log_level = this.config.log_level ?? DEFAULT_LOG_LEVEL;
@@ -1505,14 +721,14 @@ var debugLog = (input, config = {}) => {
   const task = new DebugLogTask({}, config);
   return task.run(input);
 };
-Workflow14.prototype.debugLog = CreateWorkflow13(DebugLogTask);
+Workflow11.prototype.debugLog = CreateWorkflow10(DebugLogTask);
 // src/task/DelayTask.ts
 import {
-  CreateWorkflow as CreateWorkflow14,
-  Task as Task12,
-  TaskAbortedError as TaskAbortedError3,
+  CreateWorkflow as CreateWorkflow11,
+  Task as Task11,
+  TaskAbortedError,
   TaskConfigSchema as TaskConfigSchema2,
-  Workflow as Workflow15
+  Workflow as Workflow12
 } from "@workglow/task-graph";
 import { sleep } from "@workglow/util";
 var delayTaskConfigSchema = {
@@ -1527,18 +743,18 @@ var delayTaskConfigSchema = {
   },
   additionalProperties: false
 };
-var inputSchema13 = {
+var inputSchema11 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
-var outputSchema13 = {
+var outputSchema11 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
 
-class DelayTask extends Task12 {
+class DelayTask extends Task11 {
   static type = "DelayTask";
   static category = "Utility";
   static title = "Delay";
@@ -1550,10 +766,10 @@ class DelayTask extends Task12 {
     return delayTaskConfigSchema;
   }
   static inputSchema() {
-    return inputSchema13;
+    return inputSchema11;
   }
   static outputSchema() {
-    return outputSchema13;
+    return outputSchema11;
   }
   async execute(input, executeContext) {
     const delay = this.config.delay ?? 1;
@@ -1562,7 +778,7 @@ class DelayTask extends Task12 {
       const chunkSize = delay / iterations;
       for (let i = 0;i < iterations; i++) {
         if (executeContext.signal.aborted) {
-          throw new TaskAbortedError3("Task aborted");
+          throw new TaskAbortedError("Task aborted");
         }
         await sleep(chunkSize);
         await executeContext.updateProgress(100 * i / iterations, `Delaying for ${delay}ms`);
@@ -1577,51 +793,379 @@ var delay = (input, config = { delay: 1 }) => {
   const task = new DelayTask({}, config);
   return task.run(input);
 };
-Workflow15.prototype.delay = CreateWorkflow14(DelayTask);
-// src/task/InputTask.ts
-import { CreateWorkflow as CreateWorkflow15, Task as Task13, Workflow as Workflow16 } from "@workglow/task-graph";
-
-class InputTask extends Task13 {
-  static type = "InputTask";
-  static category = "Flow Control";
-  static title = "Input";
-  static description = "Starts the workflow";
-  static hasDynamicSchemas = true;
-  static cacheable = false;
-  static inputSchema() {
-    return {
+Workflow12.prototype.delay = CreateWorkflow11(DelayTask);
+// src/task/FetchUrlTask.ts
+import {
+  AbortSignalJobError,
+  Job,
+  PermanentJobError,
+  RetryableJobError
+} from "@workglow/job-queue";
+import {
+  CreateWorkflow as CreateWorkflow12,
+  JobQueueTask,
+  TaskConfigurationError,
+  TaskInvalidInputError,
+  Workflow as Workflow13
+} from "@workglow/task-graph";
+var inputSchema12 = {
+  type: "object",
+  properties: {
+    url: {
+      type: "string",
+      title: "URL",
+      description: "The URL to fetch from",
+      format: "uri"
+    },
+    method: {
+      enum: ["GET", "POST", "PUT", "DELETE", "PATCH"],
+      title: "Method",
+      description: "The HTTP method to use",
+      default: "GET"
+    },
+    headers: {
       type: "object",
-      properties: {},
-      additionalProperties: true
-    };
-  }
-  static outputSchema() {
-    return {
+      additionalProperties: {
+        type: "string"
+      },
+      title: "Headers",
+      description: "The headers to send with the request"
+    },
+    body: {
+      type: "string",
+      title: "Body",
+      description: "The body of the request"
+    },
+    response_type: {
+      anyOf: [{ type: "null" }, { enum: ["json", "text", "blob", "arraybuffer"] }],
+      title: "Response Type",
+      description: "The forced type of response to return. If null, the response type is inferred from the Content-Type header.",
+      default: null
+    },
+    timeout: {
+      type: "number",
+      title: "Timeout",
+      description: "Request timeout in milliseconds"
+    },
+    credential_key: {
+      type: "string",
+      format: "credential",
+      title: "Credential Key",
+      description: "Key to look up in the credential store. The resolved value is sent as a Bearer token in the Authorization header.",
+      "x-ui-hidden": true
+    },
+    queue: {
+      oneOf: [{ type: "boolean" }, { type: "string" }],
+      description: "Queue handling: false=run inline, true=use default, string=explicit queue name",
+      default: true,
+      "x-ui-hidden": true
+    }
+  },
+  required: ["url"],
+  additionalProperties: false
+};
+var outputSchema12 = {
+  type: "object",
+  properties: {
+    json: {
+      title: "JSON",
+      description: "The JSON response"
+    },
+    text: {
+      type: "string",
+      title: "Text",
+      description: "The text response"
+    },
+    blob: {
+      title: "Blob",
+      description: "The blob response"
+    },
+    arraybuffer: {
+      title: "ArrayBuffer",
+      description: "The arraybuffer response"
+    },
+    metadata: {
       type: "object",
-      properties: {},
-      additionalProperties: true
-    };
-  }
-  inputSchema() {
-    return this.config?.inputSchema ?? this.constructor.inputSchema();
-  }
-  outputSchema() {
-    return this.config?.outputSchema ?? this.constructor.outputSchema();
-  }
-  async execute(input) {
-    return input;
+      properties: {
+        contentType: { type: "string" },
+        headers: { type: "object", additionalProperties: { type: "string" } }
+      },
+      additionalProperties: false,
+      title: "Response Metadata",
+      description: "HTTP response metadata including content type and headers"
+    }
+  },
+  additionalProperties: false
+};
+async function fetchWithProgress(url, options = {}, onProgress) {
+  if (!options.signal) {
+    throw new TaskConfigurationError("An AbortSignal must be provided.");
   }
-  async executeReactive(input) {
-    return input;
+  const response = await globalThis.fetch(url, options);
+  if (!response.body) {
+    throw new Error("ReadableStream not supported in this environment.");
   }
-  async* executeStream(input, context) {
-    if (context.inputStreams) {
-      for (const [, stream] of context.inputStreams) {
-        const reader = stream.getReader();
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done)
+  const contentLength = response.headers.get("Content-Length");
+  const totalBytes = contentLength ? parseInt(contentLength, 10) : 0;
+  let receivedBytes = 0;
+  const reader = response.body.getReader();
+  const stream = new ReadableStream({
+    start(controller) {
+      async function push() {
+        try {
+          while (true) {
+            if (options.signal?.aborted) {
+              controller.error(new AbortSignalJobError("Fetch aborted"));
+              reader.cancel();
+              return;
+            }
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+              break;
+            }
+            controller.enqueue(value);
+            receivedBytes += value.length;
+            if (onProgress && totalBytes) {
+              await onProgress(receivedBytes / totalBytes * 100);
+            }
+          }
+        } catch (error) {
+          controller.error(error);
+        }
+      }
+      push();
+    },
+    cancel() {
+      reader.cancel();
+    }
+  });
+  return new Response(stream, {
+    headers: response.headers,
+    status: response.status,
+    statusText: response.statusText
+  });
+}
+
+class FetchUrlJob extends Job {
+  constructor(config = { input: {} }) {
+    super(config);
+  }
+  static type = "FetchUrlJob";
+  async execute(input, context) {
+    const response = await fetchWithProgress(input.url, {
+      method: input.method,
+      headers: input.headers,
+      body: input.body,
+      signal: context.signal
+    }, async (progress) => await context.updateProgress(progress));
+    if (response.ok) {
+      const contentType = response.headers.get("content-type") ?? "";
+      const responseHeaders = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+      });
+      const metadata = {
+        contentType,
+        headers: responseHeaders
+      };
+      let responseType = input.response_type;
+      if (!responseType) {
+        if (contentType.includes("application/json")) {
+          responseType = "json";
+        } else if (contentType.includes("text/")) {
+          responseType = "text";
+        } else if (contentType.includes("application/octet-stream")) {
+          responseType = "arraybuffer";
+        } else if (contentType.includes("application/pdf") || contentType.includes("image/") || contentType.includes("application/zip")) {
+          responseType = "blob";
+        } else {
+          responseType = "json";
+        }
+        input.response_type = responseType;
+      }
+      if (responseType === "json") {
+        return { json: await response.json(), metadata };
+      } else if (responseType === "text") {
+        return { text: await response.text(), metadata };
+      } else if (responseType === "blob") {
+        return { blob: await response.blob(), metadata };
+      } else if (responseType === "arraybuffer") {
+        return { arraybuffer: await response.arrayBuffer(), metadata };
+      }
+      throw new TaskInvalidInputError(`Invalid response type: ${responseType}`);
+    } else {
+      if (response.status === 429 || response.status === 503 || response.headers.get("Retry-After")) {
+        let retryDate;
+        const retryAfterStr = response.headers.get("Retry-After");
+        if (retryAfterStr) {
+          const parsedDate = new Date(retryAfterStr);
+          if (!isNaN(parsedDate.getTime()) && parsedDate > new Date) {
+            retryDate = parsedDate;
+          } else {
+            const retryAfterSeconds = parseInt(retryAfterStr) * 1000;
+            if (!isNaN(retryAfterSeconds)) {
+              retryDate = new Date(Date.now() + retryAfterSeconds);
+            }
+          }
+        }
+        throw new RetryableJobError(`Failed to fetch ${input.url}: ${response.status} ${response.statusText}`, retryDate);
+      } else {
+        throw new PermanentJobError(`Failed to fetch ${input.url}: ${response.status} ${response.statusText}`);
+      }
+    }
+  }
+}
+
+class FetchUrlTask extends JobQueueTask {
+  static type = "FetchUrlTask";
+  static category = "Input";
+  static title = "Fetch";
+  static description = "Fetches data from a URL with progress tracking and automatic retry handling";
+  static hasDynamicSchemas = true;
+  static inputSchema() {
+    return inputSchema12;
+  }
+  static outputSchema() {
+    return outputSchema12;
+  }
+  outputSchema() {
+    const responseType = this.runInputData?.response_type ?? this.defaults?.response_type ?? null;
+    if (responseType === null || responseType === undefined) {
+      return this.constructor.outputSchema();
+    }
+    const staticSchema = this.constructor.outputSchema();
+    if (typeof staticSchema === "boolean") {
+      return staticSchema;
+    }
+    if (!staticSchema.properties) {
+      return staticSchema;
+    }
+    const properties = {};
+    if (responseType === "json" && staticSchema.properties.json) {
+      properties.json = staticSchema.properties.json;
+    } else if (responseType === "text" && staticSchema.properties.text) {
+      properties.text = staticSchema.properties.text;
+    } else if (responseType === "blob" && staticSchema.properties.blob) {
+      properties.blob = staticSchema.properties.blob;
+    } else if (responseType === "arraybuffer" && staticSchema.properties.arraybuffer) {
+      properties.arraybuffer = staticSchema.properties.arraybuffer;
+    }
+    if (staticSchema.properties.metadata) {
+      properties.metadata = staticSchema.properties.metadata;
+    }
+    if (Object.keys(properties).length === 0) {
+      return staticSchema;
+    }
+    return {
+      type: "object",
+      properties,
+      additionalProperties: false
+    };
+  }
+  constructor(input = {}, config = {}) {
+    config.queue = input?.queue ?? config.queue;
+    if (config.queue === undefined) {
+      config.queue = false;
+    }
+    super(input, config);
+    this.jobClass = FetchUrlJob;
+  }
+  async execute(input, executeContext) {
+    const credential = input.credential_key;
+    if (credential) {
+      input = {
+        ...input,
+        headers: { ...input.headers, Authorization: `Bearer ${credential}` }
+      };
+    }
+    return super.execute(input, executeContext);
+  }
+  setInput(input) {
+    if (!("response_type" in input)) {
+      super.setInput(input);
+      return;
+    }
+    const getCurrentResponseType = () => {
+      return this.runInputData?.response_type ?? this.defaults?.response_type ?? null;
+    };
+    const previousResponseType = getCurrentResponseType();
+    super.setInput(input);
+    const newResponseType = getCurrentResponseType();
+    if (previousResponseType !== newResponseType) {
+      this.emitSchemaChange();
+    }
+  }
+  async getDefaultQueueName(input) {
+    if (!input.url) {
+      return `fetch:${this.type}`;
+    }
+    try {
+      const hostname = new URL(input.url).hostname.toLowerCase();
+      const parts = hostname.split(".").filter(Boolean);
+      if (parts.length === 0) {
+        return `fetch:${this.type}`;
+      }
+      const domain = parts.length <= 2 ? parts.join(".") : parts.slice(-2).join(".");
+      return `fetch:${domain}`;
+    } catch {
+      return `fetch:${this.type}`;
+    }
+  }
+}
+var fetchUrl = async (input, config = {}) => {
+  const result = await new FetchUrlTask({}, config).run(input);
+  return result;
+};
+Workflow13.prototype.fetch = CreateWorkflow12(FetchUrlTask);
+// src/task/InputTask.ts
+import {
+  CreateWorkflow as CreateWorkflow13,
+  Task as Task12,
+  Workflow as Workflow14
+} from "@workglow/task-graph";
+
+class InputTask extends Task12 {
+  static type = "InputTask";
+  static category = "Flow Control";
+  static title = "Input";
+  static description = "Starts the workflow";
+  static hasDynamicSchemas = true;
+  static cacheable = false;
+  static inputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+  }
+  static outputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+  }
+  inputSchema() {
+    return this.config?.inputSchema ?? this.constructor.inputSchema();
+  }
+  outputSchema() {
+    return this.config?.outputSchema ?? this.constructor.outputSchema();
+  }
+  async execute(input) {
+    return input;
+  }
+  async executeReactive(input) {
+    return input;
+  }
+  async* executeStream(input, context) {
+    if (context.inputStreams) {
+      for (const [, stream] of context.inputStreams) {
+        const reader = stream.getReader();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
               break;
             if (value.type === "finish")
               continue;
@@ -1635,9 +1179,9 @@ class InputTask extends Task13 {
     yield { type: "finish", data: input };
   }
 }
-Workflow16.prototype.input = CreateWorkflow15(InputTask);
+Workflow14.prototype.input = CreateWorkflow13(InputTask);
 // src/task/JavaScriptTask.ts
-import { CreateWorkflow as CreateWorkflow16, Task as Task14, TaskConfigSchema as TaskConfigSchema3, Workflow as Workflow17 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow14, Task as Task13, TaskConfigSchema as TaskConfigSchema3, Workflow as Workflow15 } from "@workglow/task-graph";
 
 // src/util/acorn.js
 var options;
@@ -6114,7 +5658,7 @@ var configSchema = {
   },
   additionalProperties: false
 };
-var inputSchema14 = {
+var inputSchema13 = {
   type: "object",
   properties: {
     javascript_code: {
@@ -6128,7 +5672,7 @@ var inputSchema14 = {
   required: ["javascript_code"],
   additionalProperties: true
 };
-var outputSchema14 = {
+var outputSchema13 = {
   type: "object",
   properties: {
     output: {
@@ -6140,7 +5684,7 @@ var outputSchema14 = {
   additionalProperties: false
 };
 
-class JavaScriptTask extends Task14 {
+class JavaScriptTask extends Task13 {
   static type = "JavaScriptTask";
   static category = "Utility";
   static title = "JavaScript Interpreter";
@@ -6150,10 +5694,10 @@ class JavaScriptTask extends Task14 {
     return configSchema;
   }
   static inputSchema() {
-    return inputSchema14;
+    return inputSchema13;
   }
   static outputSchema() {
-    return outputSchema14;
+    return outputSchema13;
   }
   constructor(input2 = {}, config = {}) {
     super(input2, config);
@@ -6169,7 +5713,7 @@ class JavaScriptTask extends Task14 {
         additionalProperties: true
       };
     }
-    return inputSchema14;
+    return inputSchema13;
   }
   async executeReactive(input2, output) {
     if (this.config.javascript_code || input2.javascript_code) {
@@ -6188,18 +5732,18 @@ class JavaScriptTask extends Task14 {
 var javaScript = (input2, config = {}) => {
   return new JavaScriptTask({}, config).run(input2);
 };
-Workflow17.prototype.javaScript = CreateWorkflow16(JavaScriptTask);
+Workflow15.prototype.javaScript = CreateWorkflow14(JavaScriptTask);
 // src/task/JsonTask.ts
 import {
   createGraphFromDependencyJSON,
   createGraphFromGraphJSON,
-  CreateWorkflow as CreateWorkflow17,
+  CreateWorkflow as CreateWorkflow15,
   Dataflow,
   GraphAsTask as GraphAsTask2,
   TaskConfigurationError as TaskConfigurationError2,
-  Workflow as Workflow18
+  Workflow as Workflow16
 } from "@workglow/task-graph";
-var inputSchema15 = {
+var inputSchema14 = {
   type: "object",
   properties: {
     json: {
@@ -6210,7 +5754,7 @@ var inputSchema15 = {
   },
   additionalProperties: false
 };
-var outputSchema15 = {
+var outputSchema14 = {
   type: "object",
   properties: {
     output: {
@@ -6227,10 +5771,10 @@ class JsonTask extends GraphAsTask2 {
   static title = "JSON Task";
   static description = "A task that creates and manages task graphs from JSON configurations";
   static inputSchema() {
-    return inputSchema15;
+    return inputSchema14;
   }
   static outputSchema() {
-    return outputSchema15;
+    return outputSchema14;
   }
   regenerateGraph() {
     if (!this.runInputData.json)
@@ -6253,7 +5797,7 @@ class JsonTask extends GraphAsTask2 {
           if (!sourceTask) {
             throw new TaskConfigurationError2(`Dependency id ${dep.id} not found`);
           }
-          const df = new Dataflow(sourceTask.config.id, dep.output, item.id, input2);
+          const df = new Dataflow(sourceTask.id, dep.output, item.id, input2);
           this.subGraph.addDataflow(df);
         }
       }
@@ -6264,15 +5808,15 @@ class JsonTask extends GraphAsTask2 {
 var json = (input2, config = {}) => {
   return new JsonTask({}, config).run(input2);
 };
-Workflow18.prototype.json = CreateWorkflow17(JsonTask);
+Workflow16.prototype.json = CreateWorkflow15(JsonTask);
 // src/task/LambdaTask.ts
 import {
-  CreateWorkflow as CreateWorkflow18,
+  CreateWorkflow as CreateWorkflow16,
   DATAFLOW_ALL_PORTS,
-  Task as Task15,
+  Task as Task14,
   TaskConfigSchema as TaskConfigSchema4,
   TaskConfigurationError as TaskConfigurationError3,
-  Workflow as Workflow19
+  Workflow as Workflow17
 } from "@workglow/task-graph";
 var lambdaTaskConfigSchema = {
   type: "object",
@@ -6283,7 +5827,7 @@ var lambdaTaskConfigSchema = {
   },
   additionalProperties: false
 };
-var inputSchema16 = {
+var inputSchema15 = {
   type: "object",
   properties: {
     [DATAFLOW_ALL_PORTS]: {
@@ -6293,7 +5837,7 @@ var inputSchema16 = {
   },
   additionalProperties: true
 };
-var outputSchema16 = {
+var outputSchema15 = {
   type: "object",
   properties: {
     [DATAFLOW_ALL_PORTS]: {
@@ -6304,7 +5848,7 @@ var outputSchema16 = {
   additionalProperties: true
 };
 
-class LambdaTask extends Task15 {
+class LambdaTask extends Task14 {
   static type = "LambdaTask";
   static title = "Lambda Task";
   static description = "A task that wraps a provided function and its input";
@@ -6314,10 +5858,10 @@ class LambdaTask extends Task15 {
     return lambdaTaskConfigSchema;
   }
   static inputSchema() {
-    return inputSchema16;
+    return inputSchema15;
   }
   static outputSchema() {
-    return outputSchema16;
+    return outputSchema15;
   }
   constructor(input2 = {}, config = {}) {
     if (!config.execute && !config.executeReactive) {
@@ -6355,15 +5899,15 @@ function lambda(input2, config) {
   const task = new LambdaTask(input2, config);
   return task.run();
 }
-Workflow19.prototype.lambda = CreateWorkflow18(LambdaTask);
+Workflow17.prototype.lambda = CreateWorkflow16(LambdaTask);
 // src/task/MergeTask.ts
-import { CreateWorkflow as CreateWorkflow19, Task as Task16, Workflow as Workflow20 } from "@workglow/task-graph";
-var inputSchema17 = {
+import { CreateWorkflow as CreateWorkflow17, Task as Task15, Workflow as Workflow18 } from "@workglow/task-graph";
+var inputSchema16 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
-var outputSchema17 = {
+var outputSchema16 = {
   type: "object",
   properties: {
     output: {
@@ -6375,17 +5919,17 @@ var outputSchema17 = {
   additionalProperties: false
 };
 
-class MergeTask extends Task16 {
+class MergeTask extends Task15 {
   static type = "MergeTask";
   static category = "Utility";
   static title = "Merge";
   static description = "Merges multiple inputs into a single array output";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema17;
+    return inputSchema16;
   }
   static outputSchema() {
-    return outputSchema17;
+    return outputSchema16;
   }
   async execute(input2, _context) {
     const keys = Object.keys(input2).sort();
@@ -6399,11 +5943,15 @@ var merge = (input2, config = {}) => {
   const task = new MergeTask({}, config);
   return task.run(input2);
 };
-Workflow20.prototype.merge = CreateWorkflow19(MergeTask);
+Workflow18.prototype.merge = CreateWorkflow17(MergeTask);
 // src/task/OutputTask.ts
-import { CreateWorkflow as CreateWorkflow20, Task as Task17, Workflow as Workflow21 } from "@workglow/task-graph";
+import {
+  CreateWorkflow as CreateWorkflow18,
+  Task as Task16,
+  Workflow as Workflow19
+} from "@workglow/task-graph";
 
-class OutputTask extends Task17 {
+class OutputTask extends Task16 {
   static type = "OutputTask";
   static category = "Flow Control";
   static title = "Output";
@@ -6457,10 +6005,10 @@ class OutputTask extends Task17 {
     yield { type: "finish", data: input2 };
   }
 }
-Workflow21.prototype.output = CreateWorkflow20(OutputTask);
+Workflow19.prototype.output = CreateWorkflow18(OutputTask);
 // src/task/SplitTask.ts
-import { CreateWorkflow as CreateWorkflow21, Task as Task18, Workflow as Workflow22 } from "@workglow/task-graph";
-var inputSchema18 = {
+import { CreateWorkflow as CreateWorkflow19, Task as Task17, Workflow as Workflow20 } from "@workglow/task-graph";
+var inputSchema17 = {
   type: "object",
   properties: {
     input: {
@@ -6470,13 +6018,13 @@ var inputSchema18 = {
   },
   additionalProperties: false
 };
-var outputSchema18 = {
+var outputSchema17 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
 
-class SplitTask extends Task18 {
+class SplitTask extends Task17 {
   static type = "SplitTask";
   static category = "Utility";
   static title = "Split";
@@ -6484,13 +6032,13 @@ class SplitTask extends Task18 {
   static hasDynamicSchemas = true;
   static cacheable = false;
   static inputSchema() {
-    return inputSchema18;
+    return inputSchema17;
   }
   static outputSchema() {
-    return outputSchema18;
+    return outputSchema17;
   }
   outputSchema() {
-    return outputSchema18;
+    return outputSchema17;
   }
   async executeReactive(input2) {
     const inputValue = input2.input;
@@ -6509,15 +6057,327 @@ var split = (input2, config = {}) => {
   const task = new SplitTask({}, config);
   return task.run(input2);
 };
-Workflow22.prototype.split = CreateWorkflow21(SplitTask);
+Workflow20.prototype.split = CreateWorkflow19(SplitTask);
+// src/task/DateFormatTask.ts
+import {
+  CreateWorkflow as CreateWorkflow20,
+  Task as Task18,
+  Workflow as Workflow21
+} from "@workglow/task-graph";
+var inputSchema18 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "string",
+      title: "Value",
+      description: "Date string, ISO 8601 timestamp, or Unix timestamp in milliseconds"
+    },
+    format: {
+      type: "string",
+      title: "Format",
+      enum: ["iso", "date", "time", "datetime", "unix"],
+      description: "Output format: 'iso', 'date', 'time', 'datetime', 'unix'",
+      default: "iso"
+    },
+    locale: {
+      type: "string",
+      title: "Locale",
+      description: "Locale string (e.g. 'en-US')",
+      default: "en-US"
+    },
+    timeZone: {
+      type: "string",
+      title: "Time Zone",
+      description: "IANA time zone (e.g. 'America/New_York', 'UTC')"
+    }
+  },
+  required: ["value"],
+  additionalProperties: false
+};
+var outputSchema18 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "string",
+      title: "Result",
+      description: "Formatted date string"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class DateFormatTask extends Task18 {
+  static type = "DateFormatTask";
+  static category = "Utility";
+  static title = "Date Format";
+  static description = "Parses and formats a date string";
+  static inputSchema() {
+    return inputSchema18;
+  }
+  static outputSchema() {
+    return outputSchema18;
+  }
+  async executeReactive(input2, _output, _context) {
+    const dateInput = /^\d+$/.test(input2.value) ? Number(input2.value) : input2.value;
+    const date = new Date(dateInput);
+    if (isNaN(date.getTime())) {
+      throw new Error(`Invalid date: ${input2.value}`);
+    }
+    const format = input2.format ?? "iso";
+    const locale = input2.locale;
+    const timeZone = input2.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 };
+  }
+}
+Workflow21.prototype.dateFormat = CreateWorkflow20(DateFormatTask);
+// src/task/JsonPathTask.ts
+import {
+  CreateWorkflow as CreateWorkflow21,
+  Task as Task19,
+  Workflow as Workflow22
+} from "@workglow/task-graph";
+var inputSchema19 = {
+  type: "object",
+  properties: {
+    value: {
+      title: "Value",
+      description: "Input object or array to query"
+    },
+    path: {
+      type: "string",
+      title: "Path",
+      description: "Dot-notation path to extract (e.g. 'a.b.c', 'items.0.name', 'items.*.name')"
+    }
+  },
+  required: ["value", "path"],
+  additionalProperties: false
+};
+var outputSchema19 = {
+  type: "object",
+  properties: {
+    result: {
+      title: "Result",
+      description: "Extracted value(s) from the path"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+function resolvePath(obj, segments) {
+  if (segments.length === 0)
+    return obj;
+  const [head, ...tail] = segments;
+  if (head === "*") {
+    if (Array.isArray(obj)) {
+      return obj.map((item) => resolvePath(item, tail));
+    }
+    if (obj !== null && typeof obj === "object") {
+      return Object.values(obj).map((v) => resolvePath(v, tail));
+    }
+    return;
+  }
+  if (obj === null || obj === undefined || typeof obj !== "object") {
+    return;
+  }
+  const next2 = obj[head];
+  return resolvePath(next2, tail);
+}
+
+class JsonPathTask extends Task19 {
+  static type = "JsonPathTask";
+  static category = "Utility";
+  static title = "JSON Path";
+  static description = "Extracts a value from an object using a dot-notation path";
+  static inputSchema() {
+    return inputSchema19;
+  }
+  static outputSchema() {
+    return outputSchema19;
+  }
+  async executeReactive(input2, _output, _context) {
+    const segments = input2.path.split(".");
+    const result = resolvePath(input2.value, segments);
+    return { result };
+  }
+}
+Workflow22.prototype.jsonPath = CreateWorkflow21(JsonPathTask);
+// src/task/RegexTask.ts
+import {
+  CreateWorkflow as CreateWorkflow22,
+  Task as Task20,
+  Workflow as Workflow23
+} from "@workglow/task-graph";
+var inputSchema20 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "string",
+      title: "Value",
+      description: "Input string to match against"
+    },
+    pattern: {
+      type: "string",
+      title: "Pattern",
+      description: "Regular expression pattern"
+    },
+    flags: {
+      type: "string",
+      title: "Flags",
+      description: "Regex flags (e.g. 'g', 'i', 'gi')",
+      default: ""
+    }
+  },
+  required: ["value", "pattern"],
+  additionalProperties: false
+};
+var outputSchema20 = {
+  type: "object",
+  properties: {
+    match: {
+      type: "boolean",
+      title: "Match",
+      description: "Whether the pattern matched"
+    },
+    matches: {
+      type: "array",
+      items: { type: "string" },
+      title: "Matches",
+      description: "Array of matched strings (full matches when global, groups when not)"
+    }
+  },
+  required: ["match", "matches"],
+  additionalProperties: false
+};
+
+class RegexTask extends Task20 {
+  static type = "RegexTask";
+  static category = "String";
+  static title = "Regex";
+  static description = "Matches a string against a regular expression pattern";
+  static inputSchema() {
+    return inputSchema20;
+  }
+  static outputSchema() {
+    return outputSchema20;
+  }
+  async executeReactive(input2, _output, _context) {
+    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)
+    };
+  }
+}
+Workflow23.prototype.regex = CreateWorkflow22(RegexTask);
+// src/task/TemplateTask.ts
+import {
+  CreateWorkflow as CreateWorkflow23,
+  Task as Task21,
+  Workflow as Workflow24
+} from "@workglow/task-graph";
+var inputSchema21 = {
+  type: "object",
+  properties: {
+    template: {
+      type: "string",
+      title: "Template",
+      description: "Template string with {{key}} placeholders; supports {{key|default}} for defaults"
+    },
+    values: {
+      type: "object",
+      title: "Values",
+      description: "Key-value pairs to substitute into the template",
+      additionalProperties: true
+    }
+  },
+  required: ["template", "values"],
+  additionalProperties: false
+};
+var outputSchema21 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "string",
+      title: "Result",
+      description: "Rendered template string"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class TemplateTask extends Task21 {
+  static type = "TemplateTask";
+  static category = "Utility";
+  static title = "Template";
+  static description = "Renders a template string with {{key}} placeholders and optional defaults";
+  static inputSchema() {
+    return inputSchema21;
+  }
+  static outputSchema() {
+    return outputSchema21;
+  }
+  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 };
+  }
+}
+Workflow24.prototype.template = CreateWorkflow23(TemplateTask);
 // src/task/mcp/McpListTask.ts
-import { CreateWorkflow as CreateWorkflow22, Task as Task19, Workflow as Workflow23 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow24, Task as Task22, Workflow as Workflow25 } from "@workglow/task-graph";
 import {
   mcpClientFactory,
   mcpServerConfigSchema
 } from "@workglow/util";
 var mcpListTypes = ["tools", "resources", "prompts"];
-var inputSchema19 = {
+var inputSchema22 = {
   type: "object",
   properties: {
     ...mcpServerConfigSchema,
@@ -6686,7 +6546,7 @@ var outputSchemaAll = {
   additionalProperties: false
 };
 
-class McpListTask extends Task19 {
+class McpListTask extends Task22 {
   static type = "McpListTask";
   static category = "MCP";
   static title = "MCP List";
@@ -6694,7 +6554,7 @@ class McpListTask extends Task19 {
   static cacheable = false;
   static hasDynamicSchemas = true;
   static inputSchema() {
-    return inputSchema19;
+    return inputSchema22;
   }
   static outputSchema() {
     return outputSchemaAll;
@@ -6754,13 +6614,13 @@ class McpListTask extends Task19 {
 var mcpList = async (input2, config = {}) => {
   return new McpListTask({}, config).run(input2);
 };
-Workflow23.prototype.mcpList = CreateWorkflow22(McpListTask);
+Workflow25.prototype.mcpList = CreateWorkflow24(McpListTask);
 // src/task/mcp/McpPromptGetTask.ts
 import {
-  CreateWorkflow as CreateWorkflow23,
-  Task as Task20,
+  CreateWorkflow as CreateWorkflow25,
+  Task as Task23,
   TaskConfigSchema as TaskConfigSchema5,
-  Workflow as Workflow24
+  Workflow as Workflow26
 } from "@workglow/task-graph";
 import {
   mcpClientFactory as mcpClientFactory2,
@@ -6917,7 +6777,7 @@ var fallbackInputSchema = {
   additionalProperties: false
 };
 
-class McpPromptGetTask extends Task20 {
+class McpPromptGetTask extends Task23 {
   static type = "McpPromptGetTask";
   static category = "MCP";
   static title = "MCP Get Prompt";
@@ -7001,13 +6861,13 @@ class McpPromptGetTask extends Task20 {
 var mcpPromptGet = async (input2, config) => {
   return new McpPromptGetTask({}, config).run(input2);
 };
-Workflow24.prototype.mcpPromptGet = CreateWorkflow23(McpPromptGetTask);
+Workflow26.prototype.mcpPromptGet = CreateWorkflow25(McpPromptGetTask);
 // src/task/mcp/McpResourceReadTask.ts
 import {
-  CreateWorkflow as CreateWorkflow24,
-  Task as Task21,
+  CreateWorkflow as CreateWorkflow26,
+  Task as Task24,
   TaskConfigSchema as TaskConfigSchema6,
-  Workflow as Workflow25
+  Workflow as Workflow27
 } from "@workglow/task-graph";
 import {
   mcpClientFactory as mcpClientFactory3,
@@ -7057,12 +6917,12 @@ var contentItemSchema = {
     }
   ]
 };
-var inputSchema20 = {
+var inputSchema23 = {
   type: "object",
   properties: {},
   additionalProperties: false
 };
-var outputSchema19 = {
+var outputSchema22 = {
   type: "object",
   properties: {
     contents: {
@@ -7076,7 +6936,7 @@ var outputSchema19 = {
   additionalProperties: false
 };
 
-class McpResourceReadTask extends Task21 {
+class McpResourceReadTask extends Task24 {
   static type = "McpResourceReadTask";
   static category = "MCP";
   static title = "MCP Read Resource";
@@ -7084,10 +6944,10 @@ class McpResourceReadTask extends Task21 {
   static cacheable = false;
   static customizable = true;
   static inputSchema() {
-    return inputSchema20;
+    return inputSchema23;
   }
   static outputSchema() {
-    return outputSchema19;
+    return outputSchema22;
   }
   static configSchema() {
     return configSchema3;
@@ -7105,13 +6965,13 @@ class McpResourceReadTask extends Task21 {
 var mcpResourceRead = async (config) => {
   return new McpResourceReadTask({}, config).run({});
 };
-Workflow25.prototype.mcpResourceRead = CreateWorkflow24(McpResourceReadTask);
+Workflow27.prototype.mcpResourceRead = CreateWorkflow26(McpResourceReadTask);
 // src/task/mcp/McpToolCallTask.ts
 import {
-  CreateWorkflow as CreateWorkflow25,
-  Task as Task22,
+  CreateWorkflow as CreateWorkflow27,
+  Task as Task25,
   TaskConfigSchema as TaskConfigSchema7,
-  Workflow as Workflow26
+  Workflow as Workflow28
 } from "@workglow/task-graph";
 import {
   mcpClientFactory as mcpClientFactory4,
@@ -7260,7 +7120,7 @@ var fallbackInputSchema2 = {
   additionalProperties: true
 };
 
-class McpToolCallTask extends Task22 {
+class McpToolCallTask extends Task25 {
   static type = "McpToolCallTask";
   static category = "MCP";
   static title = "MCP Call Tool";
@@ -7359,577 +7219,1742 @@ class McpToolCallTask extends Task22 {
 var mcpToolCall = async (input2, config) => {
   return new McpToolCallTask({}, config).run(input2);
 };
-Workflow26.prototype.mcpToolCall = CreateWorkflow25(McpToolCallTask);
-// src/task/scalar/ScalarAbsTask.ts
-import { CreateWorkflow as CreateWorkflow26, Task as Task23, Workflow as Workflow27 } from "@workglow/task-graph";
-var inputSchema21 = {
+Workflow28.prototype.mcpToolCall = CreateWorkflow27(McpToolCallTask);
+// src/task/string/StringConcatTask.ts
+import {
+  CreateWorkflow as CreateWorkflow28,
+  Task as Task26,
+  Workflow as Workflow29
+} from "@workglow/task-graph";
+var inputSchema24 = {
+  type: "object",
+  properties: {},
+  additionalProperties: { type: "string" }
+};
+var outputSchema23 = {
   type: "object",
   properties: {
-    value: {
-      type: "number",
-      title: "Value",
-      description: "Input number"
+    result: {
+      type: "string",
+      title: "Result",
+      description: "Concatenation of all input strings"
     }
   },
-  required: ["value"],
+  required: ["result"],
   additionalProperties: false
 };
-var outputSchema20 = {
+
+class StringConcatTask extends Task26 {
+  static type = "StringConcatTask";
+  static category = "String";
+  static title = "Concat";
+  static description = "Concatenates all input strings";
+  static inputSchema() {
+    return inputSchema24;
+  }
+  static outputSchema() {
+    return outputSchema23;
+  }
+  async executeReactive(input2, _output, _context) {
+    return { result: Object.values(input2).join("") };
+  }
+}
+Workflow29.prototype.stringConcat = CreateWorkflow28(StringConcatTask);
+// src/task/string/StringIncludesTask.ts
+import {
+  CreateWorkflow as CreateWorkflow29,
+  Task as Task27,
+  Workflow as Workflow30
+} from "@workglow/task-graph";
+var inputSchema25 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "string",
+      title: "Value",
+      description: "Input string to search in"
+    },
+    search: {
+      type: "string",
+      title: "Search",
+      description: "Substring to search for"
+    }
+  },
+  required: ["value", "search"],
+  additionalProperties: false
+};
+var outputSchema24 = {
   type: "object",
   properties: {
     result: {
-      type: "number",
+      type: "boolean",
       title: "Result",
-      description: "Absolute value"
+      description: "Whether the string contains the search substring"
     }
   },
   required: ["result"],
   additionalProperties: false
 };
 
-class ScalarAbsTask extends Task23 {
-  static type = "ScalarAbsTask";
-  static category = "Math";
-  static title = "Abs";
-  static description = "Returns the absolute value of a number";
+class StringIncludesTask extends Task27 {
+  static type = "StringIncludesTask";
+  static category = "String";
+  static title = "Includes";
+  static description = "Checks if a string contains a substring";
   static inputSchema() {
-    return inputSchema21;
+    return inputSchema25;
   }
   static outputSchema() {
-    return outputSchema20;
+    return outputSchema24;
   }
-  async execute(input2, _context) {
-    return { result: Math.abs(input2.value) };
+  async executeReactive(input2, output, _context) {
+    return { result: input2.value.includes(input2.search) };
   }
 }
-Workflow27.prototype.scalarAbs = CreateWorkflow26(ScalarAbsTask);
-// src/task/scalar/ScalarCeilTask.ts
-import { CreateWorkflow as CreateWorkflow27, Task as Task24, Workflow as Workflow28 } from "@workglow/task-graph";
-var inputSchema22 = {
+Workflow30.prototype.stringIncludes = CreateWorkflow29(StringIncludesTask);
+// src/task/string/StringJoinTask.ts
+import {
+  CreateWorkflow as CreateWorkflow30,
+  Task as Task28,
+  Workflow as Workflow31
+} from "@workglow/task-graph";
+var inputSchema26 = {
   type: "object",
   properties: {
-    value: {
-      type: "number",
-      title: "Value",
-      description: "Input number"
+    values: {
+      type: "array",
+      items: { type: "string" },
+      title: "Values",
+      description: "Array of strings to join"
+    },
+    separator: {
+      type: "string",
+      title: "Separator",
+      description: "Separator between elements",
+      default: ""
     }
   },
-  required: ["value"],
+  required: ["values"],
   additionalProperties: false
 };
-var outputSchema21 = {
+var outputSchema25 = {
   type: "object",
   properties: {
     result: {
-      type: "number",
+      type: "string",
       title: "Result",
-      description: "Ceiling value"
+      description: "Joined string"
     }
   },
   required: ["result"],
   additionalProperties: false
 };
 
-class ScalarCeilTask extends Task24 {
-  static type = "ScalarCeilTask";
-  static category = "Math";
-  static title = "Ceil";
-  static description = "Returns the smallest integer greater than or equal to a number";
+class StringJoinTask extends Task28 {
+  static type = "StringJoinTask";
+  static category = "String";
+  static title = "Join";
+  static description = "Joins an array of strings with a separator";
   static inputSchema() {
-    return inputSchema22;
+    return inputSchema26;
   }
   static outputSchema() {
-    return outputSchema21;
+    return outputSchema25;
   }
-  async execute(input2, _context) {
-    return { result: Math.ceil(input2.value) };
+  async executeReactive(input2, output, _context) {
+    const separator = input2.separator ?? "";
+    return { result: input2.values.join(separator) };
   }
 }
-Workflow28.prototype.scalarCeil = CreateWorkflow27(ScalarCeilTask);
-// src/task/scalar/ScalarFloorTask.ts
-import { CreateWorkflow as CreateWorkflow28, Task as Task25, Workflow as Workflow29 } from "@workglow/task-graph";
-var inputSchema23 = {
+Workflow31.prototype.stringJoin = CreateWorkflow30(StringJoinTask);
+// src/task/string/StringLengthTask.ts
+import {
+  CreateWorkflow as CreateWorkflow31,
+  Task as Task29,
+  Workflow as Workflow32
+} from "@workglow/task-graph";
+var inputSchema27 = {
   type: "object",
   properties: {
     value: {
-      type: "number",
+      type: "string",
       title: "Value",
-      description: "Input number"
+      description: "Input string"
     }
   },
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema22 = {
+var outputSchema26 = {
   type: "object",
   properties: {
     result: {
-      type: "number",
+      type: "integer",
       title: "Result",
-      description: "Floored value"
+      description: "Length of the string"
     }
   },
   required: ["result"],
   additionalProperties: false
 };
 
-class ScalarFloorTask extends Task25 {
-  static type = "ScalarFloorTask";
-  static category = "Math";
-  static title = "Floor";
-  static description = "Returns the largest integer less than or equal to a number";
+class StringLengthTask extends Task29 {
+  static type = "StringLengthTask";
+  static category = "String";
+  static title = "Length";
+  static description = "Returns the length of a string";
   static inputSchema() {
-    return inputSchema23;
+    return inputSchema27;
   }
   static outputSchema() {
-    return outputSchema22;
+    return outputSchema26;
   }
-  async execute(input2, _context) {
-    return { result: Math.floor(input2.value) };
+  async executeReactive(input2, output, _context) {
+    return { result: input2.value.length };
   }
 }
-Workflow29.prototype.scalarFloor = CreateWorkflow28(ScalarFloorTask);
-// src/task/scalar/ScalarMaxTask.ts
-import { CreateWorkflow as CreateWorkflow29, Task as Task26, Workflow as Workflow30 } from "@workglow/task-graph";
-var inputSchema24 = {
+Workflow32.prototype.stringLength = CreateWorkflow31(StringLengthTask);
+// src/task/string/StringLowerCaseTask.ts
+import {
+  CreateWorkflow as CreateWorkflow32,
+  Task as Task30,
+  Workflow as Workflow33
+} from "@workglow/task-graph";
+var inputSchema28 = {
   type: "object",
   properties: {
-    values: {
-      type: "array",
-      items: { type: "number" },
-      title: "Values",
-      description: "Array of numbers"
+    value: {
+      type: "string",
+      title: "Value",
+      description: "Input string"
     }
   },
-  required: ["values"],
+  required: ["value"],
   additionalProperties: false
 };
-var outputSchema23 = {
+var outputSchema27 = {
   type: "object",
   properties: {
     result: {
-      type: "number",
+      type: "string",
       title: "Result",
-      description: "Maximum value"
+      description: "Lowercased string"
     }
   },
   required: ["result"],
   additionalProperties: false
 };
 
-class ScalarMaxTask extends Task26 {
-  static type = "ScalarMaxTask";
-  static category = "Math";
-  static title = "Max";
-  static description = "Returns the largest of the given numbers";
+class StringLowerCaseTask extends Task30 {
+  static type = "StringLowerCaseTask";
+  static category = "String";
+  static title = "Lower Case";
+  static description = "Converts a string to lower case";
   static inputSchema() {
-    return inputSchema24;
+    return inputSchema28;
   }
   static outputSchema() {
-    return outputSchema23;
+    return outputSchema27;
   }
-  async execute(input2, _context) {
-    return { result: Math.max(...input2.values) };
+  async executeReactive(input2, output, _context) {
+    return { result: input2.value.toLowerCase() };
   }
 }
-Workflow30.prototype.scalarMax = CreateWorkflow29(ScalarMaxTask);
-// src/task/scalar/ScalarMinTask.ts
-import { CreateWorkflow as CreateWorkflow30, Task as Task27, Workflow as Workflow31 } from "@workglow/task-graph";
-var inputSchema25 = {
+Workflow33.prototype.stringLowerCase = CreateWorkflow32(StringLowerCaseTask);
+// src/task/string/StringReplaceTask.ts
+import {
+  CreateWorkflow as CreateWorkflow33,
+  Task as Task31,
+  Workflow as Workflow34
+} from "@workglow/task-graph";
+var inputSchema29 = {
   type: "object",
   properties: {
-    values: {
-      type: "array",
-      items: { type: "number" },
-      title: "Values",
-      description: "Array of numbers"
+    value: {
+      type: "string",
+      title: "Value",
+      description: "Input string"
+    },
+    search: {
+      type: "string",
+      title: "Search",
+      description: "Substring to search for"
+    },
+    replace: {
+      type: "string",
+      title: "Replace",
+      description: "Replacement string"
     }
   },
-  required: ["values"],
+  required: ["value", "search", "replace"],
   additionalProperties: false
 };
-var outputSchema24 = {
+var outputSchema28 = {
   type: "object",
   properties: {
     result: {
-      type: "number",
+      type: "string",
       title: "Result",
-      description: "Minimum value"
+      description: "String with all occurrences replaced"
     }
   },
   required: ["result"],
   additionalProperties: false
 };
 
-class ScalarMinTask extends Task27 {
-  static type = "ScalarMinTask";
-  static category = "Math";
-  static title = "Min";
-  static description = "Returns the smallest of the given numbers";
+class StringReplaceTask extends Task31 {
+  static type = "StringReplaceTask";
+  static category = "String";
+  static title = "Replace";
+  static description = "Replaces all occurrences of a substring";
   static inputSchema() {
-    return inputSchema25;
+    return inputSchema29;
   }
   static outputSchema() {
-    return outputSchema24;
+    return outputSchema28;
   }
-  async execute(input2, _context) {
-    return { result: Math.min(...input2.values) };
+  async executeReactive(input2, output, _context) {
+    return { result: input2.value.replaceAll(input2.search, input2.replace) };
   }
 }
-Workflow31.prototype.scalarMin = CreateWorkflow30(ScalarMinTask);
-// src/task/scalar/ScalarRoundTask.ts
-import { CreateWorkflow as CreateWorkflow31, Task as Task28, Workflow as Workflow32 } from "@workglow/task-graph";
-var inputSchema26 = {
+Workflow34.prototype.stringReplace = CreateWorkflow33(StringReplaceTask);
+// src/task/string/StringSliceTask.ts
+import {
+  CreateWorkflow as CreateWorkflow34,
+  Task as Task32,
+  Workflow as Workflow35
+} from "@workglow/task-graph";
+var inputSchema30 = {
   type: "object",
   properties: {
     value: {
-      type: "number",
+      type: "string",
       title: "Value",
-      description: "Input number"
+      description: "Input string"
+    },
+    start: {
+      type: "integer",
+      title: "Start",
+      description: "Start index (inclusive, supports negative indexing)"
+    },
+    end: {
+      type: "integer",
+      title: "End",
+      description: "End index (exclusive, supports negative indexing)"
     }
   },
-  required: ["value"],
+  required: ["value", "start"],
   additionalProperties: false
 };
-var outputSchema25 = {
+var outputSchema29 = {
   type: "object",
   properties: {
     result: {
-      type: "number",
+      type: "string",
       title: "Result",
-      description: "Rounded value"
+      description: "Extracted substring"
     }
   },
   required: ["result"],
   additionalProperties: false
 };
 
-class ScalarRoundTask extends Task28 {
-  static type = "ScalarRoundTask";
-  static category = "Math";
-  static title = "Round";
-  static description = "Returns the value of a number rounded to the nearest integer";
+class StringSliceTask extends Task32 {
+  static type = "StringSliceTask";
+  static category = "String";
+  static title = "Slice";
+  static description = "Extracts a substring by start and optional end index";
   static inputSchema() {
-    return inputSchema26;
+    return inputSchema30;
   }
   static outputSchema() {
-    return outputSchema25;
+    return outputSchema29;
   }
-  async execute(input2, _context) {
-    return { result: Math.round(input2.value) };
+  async executeReactive(input2, output, _context) {
+    return { result: input2.value.slice(input2.start, input2.end) };
   }
 }
-Workflow32.prototype.scalarRound = CreateWorkflow31(ScalarRoundTask);
-// src/task/scalar/ScalarTruncTask.ts
-import { CreateWorkflow as CreateWorkflow32, Task as Task29, Workflow as Workflow33 } from "@workglow/task-graph";
-var inputSchema27 = {
+Workflow35.prototype.stringSlice = CreateWorkflow34(StringSliceTask);
+// src/task/string/StringTemplateTask.ts
+import {
+  CreateWorkflow as CreateWorkflow35,
+  Task as Task33,
+  Workflow as Workflow36
+} from "@workglow/task-graph";
+var inputSchema31 = {
   type: "object",
   properties: {
-    value: {
-      type: "number",
-      title: "Value",
-      description: "Input number"
+    template: {
+      type: "string",
+      title: "Template",
+      description: "Template string with {{key}} placeholders"
+    },
+    values: {
+      type: "object",
+      title: "Values",
+      description: "Key-value pairs to substitute into the template",
+      additionalProperties: true
     }
   },
-  required: ["value"],
+  required: ["template", "values"],
   additionalProperties: false
 };
-var outputSchema26 = {
+var outputSchema30 = {
   type: "object",
   properties: {
     result: {
-      type: "number",
+      type: "string",
       title: "Result",
-      description: "Truncated value"
+      description: "Template with placeholders replaced by values"
     }
   },
   required: ["result"],
   additionalProperties: false
 };
 
-class ScalarTruncTask extends Task29 {
-  static type = "ScalarTruncTask";
-  static category = "Math";
-  static title = "Truncate";
-  static description = "Returns the integer part of a number by removing fractional digits";
+class StringTemplateTask extends Task33 {
+  static type = "StringTemplateTask";
+  static category = "String";
+  static title = "Template";
+  static description = "Replaces {{key}} placeholders in a template string with values";
   static inputSchema() {
-    return inputSchema27;
+    return inputSchema31;
   }
   static outputSchema() {
-    return outputSchema26;
+    return outputSchema30;
   }
-  async execute(input2, _context) {
-    return { result: Math.trunc(input2.value) };
+  async executeReactive(input2, output, _context) {
+    let result = input2.template;
+    for (const [key, value] of Object.entries(input2.values)) {
+      result = result.replaceAll(`{{${key}}}`, String(value));
+    }
+    return { result };
   }
 }
-Workflow33.prototype.scalarTrunc = CreateWorkflow32(ScalarTruncTask);
-// src/task/vector/VectorDistanceTask.ts
-import { CreateWorkflow as CreateWorkflow33, Task as Task30, Workflow as Workflow34 } from "@workglow/task-graph";
+Workflow36.prototype.stringTemplate = CreateWorkflow35(StringTemplateTask);
+// src/task/string/StringTrimTask.ts
 import {
-  TypedArraySchema as TypedArraySchema5
-} from "@workglow/util";
-var inputSchema28 = {
+  CreateWorkflow as CreateWorkflow36,
+  Task as Task34,
+  Workflow as Workflow37
+} from "@workglow/task-graph";
+var inputSchema32 = {
   type: "object",
   properties: {
-    vectors: {
-      type: "array",
-      items: TypedArraySchema5({
-        title: "Vector",
-        description: "Vector for distance computation"
-      }),
-      title: "Vectors",
-      description: "Array of two vectors to compute Euclidean distance"
+    value: {
+      type: "string",
+      title: "Value",
+      description: "Input string"
     }
   },
-  required: ["vectors"],
+  required: ["value"],
   additionalProperties: false
 };
-var outputSchema27 = {
+var outputSchema31 = {
   type: "object",
   properties: {
     result: {
-      type: "number",
+      type: "string",
       title: "Result",
-      description: "Euclidean distance between vectors"
+      description: "Trimmed string"
     }
   },
   required: ["result"],
   additionalProperties: false
 };
 
-class VectorDistanceTask extends Task30 {
-  static type = "VectorDistanceTask";
-  static category = "Vector";
-  static title = "Distance";
-  static description = "Returns the Euclidean distance between the first two vectors";
+class StringTrimTask extends Task34 {
+  static type = "StringTrimTask";
+  static category = "String";
+  static title = "Trim";
+  static description = "Removes leading and trailing whitespace from a string";
   static inputSchema() {
-    return inputSchema28;
+    return inputSchema32;
   }
   static outputSchema() {
-    return outputSchema27;
+    return outputSchema31;
   }
-  async execute(input2, _context) {
-    const { vectors } = input2;
-    if (vectors.length < 2) {
-      throw new Error("Exactly two vectors are required for distance");
-    }
-    const [a, b] = vectors;
-    if (a.length !== b.length) {
-      throw new Error("Vectors must have the same length");
-    }
-    const diffs = Array.from({ length: a.length }, (_, i) => {
-      const d = Number(a[i]) - Number(b[i]);
-      return d * d;
-    });
-    return { result: Math.sqrt(sumPrecise(diffs)) };
+  async executeReactive(input2, output, _context) {
+    return { result: input2.value.trim() };
   }
 }
-Workflow34.prototype.vectorDistance = CreateWorkflow33(VectorDistanceTask);
-// src/task/vector/VectorDotProductTask.ts
-import { CreateWorkflow as CreateWorkflow34, Task as Task31, Workflow as Workflow35 } from "@workglow/task-graph";
+Workflow37.prototype.stringTrim = CreateWorkflow36(StringTrimTask);
+// src/task/string/StringUpperCaseTask.ts
 import {
-  TypedArraySchema as TypedArraySchema6
-} from "@workglow/util";
-var inputSchema29 = {
+  CreateWorkflow as CreateWorkflow37,
+  Task as Task35,
+  Workflow as Workflow38
+} from "@workglow/task-graph";
+var inputSchema33 = {
   type: "object",
   properties: {
-    vectors: {
-      type: "array",
-      items: TypedArraySchema6({
-        title: "Vector",
-        description: "Vector for dot product"
-      }),
-      title: "Vectors",
-      description: "Array of two vectors to compute dot product"
+    value: {
+      type: "string",
+      title: "Value",
+      description: "Input string"
     }
   },
-  required: ["vectors"],
+  required: ["value"],
   additionalProperties: false
 };
-var outputSchema28 = {
+var outputSchema32 = {
   type: "object",
   properties: {
     result: {
-      type: "number",
+      type: "string",
       title: "Result",
-      description: "Dot product of the vectors"
+      description: "Uppercased string"
     }
   },
   required: ["result"],
   additionalProperties: false
 };
 
-class VectorDotProductTask extends Task31 {
-  static type = "VectorDotProductTask";
-  static category = "Vector";
-  static title = "Dot Product";
-  static description = "Returns the dot (inner) product of the first two vectors";
+class StringUpperCaseTask extends Task35 {
+  static type = "StringUpperCaseTask";
+  static category = "String";
+  static title = "Upper Case";
+  static description = "Converts a string to upper case";
   static inputSchema() {
-    return inputSchema29;
+    return inputSchema33;
   }
   static outputSchema() {
-    return outputSchema28;
+    return outputSchema32;
   }
-  async execute(input2, _context) {
-    const { vectors } = input2;
-    if (vectors.length < 2) {
-      throw new Error("Exactly two vectors are required for dot product");
+  async executeReactive(input2, output, _context) {
+    return { result: input2.value.toUpperCase() };
+  }
+}
+Workflow38.prototype.stringUpperCase = CreateWorkflow37(StringUpperCaseTask);
+// src/task/scalar/ScalarAbsTask.ts
+import { CreateWorkflow as CreateWorkflow38, Task as Task36, Workflow as Workflow39 } from "@workglow/task-graph";
+var inputSchema34 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "number",
+      title: "Value",
+      description: "Input number"
     }
-    const [a, b] = vectors;
-    if (a.length !== b.length) {
-      throw new Error("Vectors must have the same length");
+  },
+  required: ["value"],
+  additionalProperties: false
+};
+var outputSchema33 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Absolute value"
     }
-    const products = Array.from({ length: a.length }, (_, i) => Number(a[i]) * Number(b[i]));
-    return { result: sumPrecise(products) };
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarAbsTask extends Task36 {
+  static type = "ScalarAbsTask";
+  static category = "Math";
+  static title = "Abs";
+  static description = "Returns the absolute value of a number";
+  static inputSchema() {
+    return inputSchema34;
+  }
+  static outputSchema() {
+    return outputSchema33;
+  }
+  async execute(input2, _context) {
+    return { result: Math.abs(input2.value) };
   }
 }
-Workflow35.prototype.vectorDotProduct = CreateWorkflow34(VectorDotProductTask);
-// src/task/vector/VectorNormalizeTask.ts
-import { CreateWorkflow as CreateWorkflow35, Task as Task32, Workflow as Workflow36 } from "@workglow/task-graph";
-import {
-  TypedArraySchema as TypedArraySchema7,
-  normalize
-} from "@workglow/util";
-var inputSchema30 = {
+Workflow39.prototype.scalarAbs = CreateWorkflow38(ScalarAbsTask);
+// src/task/scalar/ScalarCeilTask.ts
+import { CreateWorkflow as CreateWorkflow39, Task as Task37, Workflow as Workflow40 } from "@workglow/task-graph";
+var inputSchema35 = {
   type: "object",
   properties: {
-    vector: TypedArraySchema7({
-      title: "Vector",
-      description: "Input vector to normalize"
-    })
+    value: {
+      type: "number",
+      title: "Value",
+      description: "Input number"
+    }
   },
-  required: ["vector"],
+  required: ["value"],
   additionalProperties: false
 };
-var outputSchema29 = {
+var outputSchema34 = {
   type: "object",
   properties: {
-    result: TypedArraySchema7({
+    result: {
+      type: "number",
       title: "Result",
-      description: "L2-normalized vector"
-    })
+      description: "Ceiling value"
+    }
   },
   required: ["result"],
   additionalProperties: false
 };
 
-class VectorNormalizeTask extends Task32 {
-  static type = "VectorNormalizeTask";
-  static category = "Vector";
-  static title = "Normalize";
-  static description = "Returns the L2-normalized (unit length) vector";
+class ScalarCeilTask extends Task37 {
+  static type = "ScalarCeilTask";
+  static category = "Math";
+  static title = "Ceil";
+  static description = "Returns the smallest integer greater than or equal to a number";
   static inputSchema() {
-    return inputSchema30;
+    return inputSchema35;
   }
   static outputSchema() {
-    return outputSchema29;
+    return outputSchema34;
   }
   async execute(input2, _context) {
-    return { result: normalize(input2.vector) };
+    return { result: Math.ceil(input2.value) };
   }
 }
-Workflow36.prototype.vectorNormalize = CreateWorkflow35(VectorNormalizeTask);
-// src/task/vector/VectorScaleTask.ts
-import { CreateWorkflow as CreateWorkflow36, Task as Task33, Workflow as Workflow37 } from "@workglow/task-graph";
-import {
-  createTypedArrayFrom as createTypedArrayFrom5,
-  TypedArraySchema as TypedArraySchema8
-} from "@workglow/util";
-var inputSchema31 = {
+Workflow40.prototype.scalarCeil = CreateWorkflow39(ScalarCeilTask);
+// src/task/scalar/ScalarFloorTask.ts
+import { CreateWorkflow as CreateWorkflow40, Task as Task38, Workflow as Workflow41 } from "@workglow/task-graph";
+var inputSchema36 = {
   type: "object",
   properties: {
-    vector: TypedArraySchema8({
-      title: "Vector",
-      description: "Input vector"
-    }),
-    scalar: {
+    value: {
       type: "number",
-      title: "Scalar",
-      description: "Scalar multiplier"
+      title: "Value",
+      description: "Input number"
     }
   },
-  required: ["vector", "scalar"],
+  required: ["value"],
   additionalProperties: false
 };
-var outputSchema30 = {
+var outputSchema35 = {
   type: "object",
   properties: {
-    result: TypedArraySchema8({
+    result: {
+      type: "number",
       title: "Result",
-      description: "Scaled vector"
-    })
+      description: "Floored value"
+    }
   },
   required: ["result"],
   additionalProperties: false
 };
 
-class VectorScaleTask extends Task33 {
-  static type = "VectorScaleTask";
-  static category = "Vector";
-  static title = "Scale";
-  static description = "Multiplies each element of a vector by a scalar";
+class ScalarFloorTask extends Task38 {
+  static type = "ScalarFloorTask";
+  static category = "Math";
+  static title = "Floor";
+  static description = "Returns the largest integer less than or equal to a number";
   static inputSchema() {
-    return inputSchema31;
+    return inputSchema36;
   }
   static outputSchema() {
-    return outputSchema30;
+    return outputSchema35;
   }
   async execute(input2, _context) {
-    const { vector, scalar } = input2;
-    const values = Array.from(vector, (v) => Number(v) * scalar);
-    return { result: createTypedArrayFrom5([vector], values) };
+    return { result: Math.floor(input2.value) };
   }
 }
-Workflow37.prototype.vectorScale = CreateWorkflow36(VectorScaleTask);
+Workflow41.prototype.scalarFloor = CreateWorkflow40(ScalarFloorTask);
+// src/task/scalar/ScalarMaxTask.ts
+import { CreateWorkflow as CreateWorkflow41, Task as Task39, Workflow as Workflow42 } from "@workglow/task-graph";
+var inputSchema37 = {
+  type: "object",
+  properties: {
+    values: {
+      type: "array",
+      items: { type: "number" },
+      title: "Values",
+      description: "Array of numbers"
+    }
+  },
+  required: ["values"],
+  additionalProperties: false
+};
+var outputSchema36 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Maximum value"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
 
-// src/common.ts
-import { TaskRegistry } from "@workglow/task-graph";
-var registerCommonTasks = () => {
-  const tasks = [
-    DebugLogTask,
-    DelayTask,
-    FetchUrlTask,
-    InputTask,
-    JavaScriptTask,
-    JsonTask,
-    LambdaTask,
-    MergeTask,
-    OutputTask,
-    SplitTask,
-    ScalarAbsTask,
-    ScalarAddTask,
-    ScalarCeilTask,
-    ScalarDivideTask,
-    ScalarFloorTask,
-    ScalarMaxTask,
-    ScalarMinTask,
-    ScalarMultiplyTask,
-    ScalarRoundTask,
-    ScalarSubtractTask,
-    ScalarSumTask,
-    ScalarTruncTask,
-    VectorSumTask,
-    VectorDistanceTask,
-    VectorDivideTask,
-    VectorDotProductTask,
-    VectorMultiplyTask,
-    VectorNormalizeTask,
-    VectorScaleTask,
-    VectorSubtractTask,
-    McpToolCallTask,
-    McpResourceReadTask,
-    McpPromptGetTask,
-    McpListTask
-  ];
-  tasks.map(TaskRegistry.registerTask);
-  return tasks;
+class ScalarMaxTask extends Task39 {
+  static type = "ScalarMaxTask";
+  static category = "Math";
+  static title = "Max";
+  static description = "Returns the largest of the given numbers";
+  static inputSchema() {
+    return inputSchema37;
+  }
+  static outputSchema() {
+    return outputSchema36;
+  }
+  async execute(input2, _context) {
+    return { result: Math.max(...input2.values) };
+  }
+}
+Workflow42.prototype.scalarMax = CreateWorkflow41(ScalarMaxTask);
+// src/task/scalar/ScalarMinTask.ts
+import { CreateWorkflow as CreateWorkflow42, Task as Task40, Workflow as Workflow43 } from "@workglow/task-graph";
+var inputSchema38 = {
+  type: "object",
+  properties: {
+    values: {
+      type: "array",
+      items: { type: "number" },
+      title: "Values",
+      description: "Array of numbers"
+    }
+  },
+  required: ["values"],
+  additionalProperties: false
+};
+var outputSchema37 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Minimum value"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
 };
 
-// src/bun.ts
-[FileLoaderTask2].map(TaskRegistry2.registerTask);
+class ScalarMinTask extends Task40 {
+  static type = "ScalarMinTask";
+  static category = "Math";
+  static title = "Min";
+  static description = "Returns the smallest of the given numbers";
+  static inputSchema() {
+    return inputSchema38;
+  }
+  static outputSchema() {
+    return outputSchema37;
+  }
+  async execute(input2, _context) {
+    return { result: Math.min(...input2.values) };
+  }
+}
+Workflow43.prototype.scalarMin = CreateWorkflow42(ScalarMinTask);
+// src/task/scalar/ScalarRoundTask.ts
+import { CreateWorkflow as CreateWorkflow43, Task as Task41, Workflow as Workflow44 } from "@workglow/task-graph";
+var inputSchema39 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "number",
+      title: "Value",
+      description: "Input number"
+    }
+  },
+  required: ["value"],
+  additionalProperties: false
+};
+var outputSchema38 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Rounded value"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarRoundTask extends Task41 {
+  static type = "ScalarRoundTask";
+  static category = "Math";
+  static title = "Round";
+  static description = "Returns the value of a number rounded to the nearest integer";
+  static inputSchema() {
+    return inputSchema39;
+  }
+  static outputSchema() {
+    return outputSchema38;
+  }
+  async execute(input2, _context) {
+    return { result: Math.round(input2.value) };
+  }
+}
+Workflow44.prototype.scalarRound = CreateWorkflow43(ScalarRoundTask);
+// src/task/scalar/ScalarTruncTask.ts
+import { CreateWorkflow as CreateWorkflow44, Task as Task42, Workflow as Workflow45 } from "@workglow/task-graph";
+var inputSchema40 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "number",
+      title: "Value",
+      description: "Input number"
+    }
+  },
+  required: ["value"],
+  additionalProperties: false
+};
+var outputSchema39 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Truncated value"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarTruncTask extends Task42 {
+  static type = "ScalarTruncTask";
+  static category = "Math";
+  static title = "Truncate";
+  static description = "Returns the integer part of a number by removing fractional digits";
+  static inputSchema() {
+    return inputSchema40;
+  }
+  static outputSchema() {
+    return outputSchema39;
+  }
+  async execute(input2, _context) {
+    return { result: Math.trunc(input2.value) };
+  }
+}
+Workflow45.prototype.scalarTrunc = CreateWorkflow44(ScalarTruncTask);
+// src/task/vector/VectorDistanceTask.ts
+import { CreateWorkflow as CreateWorkflow45, Task as Task43, Workflow as Workflow46 } from "@workglow/task-graph";
+import {
+  TypedArraySchema as TypedArraySchema5
+} from "@workglow/util";
+var inputSchema41 = {
+  type: "object",
+  properties: {
+    vectors: {
+      type: "array",
+      items: TypedArraySchema5({
+        title: "Vector",
+        description: "Vector for distance computation"
+      }),
+      title: "Vectors",
+      description: "Array of two vectors to compute Euclidean distance"
+    }
+  },
+  required: ["vectors"],
+  additionalProperties: false
+};
+var outputSchema40 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Euclidean distance between vectors"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class VectorDistanceTask extends Task43 {
+  static type = "VectorDistanceTask";
+  static category = "Vector";
+  static title = "Distance";
+  static description = "Returns the Euclidean distance between the first two vectors";
+  static inputSchema() {
+    return inputSchema41;
+  }
+  static outputSchema() {
+    return outputSchema40;
+  }
+  async execute(input2, _context) {
+    const { vectors } = input2;
+    if (vectors.length < 2) {
+      throw new Error("Exactly two vectors are required for distance");
+    }
+    const [a, b] = vectors;
+    if (a.length !== b.length) {
+      throw new Error("Vectors must have the same length");
+    }
+    const diffs = Array.from({ length: a.length }, (_, i) => {
+      const d = Number(a[i]) - Number(b[i]);
+      return d * d;
+    });
+    return { result: Math.sqrt(sumPrecise(diffs)) };
+  }
+}
+Workflow46.prototype.vectorDistance = CreateWorkflow45(VectorDistanceTask);
+// src/task/vector/VectorDotProductTask.ts
+import { CreateWorkflow as CreateWorkflow46, Task as Task44, Workflow as Workflow47 } from "@workglow/task-graph";
+import {
+  TypedArraySchema as TypedArraySchema6
+} from "@workglow/util";
+var inputSchema42 = {
+  type: "object",
+  properties: {
+    vectors: {
+      type: "array",
+      items: TypedArraySchema6({
+        title: "Vector",
+        description: "Vector for dot product"
+      }),
+      title: "Vectors",
+      description: "Array of two vectors to compute dot product"
+    }
+  },
+  required: ["vectors"],
+  additionalProperties: false
+};
+var outputSchema41 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Dot product of the vectors"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class VectorDotProductTask extends Task44 {
+  static type = "VectorDotProductTask";
+  static category = "Vector";
+  static title = "Dot Product";
+  static description = "Returns the dot (inner) product of the first two vectors";
+  static inputSchema() {
+    return inputSchema42;
+  }
+  static outputSchema() {
+    return outputSchema41;
+  }
+  async execute(input2, _context) {
+    const { vectors } = input2;
+    if (vectors.length < 2) {
+      throw new Error("Exactly two vectors are required for dot product");
+    }
+    const [a, b] = vectors;
+    if (a.length !== b.length) {
+      throw new Error("Vectors must have the same length");
+    }
+    const products = Array.from({ length: a.length }, (_, i) => Number(a[i]) * Number(b[i]));
+    return { result: sumPrecise(products) };
+  }
+}
+Workflow47.prototype.vectorDotProduct = CreateWorkflow46(VectorDotProductTask);
+// src/task/vector/VectorNormalizeTask.ts
+import { CreateWorkflow as CreateWorkflow47, Task as Task45, Workflow as Workflow48 } from "@workglow/task-graph";
+import {
+  TypedArraySchema as TypedArraySchema7,
+  normalize
+} from "@workglow/util";
+var inputSchema43 = {
+  type: "object",
+  properties: {
+    vector: TypedArraySchema7({
+      title: "Vector",
+      description: "Input vector to normalize"
+    })
+  },
+  required: ["vector"],
+  additionalProperties: false
+};
+var outputSchema42 = {
+  type: "object",
+  properties: {
+    result: TypedArraySchema7({
+      title: "Result",
+      description: "L2-normalized vector"
+    })
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class VectorNormalizeTask extends Task45 {
+  static type = "VectorNormalizeTask";
+  static category = "Vector";
+  static title = "Normalize";
+  static description = "Returns the L2-normalized (unit length) vector";
+  static inputSchema() {
+    return inputSchema43;
+  }
+  static outputSchema() {
+    return outputSchema42;
+  }
+  async execute(input2, _context) {
+    return { result: normalize(input2.vector) };
+  }
+}
+Workflow48.prototype.vectorNormalize = CreateWorkflow47(VectorNormalizeTask);
+// src/task/vector/VectorScaleTask.ts
+import { CreateWorkflow as CreateWorkflow48, Task as Task46, Workflow as Workflow49 } from "@workglow/task-graph";
+import {
+  createTypedArrayFrom as createTypedArrayFrom5,
+  TypedArraySchema as TypedArraySchema8
+} from "@workglow/util";
+var inputSchema44 = {
+  type: "object",
+  properties: {
+    vector: TypedArraySchema8({
+      title: "Vector",
+      description: "Input vector"
+    }),
+    scalar: {
+      type: "number",
+      title: "Scalar",
+      description: "Scalar multiplier"
+    }
+  },
+  required: ["vector", "scalar"],
+  additionalProperties: false
+};
+var outputSchema43 = {
+  type: "object",
+  properties: {
+    result: TypedArraySchema8({
+      title: "Result",
+      description: "Scaled vector"
+    })
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class VectorScaleTask extends Task46 {
+  static type = "VectorScaleTask";
+  static category = "Vector";
+  static title = "Scale";
+  static description = "Multiplies each element of a vector by a scalar";
+  static inputSchema() {
+    return inputSchema44;
+  }
+  static outputSchema() {
+    return outputSchema43;
+  }
+  async execute(input2, _context) {
+    const { vector, scalar } = input2;
+    const values = Array.from(vector, (v) => Number(v) * scalar);
+    return { result: createTypedArrayFrom5([vector], values) };
+  }
+}
+Workflow49.prototype.vectorScale = CreateWorkflow48(VectorScaleTask);
+
+// src/common.ts
+import { TaskRegistry } from "@workglow/task-graph";
+var registerCommonTasks = () => {
+  const tasks = [
+    DebugLogTask,
+    DelayTask,
+    FetchUrlTask,
+    InputTask,
+    JavaScriptTask,
+    JsonTask,
+    LambdaTask,
+    MergeTask,
+    OutputTask,
+    SplitTask,
+    ScalarAbsTask,
+    ScalarAddTask,
+    ScalarCeilTask,
+    ScalarDivideTask,
+    ScalarFloorTask,
+    ScalarMaxTask,
+    ScalarMinTask,
+    ScalarMultiplyTask,
+    ScalarRoundTask,
+    ScalarSubtractTask,
+    ScalarSumTask,
+    ScalarTruncTask,
+    VectorSumTask,
+    VectorDistanceTask,
+    VectorDivideTask,
+    VectorDotProductTask,
+    VectorMultiplyTask,
+    VectorNormalizeTask,
+    VectorScaleTask,
+    VectorSubtractTask,
+    McpToolCallTask,
+    McpResourceReadTask,
+    McpPromptGetTask,
+    McpListTask,
+    StringConcatTask,
+    StringIncludesTask,
+    StringJoinTask,
+    StringLengthTask,
+    StringLowerCaseTask,
+    StringReplaceTask,
+    StringSliceTask,
+    StringTemplateTask,
+    StringTrimTask,
+    StringUpperCaseTask,
+    JsonPathTask,
+    TemplateTask,
+    DateFormatTask,
+    RegexTask
+  ];
+  tasks.map(TaskRegistry.registerTask);
+  return tasks;
+};
+
+// src/task/FileLoaderTask.server.ts
+import {
+  CreateWorkflow as CreateWorkflow50,
+  TaskAbortedError as TaskAbortedError3,
+  Workflow as Workflow51
+} from "@workglow/task-graph";
+import { readFile } from "fs/promises";
+
+// src/task/FileLoaderTask.ts
+import {
+  CreateWorkflow as CreateWorkflow49,
+  Task as Task47,
+  TaskAbortedError as TaskAbortedError2,
+  Workflow as Workflow50
+} from "@workglow/task-graph";
+import Papa from "papaparse";
+var inputSchema45 = {
+  type: "object",
+  properties: {
+    url: {
+      type: "string",
+      title: "URL",
+      description: "URL to load document from (http://, https://)",
+      format: "uri"
+    },
+    format: {
+      type: "string",
+      enum: ["text", "markdown", "json", "csv", "pdf", "image", "html", "auto"],
+      title: "Format",
+      description: "File format (auto-detected from URL if 'auto')",
+      default: "auto"
+    }
+  },
+  required: ["url"],
+  additionalProperties: false
+};
+var outputSchema44 = {
+  type: "object",
+  properties: {
+    text: {
+      type: "string",
+      title: "Text",
+      description: "Text content (for text, markdown, html formats)"
+    },
+    json: {
+      title: "JSON",
+      description: "Parsed JSON object or array"
+    },
+    csv: {
+      type: "array",
+      title: "CSV",
+      description: "Parsed CSV data as array of objects"
+    },
+    image: {
+      type: "string",
+      title: "Image",
+      description: "Base64 data URL for image files",
+      format: "image:data-uri"
+    },
+    pdf: {
+      type: "string",
+      title: "PDF",
+      description: "Base64 data URL for PDF files"
+    },
+    frontmatter: {
+      type: "object",
+      title: "Frontmatter",
+      description: "Parsed YAML frontmatter from markdown/MDX files"
+    },
+    metadata: {
+      type: "object",
+      properties: {
+        url: { type: "string" },
+        format: { type: "string" },
+        size: { type: "number" },
+        title: { type: "string" },
+        mimeType: { type: "string" }
+      },
+      additionalProperties: false,
+      title: "Metadata",
+      description: "File metadata"
+    }
+  },
+  required: ["metadata"],
+  additionalProperties: false
+};
+
+class FileLoaderTask extends Task47 {
+  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;
+  }
+  static outputSchema() {
+    return outputSchema44;
+  }
+  async execute(input2, context) {
+    const { url, format = "auto" } = input2;
+    if (context.signal.aborted) {
+      throw new TaskAbortedError2("Task aborted");
+    }
+    await context.updateProgress(0, "Detecting file format");
+    const detectedFormat = this.detectFormat(url, format);
+    const responseType = this.detectResponseType(detectedFormat);
+    if (context.signal.aborted) {
+      throw new TaskAbortedError2("Task aborted");
+    }
+    await context.updateProgress(10, `Fetching ${detectedFormat} file from ${url}`);
+    const fetchTask = context.own(new FetchUrlTask({
+      url,
+      response_type: responseType,
+      queue: false
+    }));
+    const response = await fetchTask.run();
+    if (context.signal.aborted) {
+      throw new TaskAbortedError2("Task aborted");
+    }
+    await context.updateProgress(60, "Parsing file content");
+    const title = url.split("/").pop() || url;
+    const { text, json: json2, csv, image, pdf, frontmatter, size, mimeType } = await this.parseResponse(response, url, detectedFormat);
+    if (context.signal.aborted) {
+      throw new TaskAbortedError2("Task aborted");
+    }
+    await context.updateProgress(100, "File loaded successfully");
+    return {
+      text,
+      json: json2,
+      csv,
+      image,
+      pdf,
+      frontmatter,
+      metadata: {
+        url,
+        format: detectedFormat,
+        size,
+        title,
+        mimeType
+      }
+    };
+  }
+  parseJsonContent(content) {
+    return JSON.parse(content);
+  }
+  parseCsvContent(content) {
+    try {
+      const result = Papa.parse(content, {
+        header: true,
+        skipEmptyLines: true,
+        transformHeader: (header) => header.trim()
+      });
+      return result.data;
+    } catch (error) {
+      throw new Error(`Failed to parse CSV: ${error}`);
+    }
+  }
+  parseFrontmatter(content) {
+    const trimmed = content.replace(/^\uFEFF/, "");
+    if (!trimmed.startsWith(`---
+`) && !trimmed.startsWith(`---\r
+`)) {
+      return { frontmatter: undefined, body: content };
+    }
+    const firstDelimEnd = trimmed.indexOf(`
+`) + 1;
+    const closingIdx = trimmed.indexOf(`
+---`, firstDelimEnd);
+    if (closingIdx === -1) {
+      return { frontmatter: undefined, body: content };
+    }
+    const yamlBlock = trimmed.slice(firstDelimEnd, closingIdx);
+    const afterClosing = closingIdx + 4;
+    let bodyStart = afterClosing;
+    if (trimmed[bodyStart] === "\r")
+      bodyStart++;
+    if (trimmed[bodyStart] === `
+`)
+      bodyStart++;
+    const body = trimmed.slice(bodyStart).replace(/^\r?\n/, "");
+    const frontmatter = this.parseSimpleYaml(yamlBlock);
+    return { frontmatter, body };
+  }
+  parseSimpleYaml(yaml) {
+    const result = {};
+    const lines = yaml.split(/\r?\n/);
+    let i = 0;
+    while (i < lines.length) {
+      i = this.parseYamlLine(lines, i, result, 0);
+    }
+    return result;
+  }
+  parseYamlLine(lines, index, target, indent) {
+    if (index >= lines.length)
+      return index + 1;
+    const line = lines[index];
+    if (line.trim() === "" || line.trim().startsWith("#")) {
+      return index + 1;
+    }
+    const lineIndent = line.length - line.trimStart().length;
+    if (lineIndent < indent)
+      return index;
+    const match = line.match(/^(\s*)([^:#]+?)\s*:\s*(.*)?$/);
+    if (!match)
+      return index + 1;
+    const key = match[2].trim();
+    const rawValue = (match[3] ?? "").trim();
+    if (rawValue === "" || rawValue === "|" || rawValue === ">") {
+      const nextIndex = index + 1;
+      if (nextIndex < lines.length) {
+        const nextLine = lines[nextIndex];
+        const nextTrimmed = nextLine.trimStart();
+        const nextIndent = nextLine.length - nextTrimmed.length;
+        if (nextIndent > lineIndent && nextTrimmed.startsWith("- ")) {
+          const arr = [];
+          let j = nextIndex;
+          while (j < lines.length) {
+            const arrLine = lines[j];
+            const arrTrimmed = arrLine.trimStart();
+            const arrIndent = arrLine.length - arrTrimmed.length;
+            if (arrTrimmed === "" || arrTrimmed.startsWith("#")) {
+              j++;
+              continue;
+            }
+            if (arrIndent < nextIndent)
+              break;
+            if (arrTrimmed.startsWith("- ")) {
+              arr.push(this.parseYamlValue(arrTrimmed.slice(2).trim()));
+              j++;
+            } else {
+              break;
+            }
+          }
+          target[key] = arr;
+          return j;
+        } else if (nextIndent > lineIndent) {
+          const nested = {};
+          let j = nextIndex;
+          while (j < lines.length) {
+            const nestedLine = lines[j];
+            const nestedTrimmed = nestedLine.trimStart();
+            const nestedIndent = nestedLine.length - nestedTrimmed.length;
+            if (nestedTrimmed === "" || nestedTrimmed.startsWith("#")) {
+              j++;
+              continue;
+            }
+            if (nestedIndent < nextIndent)
+              break;
+            j = this.parseYamlLine(lines, j, nested, nextIndent);
+          }
+          target[key] = nested;
+          return j;
+        }
+      }
+      target[key] = rawValue === "" ? null : rawValue;
+      return index + 1;
+    }
+    target[key] = this.parseYamlValue(rawValue);
+    return index + 1;
+  }
+  parseYamlValue(raw) {
+    if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+      return raw.slice(1, -1);
+    }
+    if (raw === "true" || raw === "True" || raw === "TRUE")
+      return true;
+    if (raw === "false" || raw === "False" || raw === "FALSE")
+      return false;
+    if (raw === "null" || raw === "~")
+      return null;
+    if (/^-?\d+(\.\d+)?$/.test(raw))
+      return Number(raw);
+    if (raw.startsWith("[") && raw.endsWith("]")) {
+      return raw.slice(1, -1).split(",").map((item) => this.parseYamlValue(item.trim()));
+    }
+    return raw;
+  }
+  async parseResponse(response, url, detectedFormat) {
+    const responseMimeType = response.metadata?.contentType || "";
+    if (detectedFormat === "json") {
+      if (!response.json) {
+        throw new Error(`Failed to load JSON from ${url}`);
+      }
+      const jsonData = response.json;
+      const content2 = JSON.stringify(jsonData, null, 2);
+      return {
+        text: undefined,
+        json: jsonData,
+        csv: undefined,
+        image: undefined,
+        pdf: undefined,
+        frontmatter: undefined,
+        size: content2.length,
+        mimeType: responseMimeType || "application/json"
+      };
+    }
+    if (detectedFormat === "csv") {
+      const content2 = response.text || "";
+      if (!content2) {
+        throw new Error(`Failed to load CSV from ${url}`);
+      }
+      const csvData = this.parseCsvContent(content2);
+      return {
+        text: undefined,
+        json: undefined,
+        csv: csvData,
+        image: undefined,
+        pdf: undefined,
+        frontmatter: undefined,
+        size: content2.length,
+        mimeType: responseMimeType || "text/csv"
+      };
+    }
+    if (detectedFormat === "image") {
+      if (!response.blob) {
+        throw new Error(`Failed to load image from ${url}`);
+      }
+      const blob = response.blob;
+      const mimeType2 = responseMimeType || (blob.type && blob.type !== "" ? blob.type : this.getImageMimeType(url));
+      const imageData = await this.blobToBase64DataURL(blob, mimeType2);
+      return {
+        text: undefined,
+        json: undefined,
+        csv: undefined,
+        image: imageData,
+        pdf: undefined,
+        frontmatter: undefined,
+        size: blob.size,
+        mimeType: mimeType2
+      };
+    }
+    if (detectedFormat === "pdf") {
+      if (!response.blob) {
+        throw new Error(`Failed to load PDF from ${url}`);
+      }
+      const blob = response.blob;
+      const mimeType2 = responseMimeType || "application/pdf";
+      const pdfData = await this.blobToBase64DataURL(blob, mimeType2);
+      return {
+        text: undefined,
+        json: undefined,
+        csv: undefined,
+        image: undefined,
+        pdf: pdfData,
+        frontmatter: undefined,
+        size: blob.size,
+        mimeType: mimeType2
+      };
+    }
+    const content = response.text || "";
+    if (!content) {
+      throw new Error(`Failed to load content from ${url}`);
+    }
+    const mimeType = responseMimeType || (detectedFormat === "markdown" ? "text/markdown" : detectedFormat === "html" ? "text/html" : "text/plain");
+    if (detectedFormat === "markdown") {
+      const { frontmatter, body } = this.parseFrontmatter(content);
+      return {
+        text: body,
+        json: undefined,
+        csv: undefined,
+        image: undefined,
+        pdf: undefined,
+        frontmatter,
+        size: content.length,
+        mimeType
+      };
+    }
+    return {
+      text: content,
+      json: undefined,
+      csv: undefined,
+      image: undefined,
+      pdf: undefined,
+      frontmatter: undefined,
+      size: content.length,
+      mimeType
+    };
+  }
+  detectResponseType(detectedFormat) {
+    let responseType = "text";
+    if (detectedFormat === "json") {
+      responseType = "json";
+    } else if (detectedFormat === "image" || detectedFormat === "pdf") {
+      responseType = "blob";
+    } else if (detectedFormat === "csv" || detectedFormat === "text" || detectedFormat === "markdown" || detectedFormat === "html") {
+      responseType = "text";
+    }
+    return responseType;
+  }
+  detectFormat(url, format) {
+    if (format === "auto") {
+      const urlLower = url.toLowerCase();
+      if (urlLower.endsWith(".md") || urlLower.endsWith(".mdx") || urlLower.endsWith(".markdown")) {
+        return "markdown";
+      } else if (urlLower.endsWith(".json")) {
+        return "json";
+      } else if (urlLower.endsWith(".csv")) {
+        return "csv";
+      } else if (urlLower.endsWith(".pdf")) {
+        return "pdf";
+      } else if (urlLower.match(/\.(jpg|jpeg|png|gif|bmp|webp|svg|ico)$/)) {
+        return "image";
+      } else if (urlLower.endsWith(".html") || urlLower.endsWith(".htm")) {
+        return "html";
+      } else {
+        return "text";
+      }
+    }
+    return format;
+  }
+  getImageMimeType(url) {
+    const urlLower = url.toLowerCase();
+    if (urlLower.endsWith(".png"))
+      return "image/png";
+    if (urlLower.endsWith(".jpg") || urlLower.endsWith(".jpeg"))
+      return "image/jpeg";
+    if (urlLower.endsWith(".gif"))
+      return "image/gif";
+    if (urlLower.endsWith(".webp"))
+      return "image/webp";
+    if (urlLower.endsWith(".bmp"))
+      return "image/bmp";
+    if (urlLower.endsWith(".svg"))
+      return "image/svg+xml";
+    if (urlLower.endsWith(".ico"))
+      return "image/x-icon";
+    return "image/jpeg";
+  }
+  async blobToBase64DataURL(blob, mimeType) {
+    if (typeof Buffer !== "undefined") {
+      const arrayBuffer = await blob.arrayBuffer();
+      const buffer = Buffer.from(arrayBuffer);
+      return `data:${mimeType};base64,${buffer.toString("base64")}`;
+    }
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader;
+      reader.onloadend = () => {
+        const result = reader.result;
+        if (result.startsWith("data:;base64,")) {
+          resolve(`data:${mimeType};base64,${result.substring(13)}`);
+        } else {
+          resolve(result);
+        }
+      };
+      reader.onerror = reject;
+      reader.readAsDataURL(blob);
+    });
+  }
+}
+Workflow50.prototype.fileLoader = CreateWorkflow49(FileLoaderTask);
+
+// src/task/FileLoaderTask.server.ts
+class FileLoaderTask2 extends FileLoaderTask {
+  async execute(input2, context) {
+    let { url, format = "auto" } = input2;
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+      return super.execute(input2, context);
+    }
+    if (context.signal.aborted) {
+      throw new TaskAbortedError3("Task aborted");
+    }
+    await context.updateProgress(0, "Detecting file format");
+    if (url.startsWith("file://")) {
+      url = url.slice(7);
+    }
+    const detectedFormat = this.detectFormat(url, format);
+    const title = url.split("/").pop() || url;
+    if (context.signal.aborted) {
+      throw new TaskAbortedError3("Task aborted");
+    }
+    await context.updateProgress(10, `Reading ${detectedFormat} file from filesystem`);
+    if (detectedFormat === "json") {
+      const fileContent2 = await readFile(url, { encoding: "utf-8" });
+      if (context.signal.aborted) {
+        throw new TaskAbortedError3("Task aborted");
+      }
+      await context.updateProgress(50, "Parsing JSON content");
+      const jsonData = this.parseJsonContent(fileContent2);
+      const content = JSON.stringify(jsonData, null, 2);
+      if (context.signal.aborted) {
+        throw new TaskAbortedError3("Task aborted");
+      }
+      await context.updateProgress(100, "File loaded successfully");
+      return {
+        text: undefined,
+        json: jsonData,
+        csv: undefined,
+        image: undefined,
+        pdf: undefined,
+        frontmatter: undefined,
+        metadata: {
+          url,
+          format: detectedFormat,
+          size: content.length,
+          title,
+          mimeType: "application/json"
+        }
+      };
+    }
+    if (detectedFormat === "csv") {
+      const fileContent2 = await readFile(url, { encoding: "utf-8" });
+      if (!fileContent2) {
+        throw new Error(`Failed to load CSV from ${url}`);
+      }
+      if (context.signal.aborted) {
+        throw new TaskAbortedError3("Task aborted");
+      }
+      await context.updateProgress(50, "Parsing CSV content");
+      const csvData = this.parseCsvContent(fileContent2);
+      if (context.signal.aborted) {
+        throw new TaskAbortedError3("Task aborted");
+      }
+      await context.updateProgress(100, "File loaded successfully");
+      return {
+        text: undefined,
+        json: undefined,
+        csv: csvData,
+        image: undefined,
+        pdf: undefined,
+        frontmatter: undefined,
+        metadata: {
+          url,
+          format: detectedFormat,
+          size: fileContent2.length,
+          title,
+          mimeType: "text/csv"
+        }
+      };
+    }
+    if (detectedFormat === "image") {
+      const fileBuffer = await readFile(url);
+      if (context.signal.aborted) {
+        throw new TaskAbortedError3("Task aborted");
+      }
+      await context.updateProgress(50, "Converting image to base64");
+      const mimeType2 = this.getImageMimeType(url);
+      const blob = new Blob([fileBuffer], { type: mimeType2 });
+      const imageData = await this.blobToBase64DataURL(blob, mimeType2);
+      if (context.signal.aborted) {
+        throw new TaskAbortedError3("Task aborted");
+      }
+      await context.updateProgress(100, "File loaded successfully");
+      return {
+        text: undefined,
+        json: undefined,
+        csv: undefined,
+        image: imageData,
+        pdf: undefined,
+        frontmatter: undefined,
+        metadata: {
+          url,
+          format: detectedFormat,
+          size: fileBuffer.length,
+          title,
+          mimeType: mimeType2
+        }
+      };
+    }
+    if (detectedFormat === "pdf") {
+      const fileBuffer = await readFile(url);
+      if (context.signal.aborted) {
+        throw new TaskAbortedError3("Task aborted");
+      }
+      await context.updateProgress(50, "Converting PDF to base64");
+      const mimeType2 = "application/pdf";
+      const blob = new Blob([fileBuffer], { type: mimeType2 });
+      const pdfData = await this.blobToBase64DataURL(blob, mimeType2);
+      if (context.signal.aborted) {
+        throw new TaskAbortedError3("Task aborted");
+      }
+      await context.updateProgress(100, "File loaded successfully");
+      return {
+        text: undefined,
+        json: undefined,
+        csv: undefined,
+        image: undefined,
+        pdf: pdfData,
+        frontmatter: undefined,
+        metadata: {
+          url,
+          format: detectedFormat,
+          size: fileBuffer.length,
+          title,
+          mimeType: mimeType2
+        }
+      };
+    }
+    const fileContent = await readFile(url, { encoding: "utf-8" });
+    if (!fileContent) {
+      throw new Error(`Failed to load content from ${url}`);
+    }
+    if (context.signal.aborted) {
+      throw new TaskAbortedError3("Task aborted");
+    }
+    await context.updateProgress(50, `Parsing ${detectedFormat} content`);
+    const mimeType = detectedFormat === "markdown" ? "text/markdown" : detectedFormat === "html" ? "text/html" : "text/plain";
+    if (context.signal.aborted) {
+      throw new TaskAbortedError3("Task aborted");
+    }
+    await context.updateProgress(100, "File loaded successfully");
+    if (detectedFormat === "markdown") {
+      const { frontmatter, body } = this.parseFrontmatter(fileContent);
+      return {
+        text: body,
+        json: undefined,
+        csv: undefined,
+        image: undefined,
+        pdf: undefined,
+        frontmatter,
+        metadata: {
+          url,
+          format: detectedFormat,
+          size: fileContent.length,
+          title,
+          mimeType
+        }
+      };
+    }
+    return {
+      text: fileContent,
+      json: undefined,
+      csv: undefined,
+      image: undefined,
+      pdf: undefined,
+      frontmatter: undefined,
+      metadata: {
+        url,
+        format: detectedFormat,
+        size: fileContent.length,
+        title,
+        mimeType
+      }
+    };
+  }
+}
+var fileLoader = (input2, config) => {
+  return new FileLoaderTask2({}, config).run(input2);
+};
+Workflow51.prototype.fileLoader = CreateWorkflow50(FileLoaderTask2);
+
+// src/bun.ts
+var registerCommonTasks2 = () => {
+  const tasks = registerCommonTasks();
+  TaskRegistry2.registerTask(FileLoaderTask2);
+  return [...tasks, FileLoaderTask2];
+};
 export {
   split,
-  registerCommonTasks,
+  registerCommonTasks2 as registerCommonTasks,
   process,
   merge,
   mcpToolCall,
@@ -7953,6 +8978,17 @@ export {
   VectorDivideTask,
   VectorDistanceTask,
   TypeReplicateArray,
+  TemplateTask,
+  StringUpperCaseTask,
+  StringTrimTask,
+  StringTemplateTask,
+  StringSliceTask,
+  StringReplaceTask,
+  StringLowerCaseTask,
+  StringLengthTask,
+  StringJoinTask,
+  StringIncludesTask,
+  StringConcatTask,
   SplitTask,
   ScalarTruncTask,
   ScalarSumTask,
@@ -7966,6 +9002,7 @@ export {
   ScalarCeilTask,
   ScalarAddTask,
   ScalarAbsTask,
+  RegexTask,
   OutputTask,
   MergeTask,
   McpToolCallTask,
@@ -7974,6 +9011,7 @@ export {
   McpListTask,
   LambdaTask,
   JsonTask,
+  JsonPathTask,
   JavaScriptTask,
   InputTask,
   FileLoaderTask2 as FileLoaderTask,
@@ -7981,7 +9019,8 @@ export {
   FetchUrlJob,
   DelayTask,
   DebugLogTask,
+  DateFormatTask,
   ArrayTask
 };
 
-//# debugId=F7898CFF8161BF7464756E2164756E21
+//# debugId=3ABCF331B228FE6F64756E2164756E21