@workglow/task-graph 0.0.85 → 0.0.87

package/dist/bun.js

@@ -1,29 +1,55 @@
 // @bun
-// src/task/ArrayTask.ts
-import { uuid4 as uuid44 } from "@workglow/util";
-
-// src/task-graph/TaskGraph.ts
-import { DirectedAcyclicGraph, EventEmitter as EventEmitter5, uuid4 as uuid43 } from "@workglow/util";
-
-// src/task/GraphAsTask.ts
-import { compileSchema as compileSchema2 } from "@workglow/util";
-
-// 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;
@@ -43,14 +69,12 @@ class Dataflow {
     return Dataflow.createId(this.sourceTaskId, this.sourceTaskPortId, this.targetTaskId, this.targetTaskPortId);
   }
   value = undefined;
-  provenance = {};
   status = TaskStatus.PENDING;
   error;
   reset() {
     this.status = TaskStatus.PENDING;
     this.error = undefined;
     this.value = undefined;
-    this.provenance = {};
     this.emit("reset");
     this.emit("status", this.status);
   }
@@ -80,7 +104,7 @@ class Dataflow {
     }
     this.emit("status", this.status);
   }
-  setPortData(entireDataBlock, nodeProvenance) {
+  setPortData(entireDataBlock) {
     if (this.sourceTaskPortId === DATAFLOW_ALL_PORTS) {
       this.value = entireDataBlock;
     } else if (this.sourceTaskPortId === DATAFLOW_ERROR_PORT) {
@@ -88,17 +112,17 @@ class Dataflow {
     } else {
       this.value = entireDataBlock[this.sourceTaskPortId];
     }
-    if (nodeProvenance)
-      this.provenance = nodeProvenance;
   }
   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 {
@@ -160,23 +184,37 @@ 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 uuid44 } from "@workglow/util";
+
+// src/task/GraphAsTask.ts
+init_Dataflow();
+import { compileSchema as compileSchema2 } from "@workglow/util";
 
 // src/task-graph/TaskGraphRunner.ts
 import {
   collectPropertyValues,
   globalServiceRegistry as globalServiceRegistry2,
+  ServiceRegistry as ServiceRegistry2,
   uuid4 as uuid42
 } from "@workglow/util";
 
@@ -211,6 +249,7 @@ class TaskOutputRepository {
 }
 
 // src/task/Task.ts
+init_Dataflow();
 import {
   compileSchema,
   deepEqual,
@@ -281,13 +320,71 @@ class TaskInvalidInputError extends TaskError {
 
 // src/task/TaskRunner.ts
 import { globalServiceRegistry } from "@workglow/util";
+
+// src/task/InputResolver.ts
+import { getInputResolvers } from "@workglow/util";
+function getSchemaFormat(schema) {
+  if (typeof schema !== "object" || schema === null)
+    return;
+  const s = schema;
+  if (typeof s.format === "string")
+    return s.format;
+  const variants = s.oneOf ?? s.anyOf;
+  if (Array.isArray(variants)) {
+    for (const variant of variants) {
+      if (typeof variant === "object" && variant !== null) {
+        const v = variant;
+        if (typeof v.format === "string")
+          return v.format;
+      }
+    }
+  }
+  return;
+}
+function getFormatPrefix(format) {
+  const colonIndex = format.indexOf(":");
+  return colonIndex >= 0 ? format.substring(0, colonIndex) : format;
+}
+async function resolveSchemaInputs(input, schema, config) {
+  if (typeof schema === "boolean")
+    return input;
+  const properties = schema.properties;
+  if (!properties || typeof properties !== "object")
+    return input;
+  const resolvers = getInputResolvers();
+  const resolved = { ...input };
+  for (const [key, propSchema] of Object.entries(properties)) {
+    const value = resolved[key];
+    const format = getSchemaFormat(propSchema);
+    if (!format)
+      continue;
+    let resolver = resolvers.get(format);
+    if (!resolver) {
+      const prefix = getFormatPrefix(format);
+      resolver = resolvers.get(prefix);
+    }
+    if (!resolver)
+      continue;
+    if (typeof value === "string") {
+      resolved[key] = await resolver(value, format, config.registry);
+    } else if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+      const results = await Promise.all(value.map((item) => resolver(item, format, config.registry)));
+      resolved[key] = results.filter((result) => result !== undefined);
+    }
+  }
+  return resolved;
+}
+
+// src/task/TaskRunner.ts
+init_TaskTypes();
+
 class TaskRunner {
   running = false;
   reactiveRunning = false;
-  nodeProvenance = {};
   task;
   abortController;
   outputCache;
+  registry = globalServiceRegistry;
   constructor(task) {
     this.task = task;
     this.own = this.own.bind(this);
@@ -297,6 +394,8 @@ class TaskRunner {
     await this.handleStart(config);
     try {
       this.task.setInput(overrides);
+      const schema = this.task.constructor.inputSchema();
+      this.task.runInputData = await resolveSchemaInputs(this.task.runInputData, schema, { registry: this.registry });
       const isValid = await this.task.validateInput(this.task.runInputData);
       if (!isValid) {
         throw new TaskInvalidInputError("Invalid input data");
@@ -332,6 +431,8 @@ class TaskRunner {
       return this.task.runOutputData;
     }
     this.task.setInput(overrides);
+    const schema = this.task.constructor.inputSchema();
+    this.task.runInputData = await resolveSchemaInputs(this.task.runInputData, schema, { registry: this.registry });
     await this.handleStartReactive();
     try {
       const isValid = await this.task.validateInput(this.task.runInputData);
@@ -362,8 +463,8 @@ class TaskRunner {
     const result = await this.task.execute(input, {
       signal: this.abortController.signal,
       updateProgress: this.handleProgress.bind(this),
-      nodeProvenance: this.nodeProvenance,
-      own: this.own
+      own: this.own,
+      registry: this.registry
     });
     return await this.executeTaskReactive(input, result || {});
   }
@@ -374,7 +475,6 @@ class TaskRunner {
   async handleStart(config = {}) {
     if (this.task.status === TaskStatus.PROCESSING)
       return;
-    this.nodeProvenance = {};
     this.running = true;
     this.task.startedAt = new Date;
     this.task.progress = 0;
@@ -383,7 +483,6 @@ class TaskRunner {
     this.abortController.signal.addEventListener("abort", () => {
       this.handleAbort();
     });
-    this.nodeProvenance = config.nodeProvenance ?? {};
     const cache = this.task.config.outputCache ?? config.outputCache;
     if (cache === true) {
       let instance = globalServiceRegistry.get(TASK_OUTPUT_REPOSITORY);
@@ -396,6 +495,9 @@ class TaskRunner {
     if (config.updateProgress) {
       this.updateProgress = config.updateProgress;
     }
+    if (config.registry) {
+      this.registry = config.registry;
+    }
     this.task.emit("start");
     this.task.emit("status", this.task.status);
   }
@@ -422,7 +524,6 @@ class TaskRunner {
     this.task.progress = 100;
     this.task.status = TaskStatus.COMPLETED;
     this.abortController = undefined;
-    this.nodeProvenance = {};
     this.task.emit("complete");
     this.task.emit("status", this.task.status);
   }
@@ -436,7 +537,6 @@ class TaskRunner {
     this.task.progress = 100;
     this.task.completedAt = new Date;
     this.abortController = undefined;
-    this.nodeProvenance = {};
     this.task.emit("disabled");
     this.task.emit("status", this.task.status);
   }
@@ -456,7 +556,6 @@ class TaskRunner {
     this.task.status = TaskStatus.FAILED;
     this.task.error = err instanceof TaskError ? err : new TaskFailedError(err?.message || "Task failed");
     this.abortController = undefined;
-    this.nodeProvenance = {};
     this.task.emit("error", this.task.error);
     this.task.emit("status", this.task.status);
   }
@@ -471,6 +570,8 @@ class TaskRunner {
 }
 
 // src/task/Task.ts
+init_TaskTypes();
+
 class Task {
   static type = "Task";
   static category = "Hidden";
@@ -554,7 +655,6 @@ class Task {
     return this._events;
   }
   _events;
-  nodeProvenance = {};
   constructor(callerDefaultInputs = {}, config = {}) {
     const inputDefaults = this.getDefaultInputsFromStaticInputDefinitions();
     const mergedDefaults = Object.assign(inputDefaults, callerDefaultInputs);
@@ -591,10 +691,45 @@ class Task {
     }
   }
   resetInputData() {
+    this.runInputData = this.smartClone(this.defaults);
+  }
+  smartClone(obj, visited = new WeakSet) {
+    if (obj === null || obj === undefined) {
+      return obj;
+    }
+    if (typeof obj !== "object") {
+      return obj;
+    }
+    if (visited.has(obj)) {
+      throw new Error("Circular reference detected in input data. " + "Cannot clone objects with circular references.");
+    }
+    if (ArrayBuffer.isView(obj)) {
+      if (typeof DataView !== "undefined" && obj instanceof DataView) {
+        return obj;
+      }
+      const typedArray = obj;
+      return new typedArray.constructor(typedArray);
+    }
+    if (!Array.isArray(obj)) {
+      const proto = Object.getPrototypeOf(obj);
+      if (proto !== Object.prototype && proto !== null) {
+        return obj;
+      }
+    }
+    visited.add(obj);
     try {
-      this.runInputData = structuredClone(this.defaults);
-    } catch (err) {
-      this.runInputData = JSON.parse(JSON.stringify(this.defaults));
+      if (Array.isArray(obj)) {
+        return obj.map((item) => this.smartClone(item, visited));
+      }
+      const result = {};
+      for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          result[key] = this.smartClone(obj[key], visited);
+        }
+      }
+      return result;
+    } finally {
+      visited.delete(obj);
     }
   }
   setDefaults(defaults) {
@@ -622,7 +757,7 @@ class Task {
     }
     if (schema.additionalProperties === true) {
       for (const [inputId, value] of Object.entries(input)) {
-        if (value !== undefined && !(inputId in properties)) {
+        if (!(inputId in properties)) {
           this.runInputData[inputId] = value;
         }
       }
@@ -675,7 +810,7 @@ class Task {
     }
     if (inputSchema.additionalProperties === true) {
       for (const [inputId, value] of Object.entries(overrides)) {
-        if (value !== undefined && !(inputId in properties)) {
+        if (!(inputId in properties)) {
           if (!deepEqual(this.runInputData[inputId], value)) {
             this.runInputData[inputId] = value;
             changed = true;
@@ -685,7 +820,7 @@ class Task {
     }
     return changed;
   }
-  async narrowInput(input) {
+  async narrowInput(input, _registry) {
     return input;
   }
   subscribe(name, fn) {
@@ -745,20 +880,20 @@ class Task {
         const path = e.data.pointer || "";
         return `${e.message}${path ? ` (${path})` : ""}`;
       });
-      throw new TaskInvalidInputError(`Input ${JSON.stringify(input)} does not match schema: ${errorMessages.join(", ")}`);
+      throw new TaskInvalidInputError(`Input ${JSON.stringify(Object.keys(input))} does not match schema: ${errorMessages.join(", ")}`);
     }
     return true;
   }
   id() {
     return this.config.id;
   }
-  getProvenance() {
-    return this.config.provenance ?? {};
-  }
   stripSymbols(obj) {
     if (obj === null || obj === undefined) {
       return obj;
     }
+    if (ArrayBuffer.isView(obj)) {
+      return obj;
+    }
     if (Array.isArray(obj)) {
       return obj.map((item) => this.stripSymbols(item));
     }
@@ -774,14 +909,12 @@ class Task {
     return obj;
   }
   toJSON() {
-    const provenance = this.getProvenance();
     const extras = this.config.extras;
     let json = this.stripSymbols({
       id: this.config.id,
       type: this.type,
       ...this.config.name ? { name: this.config.name } : {},
       defaults: this.defaults,
-      ...Object.keys(provenance).length ? { provenance } : {},
       ...extras && Object.keys(extras).length ? { extras } : {}
     });
     return json;
@@ -827,8 +960,9 @@ class Task {
 // src/task/ConditionalTask.ts
 class ConditionalTask extends Task {
   static type = "ConditionalTask";
-  static category = "Flow Control";
+  static category = "Hidden";
   static title = "Conditional Task";
+  static description = "Evaluates conditions to determine which dataflows are active";
   static hasDynamicSchemas = true;
   activeBranches = new Set;
   async execute(input, context) {
@@ -936,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;
@@ -1053,9 +1193,9 @@ class TaskGraphRunner {
   reactiveScheduler;
   running = false;
   reactiveRunning = false;
-  provenanceInput;
   graph;
   outputCache;
+  registry = globalServiceRegistry2;
   abortController;
   inProgressTasks = new Map;
   inProgressFunctions = new Map;
@@ -1064,7 +1204,6 @@ class TaskGraphRunner {
     this.processScheduler = processScheduler;
     this.reactiveScheduler = reactiveScheduler;
     this.graph = graph;
-    this.provenanceInput = new Map;
     graph.outputCache = outputCache;
     this.handleProgress = this.handleProgress.bind(this);
   }
@@ -1084,7 +1223,7 @@ class TaskGraphRunner {
         const runAsync = async () => {
           try {
             const taskInput = isRootTask ? input : this.filterInputForTask(task, input);
-            const taskPromise = this.runTaskWithProvenance(task, taskInput, config?.parentProvenance || {});
+            const taskPromise = this.runTask(task, taskInput);
             this.inProgressTasks.set(task.config.id, taskPromise);
             const taskResult = await taskPromise;
             if (this.graph.getTargetDataflows(task.config.id).length === 0) {
@@ -1194,23 +1333,16 @@ class TaskGraphRunner {
       this.addInputData(task, dataflow.getPortData());
     }
   }
-  getInputProvenance(node) {
-    const nodeProvenance = {};
-    this.graph.getSourceDataflows(node.config.id).forEach((dataflow) => {
-      Object.assign(nodeProvenance, dataflow.provenance);
-    });
-    return nodeProvenance;
-  }
-  async pushOutputFromNodeToEdges(node, results, nodeProvenance) {
+  async pushOutputFromNodeToEdges(node, results) {
     const dataflows = this.graph.getTargetDataflows(node.config.id);
     for (const dataflow of dataflows) {
       const compatibility = dataflow.semanticallyCompatible(this.graph, dataflow);
       if (compatibility === "static") {
-        dataflow.setPortData(results, nodeProvenance);
+        dataflow.setPortData(results);
       } else if (compatibility === "runtime") {
         const task = this.graph.getTask(dataflow.targetTaskId);
-        const narrowed = await task.narrowInput({ ...results });
-        dataflow.setPortData(narrowed, nodeProvenance);
+        const narrowed = await task.narrowInput({ ...results }, this.registry);
+        dataflow.setPortData(narrowed);
       } else {}
     }
   }
@@ -1280,20 +1412,14 @@ class TaskGraphRunner {
       }
     }
   }
-  async runTaskWithProvenance(task, input, parentProvenance) {
-    const nodeProvenance = {
-      ...parentProvenance,
-      ...this.getInputProvenance(task),
-      ...task.getProvenance()
-    };
-    this.provenanceInput.set(task.config.id, nodeProvenance);
+  async runTask(task, input) {
     this.copyInputFromEdgesToNode(task);
     const results = await task.runner.run(input, {
-      nodeProvenance,
       outputCache: this.outputCache,
-      updateProgress: async (task2, progress, message, ...args) => await this.handleProgress(task2, progress, message, ...args)
+      updateProgress: async (task2, progress, message, ...args) => await this.handleProgress(task2, progress, message, ...args),
+      registry: this.registry
     });
-    await this.pushOutputFromNodeToEdges(task, results, nodeProvenance);
+    await this.pushOutputFromNodeToEdges(task, results);
     return {
       id: task.config.id,
       type: task.constructor.runtype || task.constructor.type,
@@ -1327,10 +1453,15 @@ class TaskGraphRunner {
     });
   }
   async handleStart(config) {
+    if (config?.registry !== undefined) {
+      this.registry = config.registry;
+    } else {
+      this.registry = new ServiceRegistry2(globalServiceRegistry2.container.createChildContainer());
+    }
     if (config?.outputCache !== undefined) {
       if (typeof config.outputCache === "boolean") {
         if (config.outputCache === true) {
-          this.outputCache = globalServiceRegistry2.get(TASK_OUTPUT_REPOSITORY);
+          this.outputCache = this.registry.get(TASK_OUTPUT_REPOSITORY);
         } else {
           this.outputCache = undefined;
         }
@@ -1416,7 +1547,7 @@ class TaskGraphRunner {
       progress = Math.round(completed / total);
     }
     this.pushStatusFromNodeToEdges(this.graph, task);
-    await this.pushOutputFromNodeToEdges(task, task.runOutputData, task.getProvenance());
+    await this.pushOutputFromNodeToEdges(task, task.runOutputData);
     this.graph.emit("graph_progress", progress, message, args);
   }
 }
@@ -1428,7 +1559,6 @@ class GraphAsTaskRunner extends TaskRunner {
       this.task.emit("progress", progress, message, ...args);
     });
     const results = await this.task.subGraph.run(input, {
-      parentProvenance: this.nodeProvenance || {},
       parentSignal: this.abortController?.signal,
       outputCache: this.outputCache
     });
@@ -1444,27 +1574,12 @@ class GraphAsTaskRunner extends TaskRunner {
     }
     super.handleDisable();
   }
-  fixInput(input) {
-    const inputSchema = this.task.inputSchema();
-    if (typeof inputSchema === "boolean") {
-      return input;
-    }
-    const flattenedInput = Object.entries(input).reduce((acc, [key, value]) => {
-      const inputDef = inputSchema.properties?.[key];
-      const shouldFlatten = Array.isArray(value) && typeof inputDef === "object" && inputDef !== null && "x-replicate" in inputDef && inputDef["x-replicate"] === true;
-      if (shouldFlatten) {
-        return { ...acc, [key]: value[0] };
-      }
-      return { ...acc, [key]: value };
-    }, {});
-    return flattenedInput;
-  }
   async executeTask(input) {
     if (this.task.hasChildren()) {
       const runExecuteOutputData = await this.executeTaskChildren(input);
       this.task.runOutputData = this.task.subGraph.mergeExecuteOutputsToRunOutput(runExecuteOutputData, this.task.compoundMerge);
     } else {
-      const result = await super.executeTask(this.fixInput(input));
+      const result = await super.executeTask(input);
       this.task.runOutputData = result ?? {};
     }
     return this.task.runOutputData;
@@ -1474,7 +1589,7 @@ class GraphAsTaskRunner extends TaskRunner {
       const reactiveResults = await this.executeTaskChildrenReactive();
       this.task.runOutputData = this.task.subGraph.mergeExecuteOutputsToRunOutput(reactiveResults, this.task.compoundMerge);
     } else {
-      const reactiveResults = await super.executeTaskReactive(this.fixInput(input), output);
+      const reactiveResults = await super.executeTaskReactive(input, output);
       this.task.runOutputData = Object.assign({}, output, reactiveResults ?? {});
     }
     return this.task.runOutputData;
@@ -1484,6 +1599,8 @@ class GraphAsTaskRunner extends TaskRunner {
 // src/task/GraphAsTask.ts
 class GraphAsTask extends Task {
   static type = "GraphAsTask";
+  static title = "Graph as Task";
+  static description = "A task that contains a subgraph of tasks";
   static category = "Hidden";
   static compoundMerge = PROPERTY_ARRAY;
   static hasDynamicSchemas = true;
@@ -1663,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();
@@ -1706,42 +1858,26 @@ 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 === "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;
-        };
-        makeMatch(([fromOutputPortId, fromPortOutputSchema], [toInputPortId, toPortInputSchema]) => {
-          if (typeof fromPortOutputSchema === "boolean" || typeof toPortInputSchema === "boolean") {
-            if (fromPortOutputSchema === true && toPortInputSchema === true) {
-              return true;
-            }
-            return false;
-          }
-          const idTypeMatch = fromPortOutputSchema.$id !== undefined && fromPortOutputSchema.$id === toPortInputSchema.$id;
-          const idTypeBlank = fromPortOutputSchema.$id === undefined && toPortInputSchema.$id === undefined;
-          const typeMatch = idTypeBlank && (fromPortOutputSchema.type === toPortInputSchema.type || (toPortInputSchema.oneOf?.some((i) => i.type == fromPortOutputSchema.type) ?? false));
-          const outputPortIdMatch = fromOutputPortId === toInputPortId;
-          const outputPortIdOutputInput = fromOutputPortId === "output" && toInputPortId === "input";
-          const portIdsCompatible = outputPortIdMatch || outputPortIdOutputInput;
-          return (idTypeMatch || typeMatch) && portIdsCompatible;
+        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 providedInputKeys = new Set(Object.keys(input || {}));
+        const result = Workflow.autoConnect(this.graph, parent, task, {
+          providedInputKeys,
+          earlierTasks
         });
-        if (matches.size === 0) {
-          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.`;
-          console.error(this._error);
-          this.graph.removeTask(task.config.id);
+        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);
+          }
         }
       }
       return this;
@@ -1781,13 +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,
-        parentProvenance: {},
-        outputCache: this._repository
+        outputCache: this._outputCache
       });
       const results = this.graph.mergeExecuteOutputsToRunOutput(output, PROPERTY_ARRAY);
       this.events.emit("complete");
@@ -1800,6 +1939,9 @@ class Workflow {
     }
   }
   async abort() {
+    if (this._parentWorkflow) {
+      return this._parentWorkflow.abort();
+    }
     this._abortController?.abort();
   }
   pop() {
@@ -1868,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 = "";
@@ -1918,22 +2062,202 @@ class Workflow {
       if (targetSchema === false) {
         throw new WorkflowError(`Target task has schema 'false' and accepts no inputs`);
       }
-    } else if (!targetSchema.properties?.[targetTaskPortId]) {
+      if (targetSchema === true) {}
+    } else if (targetSchema.additionalProperties === true) {} else if (!targetSchema.properties?.[targetTaskPortId]) {
       throw new WorkflowError(`Input ${targetTaskPortId} not found on target task`);
     }
     const dataflow = new Dataflow(sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId);
     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
@@ -2056,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",
@@ -2098,7 +2425,6 @@ class TaskGraph {
   run(input = {}, config = {}) {
     return this.runner.runGraph(input, {
       outputCache: config?.outputCache || this.outputCache,
-      parentProvenance: config?.parentProvenance || {},
       parentSignal: config?.parentSignal || undefined
     });
   }
@@ -2174,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());
@@ -2339,117 +2665,456 @@ function serialGraph(tasks, inputHandle, outputHandle) {
   graph.addDataflows(serialGraphEdges(tasks, inputHandle, outputHandle));
   return graph;
 }
+// src/task/IteratorTaskRunner.ts
+import { Job, JobQueueClient, JobQueueServer } from "@workglow/job-queue";
+import { InMemoryQueueStorage } from "@workglow/storage";
+import { uuid4 as uuid45 } from "@workglow/util";
 
-// src/task/ArrayTask.ts
-class ArrayTask extends GraphAsTask {
-  static type = "ArrayTask";
-  static compoundMerge = PROPERTY_ARRAY;
-  inputSchema() {
-    return this.constructor.inputSchema();
-  }
-  outputSchema() {
-    return this.constructor.outputSchema();
-  }
-  regenerateGraph() {
-    const arrayInputs = new Map;
-    let hasArrayInputs = false;
-    const inputSchema = this.inputSchema();
-    if (typeof inputSchema !== "boolean") {
-      const keys = Object.keys(inputSchema.properties || {});
-      for (const inputId of keys) {
-        const inputValue = this.runInputData[inputId];
-        const inputDef = inputSchema.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;
+// src/task/TaskQueueRegistry.ts
+var taskQueueRegistry = null;
+
+class TaskQueueRegistry {
+  queues = new Map;
+  registerQueue(queue) {
+    const queueName = queue.server.queueName;
+    if (this.queues.has(queueName)) {
+      throw new Error(`Queue with name ${queueName} already exists`);
     }
-    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}_${uuid44()}` });
-      return task;
-    });
-    this.subGraph.addTasks(tasks);
-    super.regenerateGraph();
+    this.queues.set(queueName, queue);
   }
-  generateCombinations(input, inputMakeArray) {
-    const arraysToCombine = inputMakeArray.map((key) => Array.isArray(input[key]) ? input[key] : []);
-    const indices = arraysToCombine.map(() => 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;
+  getQueue(queueName) {
+    return this.queues.get(queueName);
   }
-  toJSON() {
-    const { subgraph, ...result } = super.toJSON();
-    return result;
+  startQueues() {
+    for (const queue of this.queues.values()) {
+      queue.server.start();
+    }
+    return this;
   }
-  toDependencyJSON() {
-    const { subtasks, ...result } = super.toDependencyJSON();
-    return result;
+  stopQueues() {
+    for (const queue of this.queues.values()) {
+      queue.server.stop();
+    }
+    return this;
   }
-  get runner() {
-    if (!this._runner) {
-      this._runner = new ArrayTaskRunner(this);
+  clearQueues() {
+    for (const queue of this.queues.values()) {
+      queue.storage.deleteAll();
     }
-    return this._runner;
+    return this;
   }
 }
-
-class ArrayTaskRunner extends GraphAsTaskRunner {
-  async executeTaskChildren(_input) {
-    return super.executeTaskChildren({});
+function getTaskQueueRegistry() {
+  if (!taskQueueRegistry) {
+    taskQueueRegistry = new TaskQueueRegistry;
   }
-  async executeTaskReactive(input, output) {
-    const reactiveResults = await super.executeTaskReactive(input, output);
-    if (this.task.hasChildren()) {
-      return reactiveResults;
-    } else {
-      this.task.runOutputData = Object.assign({}, output, reactiveResults ?? {});
-      return this.task.runOutputData;
-    }
+  return taskQueueRegistry;
+}
+function setTaskQueueRegistry(registry) {
+  if (taskQueueRegistry) {
+    taskQueueRegistry.stopQueues();
+    taskQueueRegistry.clearQueues();
   }
+  taskQueueRegistry = registry;
 }
-// src/task/InputTask.ts
-import { Task as Task2 } from "@workglow/task-graph";
 
-class InputTask extends Task2 {
-  static type = "InputTask";
-  static category = "Flow Control";
-  static title = "Input";
-  static description = "Starts the workflow";
-  static hasDynamicSchemas = true;
-  static cacheable = false;
-  static inputSchema() {
-    return {
+// 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 {
+      getTaskQueueRegistry().registerQueue(queue);
+    } catch (err) {
+      const existing = getTaskQueueRegistry().getQueue(queueName);
+      if (existing) {
+        return existing;
+      }
+      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
@@ -2462,25 +3127,161 @@ class InputTask extends Task2 {
       additionalProperties: true
     };
   }
-  inputSchema() {
-    return this.config?.extras?.inputSchema ?? this.constructor.inputSchema();
+  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() {
-    return this.config?.extras?.outputSchema ?? this.constructor.outputSchema();
+    if (!this.hasChildren() && !this._templateGraph) {
+      return this.constructor.outputSchema();
+    }
+    return this.getWrappedOutputSchema();
   }
-  async execute(input, _context) {
-    return input;
+  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;
   }
-  async executeReactive(input, _output, _context) {
-    return input;
+  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,
-  JobQueueServer
+  JobQueueClient as JobQueueClient2,
+  JobQueueServer as JobQueueServer2
 } from "@workglow/job-queue";
-import { InMemoryQueueStorage } from "@workglow/storage";
+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 ({
@@ -2488,9 +3289,9 @@ var defaultJobQueueFactory = async ({
   jobClass,
   options
 }) => {
-  const storage = options?.storage ?? new InMemoryQueueStorage(queueName);
+  const storage = options?.storage ?? new InMemoryQueueStorage2(queueName);
   await storage.setupDatabase();
-  const server = new JobQueueServer(jobClass, {
+  const server = new JobQueueServer2(jobClass, {
     storage,
     queueName,
     limiter: options?.limiter,
@@ -2501,7 +3302,7 @@ var defaultJobQueueFactory = async ({
     deleteAfterDisabledMs: options?.deleteAfterDisabledMs,
     cleanupIntervalMs: options?.cleanupIntervalMs
   });
-  const client = new JobQueueClient({
+  const client = new JobQueueClient2({
     storage,
     queueName
   });
@@ -2521,9 +3322,9 @@ function createJobQueueFactoryWithOptions(defaultOptions = {}) {
       ...defaultOptions,
       ...options ?? {}
     };
-    const storage = mergedOptions.storage ?? new InMemoryQueueStorage(queueName);
+    const storage = mergedOptions.storage ?? new InMemoryQueueStorage2(queueName);
     await storage.setupDatabase();
-    const server = new JobQueueServer(jobClass, {
+    const server = new JobQueueServer2(jobClass, {
       storage,
       queueName,
       limiter: mergedOptions.limiter,
@@ -2534,7 +3335,7 @@ function createJobQueueFactoryWithOptions(defaultOptions = {}) {
       deleteAfterDisabledMs: mergedOptions.deleteAfterDisabledMs,
       cleanupIntervalMs: mergedOptions.cleanupIntervalMs
     });
-    const client = new JobQueueClient({
+    const client = new JobQueueClient2({
       storage,
       queueName
     });
@@ -2552,58 +3353,8 @@ if (!globalServiceRegistry3.has(JOB_QUEUE_FACTORY)) {
   registerJobQueueFactory(defaultJobQueueFactory);
 }
 // src/task/JobQueueTask.ts
-import { Job as Job2 } from "@workglow/job-queue";
-
-// src/task/TaskQueueRegistry.ts
-var taskQueueRegistry = null;
-
-class TaskQueueRegistry {
-  queues = new Map;
-  registerQueue(queue) {
-    const queueName = queue.server.queueName;
-    if (this.queues.has(queueName)) {
-      throw new Error(`Queue with name ${queueName} already exists`);
-    }
-    this.queues.set(queueName, queue);
-  }
-  getQueue(queueName) {
-    return this.queues.get(queueName);
-  }
-  startQueues() {
-    for (const queue of this.queues.values()) {
-      queue.server.start();
-    }
-    return this;
-  }
-  stopQueues() {
-    for (const queue of this.queues.values()) {
-      queue.server.stop();
-    }
-    return this;
-  }
-  clearQueues() {
-    for (const queue of this.queues.values()) {
-      queue.storage.deleteAll();
-    }
-    return this;
-  }
-}
-function getTaskQueueRegistry() {
-  if (!taskQueueRegistry) {
-    taskQueueRegistry = new TaskQueueRegistry;
-  }
-  return taskQueueRegistry;
-}
-function setTaskQueueRegistry(registry) {
-  if (taskQueueRegistry) {
-    taskQueueRegistry.stopQueues();
-    taskQueueRegistry.clearQueues();
-  }
-  taskQueueRegistry = registry;
-}
-
-// src/task/JobQueueTask.ts
-class JobQueueTask extends ArrayTask {
+import { Job as Job3 } from "@workglow/job-queue";
+class JobQueueTask extends GraphAsTask {
   static type = "JobQueueTask";
   static canRunDirectly = true;
   currentQueueName;
@@ -2613,7 +3364,7 @@ class JobQueueTask extends ArrayTask {
   constructor(input = {}, config = {}) {
     config.queue ??= true;
     super(input, config);
-    this.jobClass = Job2;
+    this.jobClass = Job3;
   }
   async execute(input, executeContext) {
     let cleanup = () => {};
@@ -2735,16 +3486,13 @@ class JobQueueTask extends ArrayTask {
     super.abort();
   }
 }
-// src/task/OutputTask.ts
-import { Task as Task3 } from "@workglow/task-graph";
-
-class OutputTask extends Task3 {
-  static type = "OutputTask";
+// src/task/MapTask.ts
+class MapTask extends IteratorTask {
+  static type = "MapTask";
   static category = "Flow Control";
-  static title = "Output";
-  static description = "Ends the workflow";
-  static hasDynamicSchemas = true;
-  static cacheable = false;
+  static title = "Map";
+  static description = "Transforms an array by running a workflow for each element";
+  static compoundMerge = PROPERTY_ARRAY;
   static inputSchema() {
     return {
       type: "object",
@@ -2759,19 +3507,198 @@ class OutputTask extends Task3 {
       additionalProperties: true
     };
   }
-  inputSchema() {
-    return this.config?.extras?.inputSchema ?? this.constructor.inputSchema();
+  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() {
-    return this.config?.extras?.outputSchema ?? this.constructor.outputSchema();
+    if (!this.hasChildren() && !this._templateGraph) {
+      return this.constructor.outputSchema();
+    }
+    return this.getWrappedOutputSchema();
   }
-  async execute(input, _context) {
-    return input;
+  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;
   }
-  async executeReactive(input, _output, _context) {
-    return input;
+}
+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) {
@@ -2789,17 +3716,14 @@ var createSingleTaskFromJSON = (item) => {
     throw new TaskJSONError("Task id required");
   if (!item.type)
     throw new TaskJSONError("Task type required");
-  if (item.defaults && (Array.isArray(item.defaults) || Array.isArray(item.provenance)))
+  if (item.defaults && Array.isArray(item.defaults))
     throw new TaskJSONError("Task defaults must be an object");
-  if (item.provenance && (Array.isArray(item.provenance) || typeof item.provenance !== "object"))
-    throw new TaskJSONError("Task provenance must be an object");
   const taskClass = TaskRegistry.all.get(item.type);
   if (!taskClass)
     throw new TaskJSONError(`Task type ${item.type} not found, perhaps not registered?`);
   const taskConfig = {
     id: item.id,
     name: item.name,
-    provenance: item.provenance ?? {},
     extras: item.extras
   };
   const task = new taskClass(item.defaults ?? {}, taskConfig);
@@ -2842,6 +3766,170 @@ 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,
+    ForEachTask,
+    MapTask,
+    BatchTask,
+    WhileTask,
+    ReduceTask
+  ];
+  tasks.map(TaskRegistry.registerTask);
+  return tasks;
+};
 // src/storage/TaskGraphRepository.ts
 import { createServiceToken as createServiceToken3, EventEmitter as EventEmitter6 } from "@workglow/util";
 var TASK_GRAPH_REPOSITORY = createServiceToken3("taskgraph.taskGraphRepository");
@@ -3001,7 +4089,9 @@ class TaskOutputTabularRepository extends TaskOutputRepository {
 export {
   setTaskQueueRegistry,
   serialGraph,
+  resolveSchemaInputs,
   registerJobQueueFactory,
+  registerBaseTasks,
   pipe,
   parallel,
   getTaskQueueRegistry,
@@ -3016,6 +4106,7 @@ export {
   connect,
   WorkflowError,
   Workflow,
+  WhileTask,
   TaskStatus,
   TaskRegistry,
   TaskQueueRegistry,
@@ -3038,15 +4129,18 @@ export {
   Task,
   TASK_OUTPUT_REPOSITORY,
   TASK_GRAPH_REPOSITORY,
+  ReduceTask,
   PROPERTY_ARRAY,
-  OutputTask,
+  MapTask,
   JobTaskFailedError,
   JobQueueTask,
   JOB_QUEUE_FACTORY,
-  InputTask,
+  IteratorTaskRunner,
+  IteratorTask,
   GraphAsTaskRunner,
   GraphAsTask,
   GRAPH_RESULT_ARRAY,
+  ForEachTask,
   EventTaskGraphToDagMapping,
   EventDagToTaskGraphMapping,
   DataflowArrow,
@@ -3054,8 +4148,10 @@ export {
   DATAFLOW_ERROR_PORT,
   DATAFLOW_ALL_PORTS,
   CreateWorkflow,
+  CreateLoopWorkflow,
+  CreateEndLoopWorkflow,
   ConditionalTask,
-  ArrayTask
+  BatchTask
 };
 
-//# debugId=B04A540E23B60ABE64756E2164756E21
+//# debugId=F4A17E03C9237E9864756E2164756E21