@workglow/tasks 0.0.84 → 0.0.86

package/dist/{index.js → browser.js}

@@ -6,132 +6,18 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// src/task/DebugLogTask.ts
-import { CreateWorkflow, Task, TaskRegistry, Workflow } from "@workglow/task-graph";
-var log_levels = ["dir", "log", "debug", "info", "warn", "error"];
-var DEFAULT_LOG_LEVEL = "log";
-var inputSchema = {
-  type: "object",
-  properties: {
-    console: {
-      title: "Message",
-      description: "The message to log"
-    },
-    log_level: {
-      type: "string",
-      enum: log_levels,
-      title: "Log Level",
-      description: "The log level to use",
-      default: DEFAULT_LOG_LEVEL
-    }
-  },
-  additionalProperties: false
-};
-var outputSchema = {
-  type: "object",
-  properties: {
-    console: {
-      title: "Messages",
-      description: "The messages logged by the task"
-    }
-  },
-  additionalProperties: false
-};
+// src/browser.ts
+import { TaskRegistry as TaskRegistry2 } from "@workglow/task-graph";
 
-class DebugLogTask extends Task {
-  static type = "DebugLogTask";
-  static category = "Utility";
-  static title = "Debug Log";
-  static description = "Logs messages to the console with configurable log levels for debugging task graphs";
-  static cacheable = false;
-  static inputSchema() {
-    return inputSchema;
-  }
-  static outputSchema() {
-    return outputSchema;
-  }
-  async executeReactive(input, output) {
-    const { log_level = DEFAULT_LOG_LEVEL, console: messages } = input;
-    if (log_level == "dir") {
-      console.dir(messages, { depth: null });
-    } else {
-      console[log_level](messages);
-    }
-    output.console = input.console;
-    return output;
-  }
-}
-TaskRegistry.registerTask(DebugLogTask);
-var debugLog = (input, config = {}) => {
-  const task = new DebugLogTask(input, config);
-  return task.run();
-};
-Workflow.prototype.debugLog = CreateWorkflow(DebugLogTask);
-// src/task/DelayTask.ts
+// src/task/FileLoaderTask.ts
 import {
   CreateWorkflow as CreateWorkflow2,
-  Task as Task2,
+  Task,
   TaskAbortedError,
-  TaskRegistry as TaskRegistry2,
   Workflow as Workflow2
 } from "@workglow/task-graph";
-import { sleep } from "@workglow/util";
-var inputSchema2 = {
-  type: "object",
-  properties: {
-    delay: {
-      type: "number",
-      title: "Delay (ms)",
-      default: 1
-    },
-    pass_through: {
-      title: "Pass Through",
-      description: "Pass through data to the output"
-    }
-  },
-  additionalProperties: false
-};
-var outputSchema2 = {
-  type: "object",
-  properties: {},
-  additionalProperties: true
-};
+import Papa from "papaparse";
 
