@workglow/task-graph 0.0.86 → 0.0.87

package/dist/bun.js

@@ -1,20 +1,55 @@
 // @bun
-// src/task-graph/Dataflow.ts
-import { areSemanticallyCompatible, EventEmitter } from "@workglow/util";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // src/task/TaskTypes.ts
-var TaskStatus = {
-  PENDING: "PENDING",
-  DISABLED: "DISABLED",
-  PROCESSING: "PROCESSING",
-  COMPLETED: "COMPLETED",
-  ABORTING: "ABORTING",
-  FAILED: "FAILED"
-};
+var TaskStatus;
+var init_TaskTypes = __esm(() => {
+  TaskStatus = {
+    PENDING: "PENDING",
+    DISABLED: "DISABLED",
+    PROCESSING: "PROCESSING",
+    COMPLETED: "COMPLETED",
+    ABORTING: "ABORTING",
+    FAILED: "FAILED"
+  };
+});
 
 // src/task-graph/Dataflow.ts
-var DATAFLOW_ALL_PORTS = "*";
-var DATAFLOW_ERROR_PORT = "[error]";
+var exports_Dataflow = {};
+__export(exports_Dataflow, {
+  DataflowArrow: () => DataflowArrow,
+  Dataflow: () => Dataflow,
+  DATAFLOW_ERROR_PORT: () => DATAFLOW_ERROR_PORT,
+  DATAFLOW_ALL_PORTS: () => DATAFLOW_ALL_PORTS
+});
+import { areSemanticallyCompatible, EventEmitter } from "@workglow/util";
 
 class Dataflow {
   sourceTaskId;
@@ -79,13 +114,15 @@ class Dataflow {
     }
   }
   getPortData() {
+    let result;
     if (this.targetTaskPortId === DATAFLOW_ALL_PORTS) {
-      return this.value;
+      result = this.value;
     } else if (this.targetTaskPortId === DATAFLOW_ERROR_PORT) {
-      return { [DATAFLOW_ERROR_PORT]: this.error };
+      result = { [DATAFLOW_ERROR_PORT]: this.error };
     } else {
-      return { [this.targetTaskPortId]: this.value };
+      result = { [this.targetTaskPortId]: this.value };
     }
+    return result;
   }
   toJSON() {
     return {
@@ -147,22 +184,30 @@ class Dataflow {
     this._events?.emit(name, ...args);
   }
 }
-
-class DataflowArrow extends Dataflow {
-  constructor(dataflow) {
-    const pattern = /^([a-zA-Z0-9-]+?)\[([a-zA-Z0-9-]+?)\] ==> ([a-zA-Z0-9-]+?)\[([a-zA-Z0-9-]+?)\]$/;
-    const match = dataflow.match(pattern);
-    if (!match) {
-      throw new Error(`Invalid dataflow format: ${dataflow}`);
+var DATAFLOW_ALL_PORTS = "*", DATAFLOW_ERROR_PORT = "[error]", DataflowArrow;
+var init_Dataflow = __esm(() => {
+  init_TaskTypes();
+  DataflowArrow = class DataflowArrow extends Dataflow {
+    constructor(dataflow) {
+      const pattern = /^([a-zA-Z0-9-]+?)\[([a-zA-Z0-9-]+?)\] ==> ([a-zA-Z0-9-]+?)\[([a-zA-Z0-9-]+?)\]$/;
+      const match = dataflow.match(pattern);
+      if (!match) {
+        throw new Error(`Invalid dataflow format: ${dataflow}`);
+      }
+      const [, sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId] = match;
+      super(sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId);
     }
-    const [, sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId] = match;
-    super(sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId);
-  }
-}
+  };
+});
+
+// src/common.ts
+init_Dataflow();
+
 // src/task-graph/TaskGraph.ts
-import { DirectedAcyclicGraph, EventEmitter as EventEmitter5, uuid4 as uuid43 } from "@workglow/util";
+import { DirectedAcyclicGraph, EventEmitter as EventEmitter5, uuid4 as uuid44 } from "@workglow/util";
 
 // src/task/GraphAsTask.ts
+init_Dataflow();
 import { compileSchema as compileSchema2 } from "@workglow/util";
 
 // src/task-graph/TaskGraphRunner.ts
@@ -204,6 +249,7 @@ class TaskOutputRepository {
 }
 
 // src/task/Task.ts
+init_Dataflow();
 import {
   compileSchema,
   deepEqual,
@@ -330,6 +376,8 @@ async function resolveSchemaInputs(input, schema, config) {
 }
 
 // src/task/TaskRunner.ts
+init_TaskTypes();
+
 class TaskRunner {
   running = false;
   reactiveRunning = false;
@@ -522,6 +570,8 @@ class TaskRunner {
 }
 
 // src/task/Task.ts
+init_TaskTypes();
+
 class Task {
   static type = "Task";
   static category = "Hidden";
@@ -1020,7 +1070,13 @@ class ConditionalTask extends Task {
   }
 }
 
+// src/task-graph/TaskGraphRunner.ts
+init_TaskTypes();
+init_Dataflow();
+
 // src/task-graph/TaskGraphScheduler.ts
+init_TaskTypes();
+
 class TopologicalScheduler {
   dag;
   sortedNodes;
@@ -1724,35 +1780,70 @@ class GraphAsTask extends Task {
   }
 }
 
+// src/task-graph/Conversions.ts
+init_Dataflow();
+
 // src/task-graph/Workflow.ts
-import { EventEmitter as EventEmitter4 } from "@workglow/util";
+import { EventEmitter as EventEmitter4, uuid4 as uuid43 } from "@workglow/util";
+init_Dataflow();
+function CreateWorkflow(taskClass) {
+  return Workflow.createWorkflow(taskClass);
+}
+function CreateLoopWorkflow(taskClass) {
+  return function(config = {}) {
+    const task = new taskClass({}, config);
+    this.graph.addTask(task);
+    const previousTask = getLastTask(this);
+    if (previousTask && previousTask !== task) {
+      this.graph.addDataflow(new Dataflow(previousTask.config.id, "*", task.config.id, "*"));
+    }
+    return new Workflow(this.outputCache(), this, task);
+  };
+}
+function CreateEndLoopWorkflow(methodName) {
+  return function() {
+    if (!this.isLoopBuilder) {
+      throw new Error(`${methodName}() can only be called on loop workflows`);
+    }
+    return this.finalizeAndReturn();
+  };
+}
+
 class WorkflowTask extends GraphAsTask {
   static type = "Workflow";
   static compoundMerge = PROPERTY_ARRAY;
 }
-var taskIdCounter = 0;
 
 class Workflow {
-  constructor(repository) {
-    this._repository = repository;
-    this._graph = new TaskGraph({
-      outputCache: this._repository
-    });
-    this._onChanged = this._onChanged.bind(this);
-    this.setupEvents();
+  constructor(cache, parent, iteratorTask) {
+    this._outputCache = cache;
+    this._parentWorkflow = parent;
+    this._iteratorTask = iteratorTask;
+    this._graph = new TaskGraph({ outputCache: this._outputCache });
+    if (!parent) {
+      this._onChanged = this._onChanged.bind(this);
+      this.setupEvents();
+    }
   }
   _graph;
   _dataFlows = [];
   _error = "";
-  _repository;
+  _outputCache;
   _abortController;
+  _parentWorkflow;
+  _iteratorTask;
+  outputCache() {
+    return this._outputCache;
+  }
+  get isLoopBuilder() {
+    return this._parentWorkflow !== undefined;
+  }
   events = new EventEmitter4;
   static createWorkflow(taskClass) {
     const helper = function(input = {}, config = {}) {
       this._error = "";
       const parent = getLastTask(this);
-      taskIdCounter++;
-      const task = this.addTask(taskClass, input, { id: String(taskIdCounter), ...config });
+      const task = this.addTaskToGraph(taskClass, input, { id: uuid43(), ...config });
       if (this._dataFlows.length > 0) {
         this._dataFlows.forEach((dataflow) => {
           const taskSchema = task.inputSchema();
@@ -1767,158 +1858,23 @@ class Workflow {
         this._dataFlows = [];
       }
       if (parent && this.graph.getTargetDataflows(parent.config.id).length === 0) {
-        const matches = new Map;
-        const sourceSchema = parent.outputSchema();
-        const targetSchema = task.inputSchema();
-        const makeMatch = (comparator) => {
-          if (typeof sourceSchema === "object") {
-            if (targetSchema === true || typeof targetSchema === "object" && targetSchema.additionalProperties === true) {
-              for (const fromOutputPortId of Object.keys(sourceSchema.properties || {})) {
-                matches.set(fromOutputPortId, fromOutputPortId);
-                this.connect(parent.config.id, fromOutputPortId, task.config.id, fromOutputPortId);
-              }
-              return matches;
-            }
-          }
-          if (typeof sourceSchema === "boolean" || typeof targetSchema === "boolean") {
-            return matches;
-          }
-          for (const [fromOutputPortId, fromPortOutputSchema] of Object.entries(sourceSchema.properties || {})) {
-            for (const [toInputPortId, toPortInputSchema] of Object.entries(targetSchema.properties || {})) {
-              if (!matches.has(toInputPortId) && comparator([fromOutputPortId, fromPortOutputSchema], [toInputPortId, toPortInputSchema])) {
-                matches.set(toInputPortId, fromOutputPortId);
-                this.connect(parent.config.id, fromOutputPortId, task.config.id, toInputPortId);
-              }
-            }
-          }
-          return matches;
-        };
-        const getSpecificTypeIdentifiers = (schema) => {
-          const formats = new Set;
-          const ids = new Set;
-          if (typeof schema === "boolean") {
-            return { formats, ids };
-          }
-          const extractFromSchema = (s) => {
-            if (!s || typeof s !== "object" || Array.isArray(s))
-              return;
-            if (s.format)
-              formats.add(s.format);
-            if (s.$id)
-              ids.add(s.$id);
-          };
-          extractFromSchema(schema);
-          const checkUnion = (schemas) => {
-            if (!schemas)
-              return;
-            for (const s of schemas) {
-              if (typeof s === "boolean")
-                continue;
-              extractFromSchema(s);
-              if (s.items && typeof s.items === "object" && !Array.isArray(s.items)) {
-                extractFromSchema(s.items);
-              }
-            }
-          };
-          checkUnion(schema.oneOf);
-          checkUnion(schema.anyOf);
-          if (schema.items && typeof schema.items === "object" && !Array.isArray(schema.items)) {
-            extractFromSchema(schema.items);
-          }
-          return { formats, ids };
-        };
-        const isTypeCompatible = (fromPortOutputSchema, toPortInputSchema, requireSpecificType = false) => {
-          if (typeof fromPortOutputSchema === "boolean" || typeof toPortInputSchema === "boolean") {
-            return fromPortOutputSchema === true && toPortInputSchema === true;
-          }
-          const outputIds = getSpecificTypeIdentifiers(fromPortOutputSchema);
-          const inputIds = getSpecificTypeIdentifiers(toPortInputSchema);
-          for (const format of outputIds.formats) {
-            if (inputIds.formats.has(format)) {
-              return true;
-            }
-          }
-          for (const id of outputIds.ids) {
-            if (inputIds.ids.has(id)) {
-              return true;
-            }
-          }
-          if (requireSpecificType) {
-            return false;
-          }
-          const idTypeBlank = fromPortOutputSchema.$id === undefined && toPortInputSchema.$id === undefined;
-          if (!idTypeBlank)
-            return false;
-          if (fromPortOutputSchema.type === toPortInputSchema.type)
-            return true;
-          const matchesOneOf = toPortInputSchema.oneOf?.some((schema) => {
-            if (typeof schema === "boolean")
-              return schema;
-            return schema.type === fromPortOutputSchema.type;
-          }) ?? false;
-          const matchesAnyOf = toPortInputSchema.anyOf?.some((schema) => {
-            if (typeof schema === "boolean")
-              return schema;
-            return schema.type === fromPortOutputSchema.type;
-          }) ?? false;
-          return matchesOneOf || matchesAnyOf;
-        };
-        makeMatch(([fromOutputPortId, fromPortOutputSchema], [toInputPortId, toPortInputSchema]) => {
-          const outputPortIdMatch = fromOutputPortId === toInputPortId;
-          const outputPortIdOutputInput = fromOutputPortId === "output" && toInputPortId === "input";
-          const portIdsCompatible = outputPortIdMatch || outputPortIdOutputInput;
-          return portIdsCompatible && isTypeCompatible(fromPortOutputSchema, toPortInputSchema, false);
-        });
-        makeMatch(([_fromOutputPortId, fromPortOutputSchema], [_toInputPortId, toPortInputSchema]) => {
-          return isTypeCompatible(fromPortOutputSchema, toPortInputSchema, true);
-        });
-        const requiredInputs = new Set(typeof targetSchema === "object" ? targetSchema.required || [] : []);
-        const providedInputKeys = new Set(Object.keys(input || {}));
-        const requiredInputsNeedingConnection = [...requiredInputs].filter((r) => !providedInputKeys.has(r));
-        let unmatchedRequired = requiredInputsNeedingConnection.filter((r) => !matches.has(r));
-        if (unmatchedRequired.length > 0) {
-          const nodes = this._graph.getTasks();
-          const parentIndex = nodes.findIndex((n) => n.config.id === parent.config.id);
-          for (let i = parentIndex - 1;i >= 0 && unmatchedRequired.length > 0; i--) {
-            const earlierTask = nodes[i];
-            const earlierOutputSchema = earlierTask.outputSchema();
-            const makeMatchFromEarlier = (comparator) => {
-              if (typeof earlierOutputSchema === "boolean" || typeof targetSchema === "boolean") {
-                return;
-              }
-              for (const [fromOutputPortId, fromPortOutputSchema] of Object.entries(earlierOutputSchema.properties || {})) {
-                for (const requiredInputId of unmatchedRequired) {
-                  const toPortInputSchema = targetSchema.properties?.[requiredInputId];
-                  if (!matches.has(requiredInputId) && toPortInputSchema && comparator([fromOutputPortId, fromPortOutputSchema], [requiredInputId, toPortInputSchema])) {
-                    matches.set(requiredInputId, fromOutputPortId);
-                    this.connect(earlierTask.config.id, fromOutputPortId, task.config.id, requiredInputId);
-                  }
-                }
-              }
-            };
-            makeMatchFromEarlier(([fromOutputPortId, fromPortOutputSchema], [toInputPortId, toPortInputSchema]) => {
-              const outputPortIdMatch = fromOutputPortId === toInputPortId;
-              const outputPortIdOutputInput = fromOutputPortId === "output" && toInputPortId === "input";
-              const portIdsCompatible = outputPortIdMatch || outputPortIdOutputInput;
-              return portIdsCompatible && isTypeCompatible(fromPortOutputSchema, toPortInputSchema, false);
-            });
-            makeMatchFromEarlier(([_fromOutputPortId, fromPortOutputSchema], [_toInputPortId, toPortInputSchema]) => {
-              return isTypeCompatible(fromPortOutputSchema, toPortInputSchema, true);
-            });
-            unmatchedRequired = unmatchedRequired.filter((r) => !matches.has(r));
-          }
+        const nodes = this._graph.getTasks();
+        const parentIndex = nodes.findIndex((n) => n.config.id === parent.config.id);
+        const earlierTasks = [];
+        for (let i = parentIndex - 1;i >= 0; i--) {
+          earlierTasks.push(nodes[i]);
         }
-        const stillUnmatchedRequired = requiredInputsNeedingConnection.filter((r) => !matches.has(r));
-        if (stillUnmatchedRequired.length > 0) {
-          this._error = `Could not find matches for required inputs [${stillUnmatchedRequired.join(", ")}] of ${task.type}. ` + `Attempted to match from ${parent.type} and earlier tasks. Task not added.`;
-          console.error(this._error);
-          this.graph.removeTask(task.config.id);
-        } else if (matches.size === 0 && requiredInputsNeedingConnection.length === 0) {
-          const hasRequiredInputs = requiredInputs.size > 0;
-          const allRequiredInputsProvided = hasRequiredInputs && [...requiredInputs].every((r) => providedInputKeys.has(r));
-          const hasInputsWithDefaults = typeof targetSchema === "object" && targetSchema.properties && Object.values(targetSchema.properties).some((prop) => prop && typeof prop === "object" && ("default" in prop));
-          if (!allRequiredInputsProvided && !hasInputsWithDefaults) {
-            this._error = `Could not find a match between the outputs of ${parent.type} and the inputs of ${task.type}. ` + `You now need to connect the outputs to the inputs via connect() manually before adding this task. Task not added.`;
+        const providedInputKeys = new Set(Object.keys(input || {}));
+        const result = Workflow.autoConnect(this.graph, parent, task, {
+          providedInputKeys,
+          earlierTasks
+        });
+        if (result.error) {
+          if (this.isLoopBuilder) {
+            this._error = result.error;
+            console.warn(this._error);
+          } else {
+            this._error = result.error + " Task not added.";
             console.error(this._error);
             this.graph.removeTask(task.config.id);
           }
@@ -1961,12 +1917,16 @@ class Workflow {
     return this.events.waitOn(name);
   }
   async run(input = {}) {
+    if (this.isLoopBuilder) {
+      this.finalizeTemplate();
+      return this._parentWorkflow.run(input);
+    }
     this.events.emit("start");
     this._abortController = new AbortController;
     try {
       const output = await this.graph.run(input, {
         parentSignal: this._abortController.signal,
-        outputCache: this._repository
+        outputCache: this._outputCache
       });
       const results = this.graph.mergeExecuteOutputsToRunOutput(output, PROPERTY_ARRAY);
       this.events.emit("complete");
@@ -1979,6 +1939,9 @@ class Workflow {
     }
   }
   async abort() {
+    if (this._parentWorkflow) {
+      return this._parentWorkflow.abort();
+    }
     this._abortController?.abort();
   }
   pop() {
@@ -2047,10 +2010,12 @@ class Workflow {
     return task;
   }
   reset() {
-    taskIdCounter = 0;
+    if (this._parentWorkflow) {
+      throw new WorkflowError("Cannot reset a loop workflow. Call reset() on the parent workflow.");
+    }
     this.clearEvents();
     this._graph = new TaskGraph({
-      outputCache: this._repository
+      outputCache: this._outputCache
     });
     this._dataFlows = [];
     this._error = "";
@@ -2105,15 +2070,194 @@ class Workflow {
     this.graph.addDataflow(dataflow);
     return this;
   }
-  addTask(taskClass, input, config) {
+  addTaskToGraph(taskClass, input, config) {
     const task = new taskClass(input, config);
     const id = this.graph.addTask(task);
     this.events.emit("changed", id);
     return task;
   }
-}
-function CreateWorkflow(taskClass) {
-  return Workflow.createWorkflow(taskClass);
+  addTask(taskClass, input, config) {
+    const helper = Workflow.createWorkflow(taskClass);
+    return helper.call(this, input, config);
+  }
+  static AutoConnectOptions = Symbol("AutoConnectOptions");
+  static autoConnect(graph, sourceTask, targetTask, options) {
+    const matches = new Map;
+    const sourceSchema = sourceTask.outputSchema();
+    const targetSchema = targetTask.inputSchema();
+    const providedInputKeys = options?.providedInputKeys ?? new Set;
+    const earlierTasks = options?.earlierTasks ?? [];
+    const getSpecificTypeIdentifiers = (schema) => {
+      const formats = new Set;
+      const ids = new Set;
+      if (typeof schema === "boolean") {
+        return { formats, ids };
+      }
+      const extractFromSchema = (s) => {
+        if (!s || typeof s !== "object" || Array.isArray(s))
+          return;
+        if (s.format)
+          formats.add(s.format);
+        if (s.$id)
+          ids.add(s.$id);
+      };
+      extractFromSchema(schema);
+      const checkUnion = (schemas) => {
+        if (!schemas)
+          return;
+        for (const s of schemas) {
+          if (typeof s === "boolean")
+            continue;
+          extractFromSchema(s);
+          if (s.items && typeof s.items === "object" && !Array.isArray(s.items)) {
+            extractFromSchema(s.items);
+          }
+        }
+      };
+      checkUnion(schema.oneOf);
+      checkUnion(schema.anyOf);
+      if (schema.items && typeof schema.items === "object" && !Array.isArray(schema.items)) {
+        extractFromSchema(schema.items);
+      }
+      return { formats, ids };
+    };
+    const isTypeCompatible = (fromPortOutputSchema, toPortInputSchema, requireSpecificType = false) => {
+      if (typeof fromPortOutputSchema === "boolean" || typeof toPortInputSchema === "boolean") {
+        return fromPortOutputSchema === true && toPortInputSchema === true;
+      }
+      const outputIds = getSpecificTypeIdentifiers(fromPortOutputSchema);
+      const inputIds = getSpecificTypeIdentifiers(toPortInputSchema);
+      for (const format of outputIds.formats) {
+        if (inputIds.formats.has(format)) {
+          return true;
+        }
+      }
+      for (const id of outputIds.ids) {
+        if (inputIds.ids.has(id)) {
+          return true;
+        }
+      }
+      if (requireSpecificType) {
+        return false;
+      }
+      const idTypeBlank = fromPortOutputSchema.$id === undefined && toPortInputSchema.$id === undefined;
+      if (!idTypeBlank)
+        return false;
+      if (fromPortOutputSchema.type === toPortInputSchema.type)
+        return true;
+      const matchesOneOf = toPortInputSchema.oneOf?.some((schema) => {
+        if (typeof schema === "boolean")
+          return schema;
+        return schema.type === fromPortOutputSchema.type;
+      }) ?? false;
+      const matchesAnyOf = toPortInputSchema.anyOf?.some((schema) => {
+        if (typeof schema === "boolean")
+          return schema;
+        return schema.type === fromPortOutputSchema.type;
+      }) ?? false;
+      return matchesOneOf || matchesAnyOf;
+    };
+    const makeMatch = (fromSchema, toSchema, fromTaskId, toTaskId, comparator) => {
+      if (typeof fromSchema === "object") {
+        if (toSchema === true || typeof toSchema === "object" && toSchema.additionalProperties === true) {
+          for (const fromOutputPortId of Object.keys(fromSchema.properties || {})) {
+            matches.set(fromOutputPortId, fromOutputPortId);
+            graph.addDataflow(new Dataflow(fromTaskId, fromOutputPortId, toTaskId, fromOutputPortId));
+          }
+          return;
+        }
+      }
+      if (typeof fromSchema === "boolean" || typeof toSchema === "boolean") {
+        return;
+      }
+      for (const [fromOutputPortId, fromPortOutputSchema] of Object.entries(fromSchema.properties || {})) {
+        for (const [toInputPortId, toPortInputSchema] of Object.entries(toSchema.properties || {})) {
+          if (!matches.has(toInputPortId) && comparator([fromOutputPortId, fromPortOutputSchema], [toInputPortId, toPortInputSchema])) {
+            matches.set(toInputPortId, fromOutputPortId);
+            graph.addDataflow(new Dataflow(fromTaskId, fromOutputPortId, toTaskId, toInputPortId));
+          }
+        }
+      }
+    };
+    makeMatch(sourceSchema, targetSchema, sourceTask.config.id, targetTask.config.id, ([fromOutputPortId, fromPortOutputSchema], [toInputPortId, toPortInputSchema]) => {
+      const outputPortIdMatch = fromOutputPortId === toInputPortId;
+      const outputPortIdOutputInput = fromOutputPortId === "output" && toInputPortId === "input";
+      const portIdsCompatible = outputPortIdMatch || outputPortIdOutputInput;
+      return portIdsCompatible && isTypeCompatible(fromPortOutputSchema, toPortInputSchema, false);
+    });
+    makeMatch(sourceSchema, targetSchema, sourceTask.config.id, targetTask.config.id, ([_fromOutputPortId, fromPortOutputSchema], [_toInputPortId, toPortInputSchema]) => {
+      return isTypeCompatible(fromPortOutputSchema, toPortInputSchema, true);
+    });
+    const requiredInputs = new Set(typeof targetSchema === "object" ? targetSchema.required || [] : []);
+    const requiredInputsNeedingConnection = [...requiredInputs].filter((r) => !providedInputKeys.has(r));
+    let unmatchedRequired = requiredInputsNeedingConnection.filter((r) => !matches.has(r));
+    if (unmatchedRequired.length > 0 && earlierTasks.length > 0) {
+      for (let i = 0;i < earlierTasks.length && unmatchedRequired.length > 0; i++) {
+        const earlierTask = earlierTasks[i];
+        const earlierOutputSchema = earlierTask.outputSchema();
+        const makeMatchFromEarlier = (comparator) => {
+          if (typeof earlierOutputSchema === "boolean" || typeof targetSchema === "boolean") {
+            return;
+          }
+          for (const [fromOutputPortId, fromPortOutputSchema] of Object.entries(earlierOutputSchema.properties || {})) {
+            for (const requiredInputId of unmatchedRequired) {
+              const toPortInputSchema = targetSchema.properties?.[requiredInputId];
+              if (!matches.has(requiredInputId) && toPortInputSchema && comparator([fromOutputPortId, fromPortOutputSchema], [requiredInputId, toPortInputSchema])) {
+                matches.set(requiredInputId, fromOutputPortId);
+                graph.addDataflow(new Dataflow(earlierTask.config.id, fromOutputPortId, targetTask.config.id, requiredInputId));
+              }
+            }
+          }
+        };
+        makeMatchFromEarlier(([fromOutputPortId, fromPortOutputSchema], [toInputPortId, toPortInputSchema]) => {
+          const outputPortIdMatch = fromOutputPortId === toInputPortId;
+          const outputPortIdOutputInput = fromOutputPortId === "output" && toInputPortId === "input";
+          const portIdsCompatible = outputPortIdMatch || outputPortIdOutputInput;
+          return portIdsCompatible && isTypeCompatible(fromPortOutputSchema, toPortInputSchema, false);
+        });
+        makeMatchFromEarlier(([_fromOutputPortId, fromPortOutputSchema], [_toInputPortId, toPortInputSchema]) => {
+          return isTypeCompatible(fromPortOutputSchema, toPortInputSchema, true);
+        });
+        unmatchedRequired = unmatchedRequired.filter((r) => !matches.has(r));
+      }
+    }
+    const stillUnmatchedRequired = requiredInputsNeedingConnection.filter((r) => !matches.has(r));
+    if (stillUnmatchedRequired.length > 0) {
+      return {
+        matches,
+        error: `Could not find matches for required inputs [${stillUnmatchedRequired.join(", ")}] of ${targetTask.type}. ` + `Attempted to match from ${sourceTask.type} and earlier tasks.`,
+        unmatchedRequired: stillUnmatchedRequired
+      };
+    }
+    if (matches.size === 0 && requiredInputsNeedingConnection.length === 0) {
+      const hasRequiredInputs = requiredInputs.size > 0;
+      const allRequiredInputsProvided = hasRequiredInputs && [...requiredInputs].every((r) => providedInputKeys.has(r));
+      const hasInputsWithDefaults = typeof targetSchema === "object" && targetSchema.properties && Object.values(targetSchema.properties).some((prop) => prop && typeof prop === "object" && ("default" in prop));
+      if (!allRequiredInputsProvided && !hasInputsWithDefaults) {
+        return {
+          matches,
+          error: `Could not find a match between the outputs of ${sourceTask.type} and the inputs of ${targetTask.type}. ` + `You may need to connect the outputs to the inputs via connect() manually.`,
+          unmatchedRequired: []
+        };
+      }
+    }
+    return {
+      matches,
+      unmatchedRequired: []
+    };
+  }
+  finalizeTemplate() {
+    if (this._iteratorTask && this.graph.getTasks().length > 0) {
+      this._iteratorTask.setTemplateGraph(this.graph);
+    }
+  }
+  finalizeAndReturn() {
+    if (!this._parentWorkflow) {
+      throw new WorkflowError("finalizeAndReturn() can only be called on loop workflows");
+    }
+    this.finalizeTemplate();
+    return this._parentWorkflow;
+  }
 }
 
 // src/task-graph/Conversions.ts
@@ -2236,6 +2380,9 @@ function parallel(args, mergeFn = PROPERTY_ARRAY, workflow = new Workflow) {
   return workflow;
 }
 
+// src/task-graph/TaskGraph.ts
+init_Dataflow();
+
 // src/task-graph/TaskGraphEvents.ts
 var EventDagToTaskGraphMapping = {
   "node-added": "task_added",
@@ -2353,7 +2500,7 @@ class TaskGraph {
     return this._dag.removeNode(taskId);
   }
   resetGraph() {
-    this.runner.resetGraph(this, uuid43());
+    this.runner.resetGraph(this, uuid44());
   }
   toJSON() {
     const tasks = this.getTasks().map((node) => node.toJSON());
@@ -2518,84 +2665,10 @@ function serialGraph(tasks, inputHandle, outputHandle) {
   graph.addDataflows(serialGraphEdges(tasks, inputHandle, outputHandle));
   return graph;
 }
-// src/task/JobQueueFactory.ts
-import {
-  JobQueueClient,
-  JobQueueServer
-} from "@workglow/job-queue";
+// src/task/IteratorTaskRunner.ts
+import { Job, JobQueueClient, JobQueueServer } from "@workglow/job-queue";
 import { InMemoryQueueStorage } from "@workglow/storage";
-import { createServiceToken as createServiceToken2, globalServiceRegistry as globalServiceRegistry3 } from "@workglow/util";
-var JOB_QUEUE_FACTORY = createServiceToken2("taskgraph.jobQueueFactory");
-var defaultJobQueueFactory = async ({
-  queueName,
-  jobClass,
-  options
-}) => {
-  const storage = options?.storage ?? new InMemoryQueueStorage(queueName);
-  await storage.setupDatabase();
-  const server = new JobQueueServer(jobClass, {
-    storage,
-    queueName,
-    limiter: options?.limiter,
-    workerCount: options?.workerCount,
-    pollIntervalMs: options?.pollIntervalMs,
-    deleteAfterCompletionMs: options?.deleteAfterCompletionMs,
-    deleteAfterFailureMs: options?.deleteAfterFailureMs,
-    deleteAfterDisabledMs: options?.deleteAfterDisabledMs,
-    cleanupIntervalMs: options?.cleanupIntervalMs
-  });
-  const client = new JobQueueClient({
-    storage,
-    queueName
-  });
-  client.attach(server);
-  return { server, client, storage };
-};
-function registerJobQueueFactory(factory) {
-  globalServiceRegistry3.registerInstance(JOB_QUEUE_FACTORY, factory);
-}
-function createJobQueueFactoryWithOptions(defaultOptions = {}) {
-  return async ({
-    queueName,
-    jobClass,
-    options
-  }) => {
-    const mergedOptions = {
-      ...defaultOptions,
-      ...options ?? {}
-    };
-    const storage = mergedOptions.storage ?? new InMemoryQueueStorage(queueName);
-    await storage.setupDatabase();
-    const server = new JobQueueServer(jobClass, {
-      storage,
-      queueName,
-      limiter: mergedOptions.limiter,
-      workerCount: mergedOptions.workerCount,
-      pollIntervalMs: mergedOptions.pollIntervalMs,
-      deleteAfterCompletionMs: mergedOptions.deleteAfterCompletionMs,
-      deleteAfterFailureMs: mergedOptions.deleteAfterFailureMs,
-      deleteAfterDisabledMs: mergedOptions.deleteAfterDisabledMs,
-      cleanupIntervalMs: mergedOptions.cleanupIntervalMs
-    });
-    const client = new JobQueueClient({
-      storage,
-      queueName
-    });
-    client.attach(server);
-    return { server, client, storage };
-  };
-}
-function getJobQueueFactory() {
-  if (!globalServiceRegistry3.has(JOB_QUEUE_FACTORY)) {
-    registerJobQueueFactory(defaultJobQueueFactory);
-  }
-  return globalServiceRegistry3.get(JOB_QUEUE_FACTORY);
-}
-if (!globalServiceRegistry3.has(JOB_QUEUE_FACTORY)) {
-  registerJobQueueFactory(defaultJobQueueFactory);
-}
-// src/task/JobQueueTask.ts
-import { Job as Job2 } from "@workglow/job-queue";
+import { uuid4 as uuid45 } from "@workglow/util";
 
 // src/task/TaskQueueRegistry.ts
 var taskQueueRegistry = null;
@@ -2645,41 +2718,676 @@ function setTaskQueueRegistry(registry) {
   taskQueueRegistry = registry;
 }
 
-// src/task/JobQueueTask.ts
-class JobQueueTask extends GraphAsTask {
-  static type = "JobQueueTask";
-  static canRunDirectly = true;
-  currentQueueName;
-  currentJobId;
-  currentRunnerId;
-  jobClass;
-  constructor(input = {}, config = {}) {
-    config.queue ??= true;
-    super(input, config);
-    this.jobClass = Job2;
-  }
-  async execute(input, executeContext) {
-    let cleanup = () => {};
+// src/task/IteratorTaskRunner.ts
+class IteratorTaskRunner extends GraphAsTaskRunner {
+  iteratorQueue;
+  iteratorQueueName;
+  async getOrCreateIteratorQueue() {
+    const executionMode = this.task.executionMode;
+    if (executionMode === "parallel") {
+      return;
+    }
+    if (this.iteratorQueue) {
+      return this.iteratorQueue;
+    }
+    const queueName = this.task.config.queueName ?? `iterator-${this.task.config.id}-${uuid45().slice(0, 8)}`;
+    this.iteratorQueueName = queueName;
+    const existingQueue = getTaskQueueRegistry().getQueue(queueName);
+    if (existingQueue) {
+      this.iteratorQueue = existingQueue;
+      return existingQueue;
+    }
+    const concurrency = this.getConcurrencyForMode(executionMode);
+    this.iteratorQueue = await this.createIteratorQueue(queueName, concurrency);
+    return this.iteratorQueue;
+  }
+  getConcurrencyForMode(mode) {
+    switch (mode) {
+      case "sequential":
+        return 1;
+      case "parallel-limited":
+        return this.task.concurrencyLimit;
+      case "batched":
+        return this.task.batchSize;
+      case "parallel":
+      default:
+        return Infinity;
+    }
+  }
+  async createIteratorQueue(queueName, concurrency) {
+    const storage = new InMemoryQueueStorage(queueName);
+    await storage.setupDatabase();
+    const JobClass = class extends Job {
+      async execute(input) {
+        return input;
+      }
+    };
+    const server = new JobQueueServer(JobClass, {
+      storage,
+      queueName,
+      workerCount: Math.min(concurrency, 10)
+    });
+    const client = new JobQueueClient({
+      storage,
+      queueName
+    });
+    client.attach(server);
+    const queue = {
+      server,
+      client,
+      storage
+    };
     try {
-      if (this.config.queue === false && !this.constructor.canRunDirectly) {
-        throw new TaskConfigurationError(`${this.type} cannot run directly without a queue`);
+      getTaskQueueRegistry().registerQueue(queue);
+    } catch (err) {
+      const existing = getTaskQueueRegistry().getQueue(queueName);
+      if (existing) {
+        return existing;
       }
-      const registeredQueue = await this.resolveQueue(input);
-      if (!registeredQueue) {
-        if (!this.constructor.canRunDirectly) {
-          const queueLabel = typeof this.config.queue === "string" ? this.config.queue : this.currentQueueName ?? this.type;
-          throw new TaskConfigurationError(`Queue ${queueLabel} not found, and ${this.type} cannot run directly`);
-        }
-        this.currentJobId = undefined;
-        const job = await this.createJob(input, this.currentQueueName);
-        cleanup = job.onJobProgress((progress, message, details) => {
-          executeContext.updateProgress(progress, message, details);
-        });
-        const output2 = await job.execute(job.input, {
-          signal: executeContext.signal,
-          updateProgress: executeContext.updateProgress.bind(this)
-        });
-        return output2;
+      throw err;
+    }
+    await server.start();
+    return queue;
+  }
+  async executeTaskChildren(input) {
+    const executionMode = this.task.executionMode;
+    switch (executionMode) {
+      case "sequential":
+        return this.executeSequential(input);
+      case "parallel-limited":
+        return this.executeParallelLimited(input);
+      case "batched":
+        return this.executeBatched(input);
+      case "parallel":
+      default:
+        return super.executeTaskChildren(input);
+    }
+  }
+  async executeSequential(input) {
+    const tasks = this.task.subGraph.getTasks();
+    const results = [];
+    for (const task of tasks) {
+      if (this.abortController?.signal.aborted) {
+        break;
+      }
+      const taskResult = await task.run(input);
+      results.push({
+        id: task.config.id,
+        type: task.type,
+        data: taskResult
+      });
+    }
+    return results;
+  }
+  async executeParallelLimited(input) {
+    const tasks = this.task.subGraph.getTasks();
+    const results = [];
+    const limit = this.task.concurrencyLimit;
+    for (let i = 0;i < tasks.length; i += limit) {
+      if (this.abortController?.signal.aborted) {
+        break;
+      }
+      const chunk = tasks.slice(i, i + limit);
+      const chunkPromises = chunk.map(async (task) => {
+        const taskResult = await task.run(input);
+        return {
+          id: task.config.id,
+          type: task.type,
+          data: taskResult
+        };
+      });
+      const chunkResults = await Promise.all(chunkPromises);
+      results.push(...chunkResults);
+    }
+    return results;
+  }
+  async executeBatched(input) {
+    const tasks = this.task.subGraph.getTasks();
+    const results = [];
+    const batchSize = this.task.batchSize;
+    for (let i = 0;i < tasks.length; i += batchSize) {
+      if (this.abortController?.signal.aborted) {
+        break;
+      }
+      const batch = tasks.slice(i, i + batchSize);
+      const batchPromises = batch.map(async (task) => {
+        const taskResult = await task.run(input);
+        return {
+          id: task.config.id,
+          type: task.type,
+          data: taskResult
+        };
+      });
+      const batchResults = await Promise.all(batchPromises);
+      results.push(...batchResults);
+      const progress = Math.round((i + batch.length) / tasks.length * 100);
+      this.task.emit("progress", progress, `Completed batch ${Math.ceil((i + 1) / batchSize)}`);
+    }
+    return results;
+  }
+  async cleanup() {
+    if (this.iteratorQueue && this.iteratorQueueName) {
+      try {
+        this.iteratorQueue.server.stop();
+      } catch (err) {}
+    }
+  }
+}
+
+// src/task/IteratorTask.ts
+class IteratorTask extends GraphAsTask {
+  static type = "IteratorTask";
+  static category = "Flow Control";
+  static title = "Iterator";
+  static description = "Base class for loop-type tasks";
+  static hasDynamicSchemas = true;
+  _templateGraph;
+  _iteratorPortInfo;
+  constructor(input = {}, config = {}) {
+    super(input, config);
+  }
+  get runner() {
+    if (!this._runner) {
+      this._runner = new IteratorTaskRunner(this);
+    }
+    return this._runner;
+  }
+  get executionMode() {
+    return this.config.executionMode ?? "parallel";
+  }
+  get concurrencyLimit() {
+    return this.config.concurrencyLimit ?? 5;
+  }
+  get batchSize() {
+    return this.config.batchSize ?? 10;
+  }
+  detectIteratorPort() {
+    if (this._iteratorPortInfo) {
+      return this._iteratorPortInfo;
+    }
+    if (this.config.iteratorPort) {
+      const schema2 = this.inputSchema();
+      if (typeof schema2 === "boolean")
+        return;
+      const portSchema = schema2.properties?.[this.config.iteratorPort];
+      if (portSchema && typeof portSchema === "object") {
+        const itemSchema = portSchema.items ?? { type: "object" };
+        this._iteratorPortInfo = {
+          portName: this.config.iteratorPort,
+          itemSchema
+        };
+        return this._iteratorPortInfo;
+      }
+    }
+    const schema = this.inputSchema();
+    if (typeof schema === "boolean")
+      return;
+    const properties = schema.properties || {};
+    for (const [portName, portSchema] of Object.entries(properties)) {
+      if (typeof portSchema !== "object" || portSchema === null)
+        continue;
+      const ps = portSchema;
+      if (ps.type === "array" || ps.items !== undefined) {
+        const itemSchema = ps.items ?? {
+          type: "object",
+          properties: {},
+          additionalProperties: true
+        };
+        this._iteratorPortInfo = { portName, itemSchema };
+        return this._iteratorPortInfo;
+      }
+      const variants = ps.oneOf ?? ps.anyOf;
+      if (Array.isArray(variants)) {
+        for (const variant of variants) {
+          if (typeof variant === "object" && variant !== null) {
+            const v = variant;
+            if (v.type === "array" || v.items !== undefined) {
+              const itemSchema = v.items ?? {
+                type: "object",
+                properties: {},
+                additionalProperties: true
+              };
+              this._iteratorPortInfo = { portName, itemSchema };
+              return this._iteratorPortInfo;
+            }
+          }
+        }
+      }
+    }
+    return;
+  }
+  getIteratorPortName() {
+    return this.detectIteratorPort()?.portName;
+  }
+  getItemSchema() {
+    return this.detectIteratorPort()?.itemSchema ?? {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+  }
+  getIterableItems(input) {
+    const portName = this.getIteratorPortName();
+    if (!portName) {
+      throw new TaskConfigurationError(`${this.type}: No array port found in input schema. ` + `Specify 'iteratorPort' in config or ensure input has an array-typed property.`);
+    }
+    const items = input[portName];
+    if (items === undefined || items === null) {
+      return [];
+    }
+    if (Array.isArray(items)) {
+      return items;
+    }
+    return [items];
+  }
+  setTemplateGraph(graph) {
+    this._templateGraph = graph;
+    this.events.emit("regenerate");
+  }
+  getTemplateGraph() {
+    return this._templateGraph;
+  }
+  regenerateGraph() {
+    this.subGraph = new TaskGraph;
+    if (!this._templateGraph || !this._templateGraph.getTasks().length) {
+      super.regenerateGraph();
+      return;
+    }
+    const items = this.getIterableItems(this.runInputData);
+    if (items.length === 0) {
+      super.regenerateGraph();
+      return;
+    }
+    this.createIterationTasks(items);
+    super.regenerateGraph();
+  }
+  createIterationTasks(items) {
+    const portName = this.getIteratorPortName();
+    if (!portName)
+      return;
+    const baseInput = {};
+    for (const [key, value] of Object.entries(this.runInputData)) {
+      if (key !== portName) {
+        baseInput[key] = value;
+      }
+    }
+    for (let i = 0;i < items.length; i++) {
+      const item = items[i];
+      const iterationInput = {
+        ...baseInput,
+        [portName]: item,
+        _iterationIndex: i,
+        _iterationItem: item
+      };
+      this.cloneTemplateForIteration(iterationInput, i);
+    }
+  }
+  cloneTemplateForIteration(iterationInput, index) {
+    if (!this._templateGraph)
+      return;
+    const templateTasks = this._templateGraph.getTasks();
+    const templateDataflows = this._templateGraph.getDataflows();
+    const idMap = new Map;
+    for (const templateTask of templateTasks) {
+      const TaskClass = templateTask.constructor;
+      const clonedTask = new TaskClass({ ...templateTask.defaults, ...iterationInput }, {
+        ...templateTask.config,
+        id: `${templateTask.config.id}_iter${index}`,
+        name: `${templateTask.config.name || templateTask.type} [${index}]`
+      });
+      this.subGraph.addTask(clonedTask);
+      idMap.set(templateTask.config.id, clonedTask.config.id);
+    }
+    for (const templateDataflow of templateDataflows) {
+      const sourceId = idMap.get(templateDataflow.sourceTaskId);
+      const targetId = idMap.get(templateDataflow.targetTaskId);
+      if (sourceId !== undefined && targetId !== undefined) {
+        const { Dataflow: Dataflow2 } = (init_Dataflow(), __toCommonJS(exports_Dataflow));
+        const clonedDataflow = new Dataflow2(sourceId, templateDataflow.sourceTaskPortId, targetId, templateDataflow.targetTaskPortId);
+        this.subGraph.addDataflow(clonedDataflow);
+      }
+    }
+  }
+  async execute(input, context) {
+    const items = this.getIterableItems(input);
+    if (items.length === 0) {
+      return this.getEmptyResult();
+    }
+    this.runInputData = { ...this.defaults, ...input };
+    this.regenerateGraph();
+    return super.execute(input, context);
+  }
+  getEmptyResult() {
+    return {};
+  }
+  collectResults(results) {
+    return results;
+  }
+  inputSchema() {
+    if (this.hasChildren() || this._templateGraph) {
+      return super.inputSchema();
+    }
+    return this.constructor.inputSchema();
+  }
+  outputSchema() {
+    if (!this.hasChildren() && !this._templateGraph) {
+      return this.constructor.outputSchema();
+    }
+    return this.getWrappedOutputSchema();
+  }
+  getWrappedOutputSchema() {
+    const templateGraph = this._templateGraph ?? this.subGraph;
+    if (!templateGraph) {
+      return { type: "object", properties: {}, additionalProperties: false };
+    }
+    const tasks = templateGraph.getTasks();
+    const endingNodes = tasks.filter((task) => templateGraph.getTargetDataflows(task.config.id).length === 0);
+    if (endingNodes.length === 0) {
+      return { type: "object", properties: {}, additionalProperties: false };
+    }
+    const properties = {};
+    for (const task of endingNodes) {
+      const taskOutputSchema = task.outputSchema();
+      if (typeof taskOutputSchema === "boolean")
+        continue;
+      const taskProperties = taskOutputSchema.properties || {};
+      for (const [key, schema] of Object.entries(taskProperties)) {
+        properties[key] = {
+          type: "array",
+          items: schema
+        };
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      additionalProperties: false
+    };
+  }
+}
+
+// src/task/BatchTask.ts
+class BatchTask extends IteratorTask {
+  static type = "BatchTask";
+  static category = "Flow Control";
+  static title = "Batch";
+  static description = "Processes an array in configurable batches";
+  static compoundMerge = PROPERTY_ARRAY;
+  static inputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+  }
+  static outputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+  }
+  get batchSize() {
+    return this.config.batchSize ?? 10;
+  }
+  get flattenResults() {
+    return this.config.flattenResults ?? true;
+  }
+  get batchExecutionMode() {
+    return this.config.batchExecutionMode ?? "sequential";
+  }
+  getIterableItems(input) {
+    const items = super.getIterableItems(input);
+    return this.groupIntoBatches(items);
+  }
+  groupIntoBatches(items) {
+    const batches = [];
+    const size = this.batchSize;
+    for (let i = 0;i < items.length; i += size) {
+      batches.push(items.slice(i, i + size));
+    }
+    return batches;
+  }
+  createIterationTasks(batches) {
+    const portName = this.getIteratorPortName();
+    if (!portName)
+      return;
+    const baseInput = {};
+    for (const [key, value] of Object.entries(this.runInputData)) {
+      if (key !== portName) {
+        baseInput[key] = value;
+      }
+    }
+    for (let i = 0;i < batches.length; i++) {
+      const batch = batches[i];
+      const batchInput = {
+        ...baseInput,
+        [portName]: batch,
+        _batchIndex: i,
+        _batchItems: batch
+      };
+      this.cloneTemplateForIteration(batchInput, i);
+    }
+  }
+  getEmptyResult() {
+    const schema = this.outputSchema();
+    if (typeof schema === "boolean") {
+      return {};
+    }
+    const result = {};
+    for (const key of Object.keys(schema.properties || {})) {
+      result[key] = [];
+    }
+    return result;
+  }
+  outputSchema() {
+    if (!this.hasChildren() && !this._templateGraph) {
+      return this.constructor.outputSchema();
+    }
+    return this.getWrappedOutputSchema();
+  }
+  collectResults(results) {
+    const collected = super.collectResults(results);
+    if (!this.flattenResults || typeof collected !== "object" || collected === null) {
+      return collected;
+    }
+    const flattened = {};
+    for (const [key, value] of Object.entries(collected)) {
+      if (Array.isArray(value)) {
+        flattened[key] = value.flat(2);
+      } else {
+        flattened[key] = value;
+      }
+    }
+    return flattened;
+  }
+  regenerateGraph() {
+    this.subGraph = new TaskGraph;
+    if (!this._templateGraph || !this._templateGraph.getTasks().length) {
+      super.regenerateGraph();
+      return;
+    }
+    const batches = this.getIterableItems(this.runInputData);
+    if (batches.length === 0) {
+      super.regenerateGraph();
+      return;
+    }
+    this.createIterationTasks(batches);
+    this.events.emit("regenerate");
+  }
+}
+Workflow.prototype.batch = CreateLoopWorkflow(BatchTask);
+Workflow.prototype.endBatch = CreateEndLoopWorkflow("endBatch");
+// src/task/ForEachTask.ts
+class ForEachTask extends IteratorTask {
+  static type = "ForEachTask";
+  static category = "Flow Control";
+  static title = "For Each";
+  static description = "Iterates over an array and runs a workflow for each element";
+  static inputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+  }
+  static outputSchema() {
+    return {
+      type: "object",
+      properties: {
+        completed: {
+          type: "boolean",
+          title: "Completed",
+          description: "Whether all iterations completed successfully"
+        },
+        count: {
+          type: "number",
+          title: "Count",
+          description: "Number of items processed"
+        }
+      },
+      additionalProperties: false
+    };
+  }
+  get shouldCollectResults() {
+    return this.config.shouldCollectResults ?? false;
+  }
+  getEmptyResult() {
+    return {
+      completed: true,
+      count: 0
+    };
+  }
+  outputSchema() {
+    if (this.shouldCollectResults && (this.hasChildren() || this._templateGraph)) {
+      return this.getWrappedOutputSchema();
+    }
+    return this.constructor.outputSchema();
+  }
+  collectResults(results) {
+    if (this.config.shouldCollectResults) {
+      return super.collectResults(results);
+    }
+    return {
+      completed: true,
+      count: results.length
+    };
+  }
+}
+Workflow.prototype.forEach = CreateLoopWorkflow(ForEachTask);
+Workflow.prototype.endForEach = CreateEndLoopWorkflow("endForEach");
+// src/task/JobQueueFactory.ts
+import {
+  JobQueueClient as JobQueueClient2,
+  JobQueueServer as JobQueueServer2
+} from "@workglow/job-queue";
+import { InMemoryQueueStorage as InMemoryQueueStorage2 } from "@workglow/storage";
+import { createServiceToken as createServiceToken2, globalServiceRegistry as globalServiceRegistry3 } from "@workglow/util";
+var JOB_QUEUE_FACTORY = createServiceToken2("taskgraph.jobQueueFactory");
+var defaultJobQueueFactory = async ({
+  queueName,
+  jobClass,
+  options
+}) => {
+  const storage = options?.storage ?? new InMemoryQueueStorage2(queueName);
+  await storage.setupDatabase();
+  const server = new JobQueueServer2(jobClass, {
+    storage,
+    queueName,
+    limiter: options?.limiter,
+    workerCount: options?.workerCount,
+    pollIntervalMs: options?.pollIntervalMs,
+    deleteAfterCompletionMs: options?.deleteAfterCompletionMs,
+    deleteAfterFailureMs: options?.deleteAfterFailureMs,
+    deleteAfterDisabledMs: options?.deleteAfterDisabledMs,
+    cleanupIntervalMs: options?.cleanupIntervalMs
+  });
+  const client = new JobQueueClient2({
+    storage,
+    queueName
+  });
+  client.attach(server);
+  return { server, client, storage };
+};
+function registerJobQueueFactory(factory) {
+  globalServiceRegistry3.registerInstance(JOB_QUEUE_FACTORY, factory);
+}
+function createJobQueueFactoryWithOptions(defaultOptions = {}) {
+  return async ({
+    queueName,
+    jobClass,
+    options
+  }) => {
+    const mergedOptions = {
+      ...defaultOptions,
+      ...options ?? {}
+    };
+    const storage = mergedOptions.storage ?? new InMemoryQueueStorage2(queueName);
+    await storage.setupDatabase();
+    const server = new JobQueueServer2(jobClass, {
+      storage,
+      queueName,
+      limiter: mergedOptions.limiter,
+      workerCount: mergedOptions.workerCount,
+      pollIntervalMs: mergedOptions.pollIntervalMs,
+      deleteAfterCompletionMs: mergedOptions.deleteAfterCompletionMs,
+      deleteAfterFailureMs: mergedOptions.deleteAfterFailureMs,
+      deleteAfterDisabledMs: mergedOptions.deleteAfterDisabledMs,
+      cleanupIntervalMs: mergedOptions.cleanupIntervalMs
+    });
+    const client = new JobQueueClient2({
+      storage,
+      queueName
+    });
+    client.attach(server);
+    return { server, client, storage };
+  };
+}
+function getJobQueueFactory() {
+  if (!globalServiceRegistry3.has(JOB_QUEUE_FACTORY)) {
+    registerJobQueueFactory(defaultJobQueueFactory);
+  }
+  return globalServiceRegistry3.get(JOB_QUEUE_FACTORY);
+}
+if (!globalServiceRegistry3.has(JOB_QUEUE_FACTORY)) {
+  registerJobQueueFactory(defaultJobQueueFactory);
+}
+// src/task/JobQueueTask.ts
+import { Job as Job3 } from "@workglow/job-queue";
+class JobQueueTask extends GraphAsTask {
+  static type = "JobQueueTask";
+  static canRunDirectly = true;
+  currentQueueName;
+  currentJobId;
+  currentRunnerId;
+  jobClass;
+  constructor(input = {}, config = {}) {
+    config.queue ??= true;
+    super(input, config);
+    this.jobClass = Job3;
+  }
+  async execute(input, executeContext) {
+    let cleanup = () => {};
+    try {
+      if (this.config.queue === false && !this.constructor.canRunDirectly) {
+        throw new TaskConfigurationError(`${this.type} cannot run directly without a queue`);
+      }
+      const registeredQueue = await this.resolveQueue(input);
+      if (!registeredQueue) {
+        if (!this.constructor.canRunDirectly) {
+          const queueLabel = typeof this.config.queue === "string" ? this.config.queue : this.currentQueueName ?? this.type;
+          throw new TaskConfigurationError(`Queue ${queueLabel} not found, and ${this.type} cannot run directly`);
+        }
+        this.currentJobId = undefined;
+        const job = await this.createJob(input, this.currentQueueName);
+        cleanup = job.onJobProgress((progress, message, details) => {
+          executeContext.updateProgress(progress, message, details);
+        });
+        const output2 = await job.execute(job.input, {
+          signal: executeContext.signal,
+          updateProgress: executeContext.updateProgress.bind(this)
+        });
+        return output2;
       }
       const { client } = registeredQueue;
       const jobInput = await this.getJobInput(input);
@@ -2778,6 +3486,219 @@ class JobQueueTask extends GraphAsTask {
     super.abort();
   }
 }
+// src/task/MapTask.ts
+class MapTask extends IteratorTask {
+  static type = "MapTask";
+  static category = "Flow Control";
+  static title = "Map";
+  static description = "Transforms an array by running a workflow for each element";
+  static compoundMerge = PROPERTY_ARRAY;
+  static inputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+  }
+  static outputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+  }
+  get preserveOrder() {
+    return this.config.preserveOrder ?? true;
+  }
+  get flatten() {
+    return this.config.flatten ?? false;
+  }
+  getEmptyResult() {
+    const schema = this.outputSchema();
+    if (typeof schema === "boolean") {
+      return {};
+    }
+    const result = {};
+    for (const key of Object.keys(schema.properties || {})) {
+      result[key] = [];
+    }
+    return result;
+  }
+  outputSchema() {
+    if (!this.hasChildren() && !this._templateGraph) {
+      return this.constructor.outputSchema();
+    }
+    return this.getWrappedOutputSchema();
+  }
+  collectResults(results) {
+    const collected = super.collectResults(results);
+    if (!this.flatten || typeof collected !== "object" || collected === null) {
+      return collected;
+    }
+    const flattened = {};
+    for (const [key, value] of Object.entries(collected)) {
+      if (Array.isArray(value)) {
+        flattened[key] = value.flat();
+      } else {
+        flattened[key] = value;
+      }
+    }
+    return flattened;
+  }
+}
+Workflow.prototype.map = CreateLoopWorkflow(MapTask);
+Workflow.prototype.endMap = CreateEndLoopWorkflow("endMap");
+// src/task/ReduceTask.ts
+class ReduceTask extends IteratorTask {
+  static type = "ReduceTask";
+  static category = "Flow Control";
+  static title = "Reduce";
+  static description = "Processes array elements sequentially with an accumulator (fold)";
+  constructor(input = {}, config = {}) {
+    const reduceConfig = {
+      ...config,
+      executionMode: "sequential"
+    };
+    super(input, reduceConfig);
+  }
+  get initialValue() {
+    return this.config.initialValue ?? {};
+  }
+  get accumulatorPort() {
+    return this.config.accumulatorPort ?? "accumulator";
+  }
+  get currentItemPort() {
+    return this.config.currentItemPort ?? "currentItem";
+  }
+  get indexPort() {
+    return this.config.indexPort ?? "index";
+  }
+  async execute(input, context) {
+    if (!this._templateGraph || this._templateGraph.getTasks().length === 0) {
+      return this.initialValue;
+    }
+    const items = this.getIterableItems(input);
+    if (items.length === 0) {
+      return this.initialValue;
+    }
+    let accumulator = { ...this.initialValue };
+    for (let index = 0;index < items.length; index++) {
+      if (context.signal?.aborted) {
+        break;
+      }
+      const currentItem = items[index];
+      const stepInput = {
+        ...input,
+        [this.accumulatorPort]: accumulator,
+        [this.currentItemPort]: currentItem,
+        [this.indexPort]: index
+      };
+      this.subGraph = this.cloneTemplateForStep(index);
+      const results = await this.subGraph.run(stepInput, {
+        parentSignal: context.signal
+      });
+      accumulator = this.subGraph.mergeExecuteOutputsToRunOutput(results, this.compoundMerge);
+      const progress = Math.round((index + 1) / items.length * 100);
+      await context.updateProgress(progress, `Processing item ${index + 1}/${items.length}`);
+    }
+    return accumulator;
+  }
+  getEmptyResult() {
+    return this.initialValue;
+  }
+  cloneTemplateForStep(stepIndex) {
+    const clonedGraph = new TaskGraph;
+    if (!this._templateGraph) {
+      return clonedGraph;
+    }
+    const templateTasks = this._templateGraph.getTasks();
+    const templateDataflows = this._templateGraph.getDataflows();
+    const idMap = new Map;
+    for (const templateTask of templateTasks) {
+      const TaskClass = templateTask.constructor;
+      const clonedTask = new TaskClass({ ...templateTask.defaults }, {
+        ...templateTask.config,
+        id: `${templateTask.config.id}_step${stepIndex}`,
+        name: `${templateTask.config.name || templateTask.type} [${stepIndex}]`
+      });
+      clonedGraph.addTask(clonedTask);
+      idMap.set(templateTask.config.id, clonedTask.config.id);
+    }
+    for (const templateDataflow of templateDataflows) {
+      const sourceId = idMap.get(templateDataflow.sourceTaskId);
+      const targetId = idMap.get(templateDataflow.targetTaskId);
+      if (sourceId !== undefined && targetId !== undefined) {
+        const { Dataflow: Dataflow2 } = (init_Dataflow(), __toCommonJS(exports_Dataflow));
+        const clonedDataflow = new Dataflow2(sourceId, templateDataflow.sourceTaskPortId, targetId, templateDataflow.targetTaskPortId);
+        clonedGraph.addDataflow(clonedDataflow);
+      }
+    }
+    return clonedGraph;
+  }
+  static inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        accumulator: {
+          title: "Accumulator",
+          description: "The current accumulator value"
+        },
+        currentItem: {
+          title: "Current Item",
+          description: "The current item being processed"
+        },
+        index: {
+          type: "number",
+          title: "Index",
+          description: "The current item index"
+        }
+      },
+      additionalProperties: true
+    };
+  }
+  static outputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+  }
+  outputSchema() {
+    if (!this._templateGraph) {
+      return this.constructor.outputSchema();
+    }
+    const tasks = this._templateGraph.getTasks();
+    const endingNodes = tasks.filter((task) => this._templateGraph.getTargetDataflows(task.config.id).length === 0);
+    if (endingNodes.length === 0) {
+      return this.constructor.outputSchema();
+    }
+    const properties = {};
+    for (const task of endingNodes) {
+      const taskOutputSchema = task.outputSchema();
+      if (typeof taskOutputSchema === "boolean")
+        continue;
+      const taskProperties = taskOutputSchema.properties || {};
+      for (const [key, schema] of Object.entries(taskProperties)) {
+        if (!properties[key]) {
+          properties[key] = schema;
+        }
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      additionalProperties: false
+    };
+  }
+  regenerateGraph() {
+    this.events.emit("regenerate");
+  }
+}
+Workflow.prototype.reduce = CreateLoopWorkflow(ReduceTask);
+Workflow.prototype.endReduce = CreateEndLoopWorkflow("endReduce");
+// src/task/TaskJSON.ts
+init_Dataflow();
+
 // src/task/TaskRegistry.ts
 var taskConstructors = new Map;
 function registerTask(baseClass) {
@@ -2845,9 +3766,167 @@ var createGraphFromGraphJSON = (graphJsonObj) => {
   }
   return subGraph;
 };
+
+// src/task/index.ts
+init_TaskTypes();
+
+// src/task/WhileTask.ts
+class WhileTask extends GraphAsTask {
+  static type = "WhileTask";
+  static category = "Flow Control";
+  static title = "While Loop";
+  static description = "Loops until a condition function returns false";
+  static hasDynamicSchemas = true;
+  _templateGraph;
+  _currentIteration = 0;
+  constructor(input = {}, config = {}) {
+    super(input, config);
+  }
+  get condition() {
+    return this.config.condition;
+  }
+  get maxIterations() {
+    return this.config.maxIterations ?? 100;
+  }
+  get chainIterations() {
+    return this.config.chainIterations ?? true;
+  }
+  get currentIteration() {
+    return this._currentIteration;
+  }
+  setTemplateGraph(graph) {
+    this._templateGraph = graph;
+  }
+  getTemplateGraph() {
+    return this._templateGraph;
+  }
+  async execute(input, context) {
+    if (!this._templateGraph || this._templateGraph.getTasks().length === 0) {
+      throw new TaskConfigurationError(`${this.type}: No template graph set for while loop`);
+    }
+    if (!this.condition) {
+      throw new TaskConfigurationError(`${this.type}: No condition function provided`);
+    }
+    this._currentIteration = 0;
+    let currentInput = { ...input };
+    let currentOutput = {};
+    while (this._currentIteration < this.maxIterations) {
+      if (context.signal?.aborted) {
+        break;
+      }
+      this.subGraph = this.cloneTemplateGraph(this._currentIteration);
+      const results = await this.subGraph.run(currentInput, {
+        parentSignal: context.signal
+      });
+      currentOutput = this.subGraph.mergeExecuteOutputsToRunOutput(results, this.compoundMerge);
+      if (!this.condition(currentOutput, this._currentIteration)) {
+        break;
+      }
+      if (this.chainIterations) {
+        currentInput = { ...currentInput, ...currentOutput };
+      }
+      this._currentIteration++;
+      const progress = Math.min(this._currentIteration / this.maxIterations * 100, 99);
+      await context.updateProgress(progress, `Iteration ${this._currentIteration}`);
+    }
+    return currentOutput;
+  }
+  cloneTemplateGraph(iteration) {
+    const clonedGraph = new TaskGraph;
+    if (!this._templateGraph) {
+      return clonedGraph;
+    }
+    const templateTasks = this._templateGraph.getTasks();
+    const templateDataflows = this._templateGraph.getDataflows();
+    const idMap = new Map;
+    for (const templateTask of templateTasks) {
+      const TaskClass = templateTask.constructor;
+      const clonedTask = new TaskClass({ ...templateTask.defaults }, {
+        ...templateTask.config,
+        id: `${templateTask.config.id}_iter${iteration}`,
+        name: `${templateTask.config.name || templateTask.type} [${iteration}]`
+      });
+      clonedGraph.addTask(clonedTask);
+      idMap.set(templateTask.config.id, clonedTask.config.id);
+    }
+    for (const templateDataflow of templateDataflows) {
+      const sourceId = idMap.get(templateDataflow.sourceTaskId);
+      const targetId = idMap.get(templateDataflow.targetTaskId);
+      if (sourceId !== undefined && targetId !== undefined) {
+        const { Dataflow: Dataflow2 } = (init_Dataflow(), __toCommonJS(exports_Dataflow));
+        const clonedDataflow = new Dataflow2(sourceId, templateDataflow.sourceTaskPortId, targetId, templateDataflow.targetTaskPortId);
+        clonedGraph.addDataflow(clonedDataflow);
+      }
+    }
+    return clonedGraph;
+  }
+  static inputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+  }
+  static outputSchema() {
+    return {
+      type: "object",
+      properties: {
+        _iterations: {
+          type: "number",
+          title: "Iterations",
+          description: "Number of iterations executed"
+        }
+      },
+      additionalProperties: true
+    };
+  }
+  outputSchema() {
+    if (!this._templateGraph) {
+      return this.constructor.outputSchema();
+    }
+    const tasks = this._templateGraph.getTasks();
+    const endingNodes = tasks.filter((task) => this._templateGraph.getTargetDataflows(task.config.id).length === 0);
+    if (endingNodes.length === 0) {
+      return this.constructor.outputSchema();
+    }
+    const properties = {
+      _iterations: {
+        type: "number",
+        title: "Iterations",
+        description: "Number of iterations executed"
+      }
+    };
+    for (const task of endingNodes) {
+      const taskOutputSchema = task.outputSchema();
+      if (typeof taskOutputSchema === "boolean")
+        continue;
+      const taskProperties = taskOutputSchema.properties || {};
+      for (const [key, schema] of Object.entries(taskProperties)) {
+        if (!properties[key]) {
+          properties[key] = schema;
+        }
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      additionalProperties: false
+    };
+  }
+}
+Workflow.prototype.while = CreateLoopWorkflow(WhileTask);
+Workflow.prototype.endWhile = CreateEndLoopWorkflow("endWhile");
 // src/task/index.ts
 var registerBaseTasks = () => {
-  const tasks = [ConditionalTask, GraphAsTask];
+  const tasks = [
+    ConditionalTask,
+    GraphAsTask,
+    ForEachTask,
+    MapTask,
+    BatchTask,
+    WhileTask,
+    ReduceTask
+  ];
   tasks.map(TaskRegistry.registerTask);
   return tasks;
 };
@@ -3027,6 +4106,7 @@ export {
   connect,
   WorkflowError,
   Workflow,
+  WhileTask,
   TaskStatus,
   TaskRegistry,
   TaskQueueRegistry,
@@ -3049,13 +4129,18 @@ export {
   Task,
   TASK_OUTPUT_REPOSITORY,
   TASK_GRAPH_REPOSITORY,
+  ReduceTask,
   PROPERTY_ARRAY,
+  MapTask,
   JobTaskFailedError,
   JobQueueTask,
   JOB_QUEUE_FACTORY,
+  IteratorTaskRunner,
+  IteratorTask,
   GraphAsTaskRunner,
   GraphAsTask,
   GRAPH_RESULT_ARRAY,
+  ForEachTask,
   EventTaskGraphToDagMapping,
   EventDagToTaskGraphMapping,
   DataflowArrow,
@@ -3063,7 +4148,10 @@ export {
   DATAFLOW_ERROR_PORT,
   DATAFLOW_ALL_PORTS,
   CreateWorkflow,
-  ConditionalTask
+  CreateLoopWorkflow,
+  CreateEndLoopWorkflow,
+  ConditionalTask,
+  BatchTask
 };
 
-//# debugId=A58A1B322B71CA9464756E2164756E21
+//# debugId=F4A17E03C9237E9864756E2164756E21