-class DelayTask extends Task2 {
-  static type = "DelayTask";
-  static category = "Utility";
-  static title = "Delay";
-  static description = "Delays execution for a specified duration with progress tracking";
-  static inputSchema() {
-    return inputSchema2;
-  }
-  static outputSchema() {
-    return outputSchema2;
-  }
-  async execute(input, executeContext) {
-    const delay = input.delay ?? 0;
-    if (delay > 100) {
-      const iterations = Math.min(100, Math.floor(delay / 16));
-      const chunkSize = delay / iterations;
-      for (let i = 0;i < iterations; i++) {
-        if (executeContext.signal.aborted) {
-          throw new TaskAbortedError("Task aborted");
-        }
-        await sleep(chunkSize);
-        await executeContext.updateProgress(100 * i / iterations, `Delaying for ${delay}ms`);
-      }
-    } else {
-      await sleep(delay);
-    }
-    return input.pass_through;
-  }
-}
-TaskRegistry2.registerTask(DelayTask);
-var delay = (input, config = {}) => {
-  const task = new DelayTask(input, config);
-  return task.run();
-};
-Workflow2.prototype.delay = CreateWorkflow2(DelayTask);
 // src/task/FetchUrlTask.ts
 import {
   AbortSignalJobError,
@@ -140,14 +26,13 @@ import {
   RetryableJobError
 } from "@workglow/job-queue";
 import {
-  CreateWorkflow as CreateWorkflow3,
+  CreateWorkflow,
   JobQueueTask,
   TaskConfigurationError,
   TaskInvalidInputError,
-  TaskRegistry as TaskRegistry3,
-  Workflow as Workflow3
+  Workflow
 } from "@workglow/task-graph";
-var inputSchema3 = {
+var inputSchema = {
   type: "object",
   properties: {
     url: {
@@ -178,6 +63,7 @@ var inputSchema3 = {
     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: {
@@ -195,7 +81,7 @@ var inputSchema3 = {
   required: ["url"],
   additionalProperties: false
 };
-var outputSchema3 = {
+var outputSchema = {
   type: "object",
   properties: {
     json: {
@@ -214,6 +100,16 @@ var outputSchema3 = {
     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"
     }
   },
   additionalProperties: false
@@ -281,9 +177,17 @@ class FetchUrlJob extends Job {
       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) {
-        const contentType = response.headers.get("content-type") ?? "";
         if (contentType.includes("application/json")) {
           responseType = "json";
         } else if (contentType.includes("text/")) {
@@ -298,13 +202,13 @@ class FetchUrlJob extends Job {
         input.response_type = responseType;
       }
       if (responseType === "json") {
-        return { json: await response.json() };
+        return { json: await response.json(), metadata };
       } else if (responseType === "text") {
-        return { text: await response.text() };
+        return { text: await response.text(), metadata };
       } else if (responseType === "blob") {
-        return { blob: await response.blob() };
+        return { blob: await response.blob(), metadata };
       } else if (responseType === "arraybuffer") {
-        return { arraybuffer: await response.arrayBuffer() };
+        return { arraybuffer: await response.arrayBuffer(), metadata };
       }
       throw new TaskInvalidInputError(`Invalid response type: ${responseType}`);
     } else {
@@ -337,10 +241,10 @@ class FetchUrlTask extends JobQueueTask {
   static description = "Fetches data from a URL with progress tracking and automatic retry handling";
   static hasDynamicSchemas = true;
   static inputSchema() {
-    return inputSchema3;
+    return inputSchema;
   }
   static outputSchema() {
-    return outputSchema3;
+    return outputSchema;
   }
   outputSchema() {
     const responseType = this.runInputData?.response_type ?? this.defaults?.response_type ?? null;
@@ -364,6 +268,9 @@ class FetchUrlTask extends JobQueueTask {
     } 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;
     }
@@ -413,14 +320,595 @@ class FetchUrlTask extends JobQueueTask {
     }
   }
 }
-TaskRegistry3.registerTask(FetchUrlTask);
 var fetchUrl = async (input, config = {}) => {
-  const result = await new FetchUrlTask(input, config).run();
+  const result = await new FetchUrlTask({}, config).run(input);
   return result;
 };
-Workflow3.prototype.fetch = CreateWorkflow3(FetchUrlTask);
+Workflow.prototype.fetch = CreateWorkflow(FetchUrlTask);
+
+// src/task/FileLoaderTask.ts
+var inputSchema2 = {
+  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 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"
+    }
+  },
+  required: ["metadata"],
+  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;
+  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");
+    }
+    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");
+    }
+    await context.updateProgress(100, "File loaded successfully");
+    return {
+      text,
+      json,
+      csv,
+      image,
+      pdf,
+      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}`);
+    }
+  }
+  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
+      };
+    }
+    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");
+    return {
+      text: content,
+      json: undefined,
+      csv: undefined,
+      image: undefined,
+      pdf: 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(".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);
+    });
+  }
+}
+var fileLoader = (input, config) => {
+  return new FileLoaderTask({}, config).run(input);
+};
+Workflow2.prototype.fileLoader = CreateWorkflow2(FileLoaderTask);
+
+// src/task/ArrayTask.ts
+import {
+  uuid4
+} from "@workglow/util";
+import {
+  GraphAsTask,
+  GraphAsTaskRunner,
+  PROPERTY_ARRAY,
+  TaskGraph
+} from "@workglow/task-graph";
+var TypeReplicateArray = (type, annotations = {}) => ({
+  oneOf: [type, { type: "array", items: type }],
+  title: type.title,
+  description: type.description,
+  ...type.format ? { format: type.format } : {},
+  ...annotations,
+  "x-replicate": true
+});
+
+class ArrayTask extends GraphAsTask {
+  static type = "ArrayTask";
+  static compoundMerge = PROPERTY_ARRAY;
+  inputSchema() {
+    return this.constructor.inputSchema();
+  }
+  outputSchema() {
+    return this.constructor.outputSchema();
+  }
+  executeMerge(_input, output) {
+    return output;
+  }
+  regenerateGraph() {
+    const arrayInputs = new Map;
+    let hasArrayInputs = false;
+    const inputSchema3 = this.inputSchema();
+    if (typeof inputSchema3 !== "boolean") {
+      const keys = Object.keys(inputSchema3.properties || {});
+      for (const inputId of keys) {
+        const inputValue = this.runInputData[inputId];
+        const inputDef = inputSchema3.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;
+        }
+      }
+    }
+    this.subGraph = new TaskGraph;
+    if (!hasArrayInputs) {
+      super.regenerateGraph();
+      return;
+    }
+    const inputIds = Array.from(arrayInputs.keys());
+    const inputObject = Object.fromEntries(arrayInputs);
+    const combinations = this.generateCombinations(inputObject, inputIds);
+    const tasks = combinations.map((combination) => {
+      const { id, name, ...rest } = this.config;
+      const task = new this.constructor({ ...this.defaults, ...this.runInputData, ...combination }, { ...rest, id: `${id}_${uuid4()}` });
+      return task;
+    });
+    this.subGraph.addTasks(tasks);
+    super.regenerateGraph();
+  }
+  generateCombinations(input, inputMakeArray) {
+    const arraysToCombine = inputMakeArray.map((key) => Array.isArray(input[key]) ? input[key] : []);
+    const indices = new Array(arraysToCombine.length).fill(0);
+    const combinations = [];
+    let done = false;
+    while (!done) {
+      combinations.push([...indices]);
+      for (let i = indices.length - 1;i >= 0; i--) {
+        if (++indices[i] < arraysToCombine[i].length)
+          break;
+        if (i === 0)
+          done = true;
+        else
+          indices[i] = 0;
+      }
+    }
+    const combos = combinations.map((combination) => {
+      const result = { ...input };
+      combination.forEach((valueIndex, arrayIndex) => {
+        const key = inputMakeArray[arrayIndex];
+        if (Array.isArray(input[key]))
+          result[key] = input[key][valueIndex];
+      });
+      return result;
+    });
+    return combos;
+  }
+  toJSON() {
+    const { subgraph, ...result } = super.toJSON();
+    return result;
+  }
+  toDependencyJSON() {
+    const { subtasks, ...result } = super.toDependencyJSON();
+    return result;
+  }
+  get runner() {
+    if (!this._runner) {
+      this._runner = new ArrayTaskRunner(this);
+    }
+    return this._runner;
+  }
+}
+
+class ArrayTaskRunner extends GraphAsTaskRunner {
+  async executeTaskChildren(_input) {
+    return super.executeTaskChildren({});
+  }
+  async executeTaskReactive(input, output) {
+    await super.executeTaskReactive(input, output);
+    if (this.task.hasChildren()) {
+      this.task.runOutputData = this.task.executeMerge(input, this.task.runOutputData);
+    }
+    return this.task.runOutputData;
+  }
+  async executeTask(input) {
+    await super.executeTask(input);
+    if (this.task.hasChildren()) {
+      this.task.runOutputData = this.task.executeMerge(input, this.task.runOutputData);
+    }
+    return this.task.runOutputData;
+  }
+}
+// src/task/DebugLogTask.ts
+import { CreateWorkflow as CreateWorkflow3, Task as Task2, Workflow as Workflow3 } from "@workglow/task-graph";
+var log_levels = ["dir", "log", "debug", "info", "warn", "error"];
+var DEFAULT_LOG_LEVEL = "log";
+var inputSchema3 = {
+  type: "object",
+  properties: {
+    console: {
+      title: "Message",
+      description: "The message to log"
+    },
+    log_level: {
+      type: "string",
+      enum: log_levels,
+      title: "Log Level",
+      description: "The log level to use",
+      default: DEFAULT_LOG_LEVEL
+    }
+  },
+  additionalProperties: false
+};
+var outputSchema3 = {
+  type: "object",
+  properties: {
+    console: {
+      title: "Messages",
+      description: "The messages logged by the task"
+    }
+  },
+  additionalProperties: false
+};
+
+class DebugLogTask extends Task2 {
+  static type = "DebugLogTask";
+  static category = "Utility";
+  static title = "Debug Log";
+  static description = "Logs messages to the console with configurable log levels for debugging task graphs";
+  static cacheable = false;
+  static inputSchema() {
+    return inputSchema3;
+  }
+  static outputSchema() {
+    return outputSchema3;
+  }
+  async executeReactive(input, output) {
+    const { log_level = DEFAULT_LOG_LEVEL, console: messages } = input;
+    if (log_level == "dir") {
+      console.dir(messages, { depth: null });
+    } else {
+      console[log_level](messages);
+    }
+    output.console = input.console;
+    return output;
+  }
+}
+var debugLog = (input, config = {}) => {
+  const task = new DebugLogTask({}, config);
+  return task.run(input);
+};
+Workflow3.prototype.debugLog = CreateWorkflow3(DebugLogTask);
+// src/task/DelayTask.ts
+import {
+  CreateWorkflow as CreateWorkflow4,
+  Task as Task3,
+  TaskAbortedError as TaskAbortedError2,
+  Workflow as Workflow4
+} from "@workglow/task-graph";
+import { sleep } from "@workglow/util";
+var inputSchema4 = {
+  type: "object",
+  properties: {
+    delay: {
+      type: "number",
+      title: "Delay (ms)",
+      default: 1
+    },
+    pass_through: {
+      title: "Pass Through",
+      description: "Pass through data to the output"
+    }
+  },
+  additionalProperties: false
+};
+var outputSchema4 = {
+  type: "object",
+  properties: {},
+  additionalProperties: true
+};
+
+class DelayTask extends Task3 {
+  static type = "DelayTask";
+  static category = "Utility";
+  static title = "Delay";
+  static description = "Delays execution for a specified duration with progress tracking";
+  static inputSchema() {
+    return inputSchema4;
+  }
+  static outputSchema() {
+    return outputSchema4;
+  }
+  async execute(input, executeContext) {
+    const delay = input.delay ?? 0;
+    if (delay > 100) {
+      const iterations = Math.min(100, Math.floor(delay / 16));
+      const chunkSize = delay / iterations;
+      for (let i = 0;i < iterations; i++) {
+        if (executeContext.signal.aborted) {
+          throw new TaskAbortedError2("Task aborted");
+        }
+        await sleep(chunkSize);
+        await executeContext.updateProgress(100 * i / iterations, `Delaying for ${delay}ms`);
+      }
+    } else {
+      await sleep(delay);
+    }
+    return input.pass_through;
+  }
+}
+var delay = (input, config = {}) => {
+  const task = new DelayTask({}, config);
+  return task.run(input);
+};
+Workflow4.prototype.delay = CreateWorkflow4(DelayTask);
+// src/task/InputTask.ts
+import { CreateWorkflow as CreateWorkflow5, Task as Task4, Workflow as Workflow5 } from "@workglow/task-graph";
+
+class InputTask extends Task4 {
+  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?.extras?.inputSchema ?? this.constructor.inputSchema();
+  }
+  outputSchema() {
+    return this.config?.extras?.outputSchema ?? this.constructor.outputSchema();
+  }
+  async execute(input) {
+    return input;
+  }
+  async executeReactive(input) {
+    return input;
+  }
+}
+Workflow5.prototype.input = CreateWorkflow5(InputTask);
 // src/task/JavaScriptTask.ts
-import { CreateWorkflow as CreateWorkflow4, Task as Task3, TaskRegistry as TaskRegistry4, Workflow as Workflow4 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow6, Task as Task5, Workflow as Workflow6 } from "@workglow/task-graph";
 
 // src/util/acorn.js
 var options;
@@ -4883,7 +5371,7 @@ Interpreter["VALUE_IN_DESCRIPTOR"] = Interpreter.VALUE_IN_DESCRIPTOR;
 Interpreter["Status"] = Interpreter.Status;
 
 // src/task/JavaScriptTask.ts
-var inputSchema4 = {
+var inputSchema5 = {
   type: "object",
   properties: {
     javascript_code: {
@@ -4897,7 +5385,7 @@ var inputSchema4 = {
   required: ["javascript_code"],
   additionalProperties: true
 };
-var outputSchema4 = {
+var outputSchema5 = {
   type: "object",
   properties: {
     output: {
@@ -4909,16 +5397,16 @@ var outputSchema4 = {
   additionalProperties: false
 };
 
-class JavaScriptTask extends Task3 {
+class JavaScriptTask extends Task5 {
   static type = "JavaScriptTask";
   static category = "Utility";
   static title = "JavaScript Interpreter";
   static description = "Executes JavaScript code in a sandboxed interpreter environment";
   static inputSchema() {
-    return inputSchema4;
+    return inputSchema5;
   }
   static outputSchema() {
-    return outputSchema4;
+    return outputSchema5;
   }
   async executeReactive(input2, output) {
     if (input2.javascript_code) {
@@ -4937,22 +5425,20 @@ class JavaScriptTask extends Task3 {
     return output;
   }
 }
-TaskRegistry4.registerTask(JavaScriptTask);
 var javaScript = (input2, config = {}) => {
-  return new JavaScriptTask(input2, config).run();
+  return new JavaScriptTask({}, config).run(input2);
 };
-Workflow4.prototype.javaScript = CreateWorkflow4(JavaScriptTask);
+Workflow6.prototype.javaScript = CreateWorkflow6(JavaScriptTask);
 // src/task/JsonTask.ts
 import {
   createGraphFromDependencyJSON,
-  CreateWorkflow as CreateWorkflow5,
+  CreateWorkflow as CreateWorkflow7,
   Dataflow,
-  GraphAsTask,
+  GraphAsTask as GraphAsTask2,
   TaskConfigurationError as TaskConfigurationError2,
-  TaskRegistry as TaskRegistry5,
-  Workflow as Workflow5
+  Workflow as Workflow7
 } from "@workglow/task-graph";
-var inputSchema5 = {
+var inputSchema6 = {
   type: "object",
   properties: {
     json: {
@@ -4963,7 +5449,7 @@ var inputSchema5 = {
   },
   additionalProperties: false
 };
-var outputSchema5 = {
+var outputSchema6 = {
   type: "object",
   properties: {
     output: {
@@ -4974,14 +5460,16 @@ var outputSchema5 = {
   additionalProperties: false
 };
 
-class JsonTask extends GraphAsTask {
+class JsonTask extends GraphAsTask2 {
   static type = "JsonTask";
   static category = "Hidden";
+  static title = "JSON Task";
+  static description = "A task that creates and manages task graphs from JSON configurations";
   static inputSchema() {
-    return inputSchema5;
+    return inputSchema6;
   }
   static outputSchema() {
-    return outputSchema5;
+    return outputSchema6;
   }
   regenerateGraph() {
     if (!this.runInputData.json)
@@ -5009,21 +5497,19 @@ class JsonTask extends GraphAsTask {
     super.regenerateGraph();
   }
 }
-TaskRegistry5.registerTask(JsonTask);
 var json = (input2, config = {}) => {
-  return new JsonTask(input2, config).run();
+  return new JsonTask({}, config).run(input2);
 };
-Workflow5.prototype.json = CreateWorkflow5(JsonTask);
+Workflow7.prototype.json = CreateWorkflow7(JsonTask);
 // src/task/LambdaTask.ts
 import {
-  CreateWorkflow as CreateWorkflow6,
+  CreateWorkflow as CreateWorkflow8,
   DATAFLOW_ALL_PORTS,
-  Task as Task4,
+  Task as Task6,
   TaskConfigurationError as TaskConfigurationError3,
-  TaskRegistry as TaskRegistry6,
-  Workflow as Workflow6
+  Workflow as Workflow8
 } from "@workglow/task-graph";
-var inputSchema6 = {
+var inputSchema7 = {
   type: "object",
   properties: {
     [DATAFLOW_ALL_PORTS]: {
@@ -5033,7 +5519,7 @@ var inputSchema6 = {
   },
   additionalProperties: true
 };
-var outputSchema6 = {
+var outputSchema7 = {
   type: "object",
   properties: {
     [DATAFLOW_ALL_PORTS]: {
@@ -5044,15 +5530,17 @@ var outputSchema6 = {
   additionalProperties: true
 };
 
-class LambdaTask extends Task4 {
+class LambdaTask extends Task6 {
   static type = "LambdaTask";
+  static title = "Lambda Task";
+  static description = "A task that wraps a provided function and its input";
   static category = "Hidden";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema6;
+    return inputSchema7;
   }
   static outputSchema() {
-    return outputSchema6;
+    return outputSchema7;
   }
   constructor(input2 = {}, config = {}) {
     if (!config.execute && !config.executeReactive) {
@@ -5073,7 +5561,6 @@ class LambdaTask extends Task4 {
     return output;
   }
 }
-TaskRegistry6.registerTask(LambdaTask);
 function process(value) {
   if (typeof value === "string")
     return `Processed: ${value}`;
@@ -5091,20 +5578,15 @@ function lambda(input2, config) {
   const task = new LambdaTask(input2, config);
   return task.run();
 }
-Workflow6.prototype.lambda = CreateWorkflow6(LambdaTask);
+Workflow8.prototype.lambda = CreateWorkflow8(LambdaTask);
 // src/task/MergeTask.ts
-import {
-  CreateWorkflow as CreateWorkflow7,
-  Task as Task5,
-  TaskRegistry as TaskRegistry7,
-  Workflow as Workflow7
-} from "@workglow/task-graph";
-var inputSchema7 = {
+import { CreateWorkflow as CreateWorkflow9, Task as Task7, Workflow as Workflow9 } from "@workglow/task-graph";
+var inputSchema8 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
-var outputSchema7 = {
+var outputSchema8 = {
   type: "object",
   properties: {
     output: {
@@ -5116,17 +5598,17 @@ var outputSchema7 = {
   additionalProperties: false
 };
 
-class MergeTask extends Task5 {
+class MergeTask extends Task7 {
   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 inputSchema7;
+    return inputSchema8;
   }
   static outputSchema() {
-    return outputSchema7;
+    return outputSchema8;
   }
   async execute(input2, context) {
     const keys = Object.keys(input2).sort();
@@ -5136,15 +5618,52 @@ class MergeTask extends Task5 {
     };
   }
 }
-TaskRegistry7.registerTask(MergeTask);
 var merge = (input2, config = {}) => {
-  const task = new MergeTask(input2, config);
-  return task.run();
+  const task = new MergeTask({}, config);
+  return task.run(input2);
 };
-Workflow7.prototype.merge = CreateWorkflow7(MergeTask);
+Workflow9.prototype.merge = CreateWorkflow9(MergeTask);
+// src/task/OutputTask.ts
+import { CreateWorkflow as CreateWorkflow10, Task as Task8, Workflow as Workflow10 } from "@workglow/task-graph";
+
+class OutputTask extends Task8 {
+  static type = "OutputTask";
+  static category = "Flow Control";
+  static title = "Output";
+  static description = "Ends 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?.extras?.inputSchema ?? this.constructor.inputSchema();
+  }
+  outputSchema() {
+    return this.config?.extras?.outputSchema ?? this.constructor.outputSchema();
+  }
+  async execute(input2) {
+    return input2;
+  }
+  async executeReactive(input2) {
+    return input2;
+  }
+}
+Workflow10.prototype.output = CreateWorkflow10(OutputTask);
 // src/task/SplitTask.ts
-import { CreateWorkflow as CreateWorkflow8, Task as Task6, TaskRegistry as TaskRegistry8, Workflow as Workflow8 } from "@workglow/task-graph";
-var inputSchema8 = {
+import { CreateWorkflow as CreateWorkflow11, Task as Task9, Workflow as Workflow11 } from "@workglow/task-graph";
+var inputSchema9 = {
   type: "object",
   properties: {
     input: {
@@ -5154,13 +5673,13 @@ var inputSchema8 = {
   },
   additionalProperties: false
 };
-var outputSchema8 = {
+var outputSchema9 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
 
-class SplitTask extends Task6 {
+class SplitTask extends Task9 {
   static type = "SplitTask";
   static category = "Utility";
   static title = "Split";
@@ -5168,13 +5687,13 @@ class SplitTask extends Task6 {
   static hasDynamicSchemas = true;
   static cacheable = false;
   static inputSchema() {
-    return inputSchema8;
+    return inputSchema9;
   }
   static outputSchema() {
-    return outputSchema8;
+    return outputSchema9;
   }
   outputSchema() {
-    return outputSchema8;
+    return outputSchema9;
   }
   async executeReactive(input2) {
     const inputValue = input2.input;
@@ -5189,31 +5708,60 @@ class SplitTask extends Task6 {
     return output;
   }
 }
-TaskRegistry8.registerTask(SplitTask);
 var split = (input2, config = {}) => {
-  const task = new SplitTask(input2, config);
-  return task.run();
+  const task = new SplitTask({}, config);
+  return task.run(input2);
+};
+Workflow11.prototype.split = CreateWorkflow11(SplitTask);
+
+// src/common.ts
+import { TaskRegistry } from "@workglow/task-graph";
+var registerCommonTasks = () => {
+  const tasks = [
+    ArrayTask,
+    DebugLogTask,
+    DelayTask,
+    FetchUrlTask,
+    InputTask,
+    JavaScriptTask,
+    JsonTask,
+    LambdaTask,
+    MergeTask,
+    OutputTask,
+    SplitTask
+  ];
+  tasks.map(TaskRegistry.registerTask);
+  return tasks;
 };
-Workflow8.prototype.split = CreateWorkflow8(SplitTask);
+
+// src/browser.ts
+[FileLoaderTask].map(TaskRegistry2.registerTask);
 export {
   split,
+  registerCommonTasks,
   process,
   merge,
   lambda,
   json,
   javaScript,
+  fileLoader,
   fetchUrl,
   delay,
   debugLog,
+  TypeReplicateArray,
   SplitTask,
+  OutputTask,
   MergeTask,
   LambdaTask,
   JsonTask,
   JavaScriptTask,
+  InputTask,
+  FileLoaderTask,
   FetchUrlTask,
   FetchUrlJob,
   DelayTask,
-  DebugLogTask
+  DebugLogTask,
+  ArrayTask
 };
 
-//# debugId=5A48AA5322FF43C164756E2164756E21
+//# debugId=B1BD272CB310F36564756E2164756E21