@workglow/task-graph 0.0.88 → 0.0.90

package/dist/bun.js

@@ -162,7 +162,7 @@ class DataflowArrow extends 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
 import { compileSchema as compileSchema2 } from "@workglow/util";
@@ -205,6 +205,73 @@ class TaskOutputRepository {
   }
 }
 
+// src/task/ConditionUtils.ts
+function evaluateCondition(fieldValue, operator, compareValue) {
+  if (fieldValue === null || fieldValue === undefined) {
+    switch (operator) {
+      case "is_empty":
+        return true;
+      case "is_not_empty":
+        return false;
+      case "is_true":
+        return false;
+      case "is_false":
+        return true;
+      default:
+        return false;
+    }
+  }
+  const strValue = String(fieldValue);
+  const numValue = Number(fieldValue);
+  switch (operator) {
+    case "equals":
+      if (!isNaN(numValue) && !isNaN(Number(compareValue))) {
+        return numValue === Number(compareValue);
+      }
+      return strValue === compareValue;
+    case "not_equals":
+      if (!isNaN(numValue) && !isNaN(Number(compareValue))) {
+        return numValue !== Number(compareValue);
+      }
+      return strValue !== compareValue;
+    case "greater_than":
+      return numValue > Number(compareValue);
+    case "greater_or_equal":
+      return numValue >= Number(compareValue);
+    case "less_than":
+      return numValue < Number(compareValue);
+    case "less_or_equal":
+      return numValue <= Number(compareValue);
+    case "contains":
+      return strValue.toLowerCase().includes(compareValue.toLowerCase());
+    case "starts_with":
+      return strValue.toLowerCase().startsWith(compareValue.toLowerCase());
+    case "ends_with":
+      return strValue.toLowerCase().endsWith(compareValue.toLowerCase());
+    case "is_empty":
+      return strValue === "" || Array.isArray(fieldValue) && fieldValue.length === 0;
+    case "is_not_empty":
+      return strValue !== "" && !(Array.isArray(fieldValue) && fieldValue.length === 0);
+    case "is_true":
+      return Boolean(fieldValue) === true;
+    case "is_false":
+      return Boolean(fieldValue) === false;
+    default:
+      return false;
+  }
+}
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== "object") {
+      return;
+    }
+    current = current[part];
+  }
+  return current;
+}
+
 // src/task/Task.ts
 import {
   compileSchema,
@@ -544,13 +611,13 @@ class Task {
       additionalProperties: false
     };
   }
-  async execute(input, context) {
+  async execute(_input, context) {
     if (context.signal?.aborted) {
       throw new TaskAbortedError("Task aborted");
     }
     return;
   }
-  async executeReactive(input, output, context) {
+  async executeReactive(_input, output, _context) {
     return output;
   }
   _runner;
@@ -912,18 +979,62 @@ class Task {
 // src/task/ConditionalTask.ts
 class ConditionalTask extends Task {
   static type = "ConditionalTask";
-  static category = "Hidden";
-  static title = "Conditional Task";
-  static description = "Evaluates conditions to determine which dataflows are active";
+  static category = "Flow Control";
+  static title = "Condition";
+  static description = "Route data based on conditions";
   static hasDynamicSchemas = true;
   activeBranches = new Set;
+  buildBranchesFromConditionConfig(conditionConfig) {
+    if (!conditionConfig?.branches || conditionConfig.branches.length === 0) {
+      return [
+        {
+          id: "default",
+          condition: () => true,
+          outputPort: "1"
+        }
+      ];
+    }
+    return conditionConfig.branches.map((branch, index) => ({
+      id: branch.id,
+      outputPort: String(index + 1),
+      condition: (inputData) => {
+        const fieldValue = getNestedValue(inputData, branch.field);
+        return evaluateCondition(fieldValue, branch.operator, branch.value);
+      }
+    }));
+  }
+  resolveBranches(input) {
+    const configBranches = this.config.branches ?? [];
+    if (configBranches.length > 0 && typeof configBranches[0].condition === "function") {
+      return {
+        branches: configBranches,
+        isExclusive: this.config.exclusive ?? true,
+        defaultBranch: this.config.defaultBranch,
+        fromConditionConfig: false
+      };
+    }
+    const conditionConfig = input.conditionConfig ?? this.config.extras?.conditionConfig;
+    if (conditionConfig) {
+      return {
+        branches: this.buildBranchesFromConditionConfig(conditionConfig),
+        isExclusive: conditionConfig.exclusive ?? true,
+        defaultBranch: conditionConfig.defaultBranch,
+        fromConditionConfig: true
+      };
+    }
+    return {
+      branches: configBranches,
+      isExclusive: this.config.exclusive ?? true,
+      defaultBranch: this.config.defaultBranch,
+      fromConditionConfig: false
+    };
+  }
   async execute(input, context) {
     if (context.signal?.aborted) {
       return;
     }
     this.activeBranches.clear();
-    const branches = this.config.branches ?? [];
-    const isExclusive = this.config.exclusive ?? true;
+    const { branches, isExclusive, defaultBranch, fromConditionConfig } = this.resolveBranches(input);
     for (const branch of branches) {
       try {
         const isActive = branch.condition(input);
@@ -937,14 +1048,50 @@ class ConditionalTask extends Task {
         console.warn(`Condition evaluation failed for branch "${branch.id}":`, error);
       }
     }
-    if (this.activeBranches.size === 0 && this.config.defaultBranch) {
-      const defaultBranchExists = branches.some((b) => b.id === this.config.defaultBranch);
+    if (this.activeBranches.size === 0 && defaultBranch) {
+      const defaultBranchExists = branches.some((b) => b.id === defaultBranch);
       if (defaultBranchExists) {
-        this.activeBranches.add(this.config.defaultBranch);
+        this.activeBranches.add(defaultBranch);
       }
     }
+    if (fromConditionConfig) {
+      return this.buildConditionConfigOutput(input, branches, isExclusive);
+    }
     return this.buildOutput(input);
   }
+  buildConditionConfigOutput(input, branches, isExclusive) {
+    const output = {};
+    const { conditionConfig, ...passThrough } = input;
+    const inputKeys = Object.keys(passThrough);
+    let matchedBranchNumber = null;
+    for (let i = 0;i < branches.length; i++) {
+      if (this.activeBranches.has(branches[i].id)) {
+        if (matchedBranchNumber === null) {
+          matchedBranchNumber = i + 1;
+        }
+      }
+    }
+    if (isExclusive) {
+      if (matchedBranchNumber !== null) {
+        for (const key of inputKeys) {
+          output[`${key}_${matchedBranchNumber}`] = passThrough[key];
+        }
+      } else {
+        for (const key of inputKeys) {
+          output[`${key}_else`] = passThrough[key];
+        }
+      }
+    } else {
+      for (let i = 0;i < branches.length; i++) {
+        if (this.activeBranches.has(branches[i].id)) {
+          for (const key of inputKeys) {
+            output[`${key}_${i + 1}`] = passThrough[key];
+          }
+        }
+      }
+    }
+    return output;
+  }
   buildOutput(input) {
     const output = {
       _activeBranches: Array.from(this.activeBranches)
@@ -1202,16 +1349,18 @@ class TaskGraphRunner {
     await this.handleComplete();
     return results;
   }
-  async runGraphReactive() {
+  async runGraphReactive(input = {}) {
     await this.handleStartReactive();
     const results = [];
     try {
       for await (const task of this.reactiveScheduler.tasks()) {
+        const isRootTask = this.graph.getSourceDataflows(task.config.id).length === 0;
         if (task.status === TaskStatus.PENDING) {
           task.resetInputData();
           this.copyInputFromEdgesToNode(task);
         }
-        const taskResult = await task.runReactive();
+        const taskInput = isRootTask ? input : {};
+        const taskResult = await task.runReactive(taskInput);
         await this.pushOutputFromNodeToEdges(task, taskResult);
         if (this.graph.getTargetDataflows(task.config.id).length === 0) {
           results.push({
@@ -1512,7 +1661,7 @@ class GraphAsTaskRunner extends TaskRunner {
     return results;
   }
   async executeTaskChildrenReactive() {
-    return this.task.subGraph.runReactive();
+    return this.task.subGraph.runReactive(this.task.runInputData);
   }
   async handleDisable() {
     if (this.task.hasChildren()) {
@@ -1545,9 +1694,9 @@ 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 title = "Group";
+  static description = "A group of tasks that are executed together";
+  static category = "Flow Control";
   static compoundMerge = PROPERTY_ARRAY;
   static hasDynamicSchemas = true;
   constructor(input = {}, config = {}) {
@@ -1727,38 +1876,64 @@ class GraphAsTask extends Task {
 }
 
 // src/task-graph/Workflow.ts
-import { EventEmitter as EventEmitter4 } from "@workglow/util";
+import { EventEmitter as EventEmitter4, uuid4 as uuid43 } from "@workglow/util";
+function CreateWorkflow(taskClass) {
+  return Workflow.createWorkflow(taskClass);
+}
+function CreateLoopWorkflow(taskClass) {
+  return function(config = {}) {
+    return this.addLoopTask(taskClass, config);
+  };
+}
+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;
+  _pendingLoopConnect;
+  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();
-          if (typeof taskSchema !== "boolean" && taskSchema.properties?.[dataflow.targetTaskPortId] === undefined || taskSchema === true && dataflow.targetTaskPortId !== DATAFLOW_ALL_PORTS) {
+          if (typeof taskSchema !== "boolean" && taskSchema.properties?.[dataflow.targetTaskPortId] === undefined && taskSchema.additionalProperties !== true || taskSchema === true && dataflow.targetTaskPortId !== DATAFLOW_ALL_PORTS) {
             this._error = `Input ${dataflow.targetTaskPortId} not found on task ${task.config.id}`;
             console.error(this._error);
             return;
@@ -1769,158 +1944,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);
           }
@@ -1963,12 +2003,20 @@ class Workflow {
     return this.events.waitOn(name);
   }
   async run(input = {}) {
+    if (this.isLoopBuilder) {
+      this.finalizeTemplate();
+      if (this._pendingLoopConnect) {
+        this._parentWorkflow.autoConnectLoopTask(this._pendingLoopConnect);
+        this._pendingLoopConnect = undefined;
+      }
+      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");
@@ -1981,6 +2029,9 @@ class Workflow {
     }
   }
   async abort() {
+    if (this._parentWorkflow) {
+      return this._parentWorkflow.abort();
+    }
     this._abortController?.abort();
   }
   pop() {
@@ -2049,10 +2100,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 = "";
@@ -2107,15 +2160,243 @@ 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);
+  }
+  addLoopTask(taskClass, config = {}) {
+    this._error = "";
+    const parent = getLastTask(this);
+    const task = this.addTaskToGraph(taskClass, {}, { id: uuid43(), ...config });
+    if (this._dataFlows.length > 0) {
+      this._dataFlows.forEach((dataflow) => {
+        const taskSchema = task.inputSchema();
+        if (typeof taskSchema !== "boolean" && taskSchema.properties?.[dataflow.targetTaskPortId] === undefined && taskSchema.additionalProperties !== true || taskSchema === true && dataflow.targetTaskPortId !== DATAFLOW_ALL_PORTS) {
+          this._error = `Input ${dataflow.targetTaskPortId} not found on task ${task.config.id}`;
+          console.error(this._error);
+          return;
+        }
+        dataflow.targetTaskId = task.config.id;
+        this.graph.addDataflow(dataflow);
+      });
+      this._dataFlows = [];
+    }
+    const loopBuilder = new Workflow(this.outputCache(), this, task);
+    if (parent) {
+      loopBuilder._pendingLoopConnect = { parent, iteratorTask: task };
+    }
+    return loopBuilder;
+  }
+  autoConnectLoopTask(pending) {
+    if (!pending)
+      return;
+    const { parent, iteratorTask } = pending;
+    if (this.graph.getTargetDataflows(parent.config.id).length === 0) {
+      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 result = Workflow.autoConnect(this.graph, parent, iteratorTask, {
+        earlierTasks
+      });
+      if (result.error) {
+        this._error = result.error + " Task not added.";
+        console.error(this._error);
+        this.graph.removeTask(iteratorTask.config.id);
+      }
+    }
+  }
+  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) {
+      return;
+    }
+    this._iteratorTask.subGraph = this.graph;
+  }
+  finalizeAndReturn() {
+    if (!this._parentWorkflow) {
+      throw new WorkflowError("finalizeAndReturn() can only be called on loop workflows");
+    }
+    this.finalizeTemplate();
+    if (this._pendingLoopConnect) {
+      this._parentWorkflow.autoConnectLoopTask(this._pendingLoopConnect);
+      this._pendingLoopConnect = undefined;
+    }
+    return this._parentWorkflow;
+  }
 }
 
 // src/task-graph/Conversions.ts
@@ -2283,8 +2564,8 @@ class TaskGraph {
       parentSignal: config?.parentSignal || undefined
     });
   }
-  runReactive() {
-    return this.runner.runGraphReactive();
+  runReactive(input = {}) {
+    return this.runner.runGraphReactive(input);
   }
   mergeExecuteOutputsToRunOutput(results, compoundMerge) {
     return this.runner.mergeExecuteOutputsToRunOutput(results, compoundMerge);
@@ -2355,7 +2636,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());
@@ -2520,80 +2801,1144 @@ function serialGraph(tasks, inputHandle, outputHandle) {
   graph.addDataflows(serialGraphEdges(tasks, inputHandle, outputHandle));
   return graph;
 }
-// src/task/JobQueueFactory.ts
-import {
-  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);
+// src/task/IteratorTaskRunner.ts
+class IteratorTaskRunner extends GraphAsTaskRunner {
+  subGraphRunChain = Promise.resolve();
+  async executeTask(input) {
+    const analysis = this.task.analyzeIterationInput(input);
+    if (analysis.iterationCount === 0) {
+      const emptyResult = this.task.getEmptyResult();
+      return this.executeTaskReactive(input, emptyResult);
+    }
+    const result = this.task.isReduceTask() ? await this.executeReduceIterations(analysis) : await this.executeCollectIterations(analysis);
+    return this.executeTaskReactive(input, result);
   }
-  return globalServiceRegistry3.get(JOB_QUEUE_FACTORY);
-}
-if (!globalServiceRegistry3.has(JOB_QUEUE_FACTORY)) {
+  async executeTaskReactive(input, output) {
+    const reactiveResult = await this.task.executeReactive(input, output, { own: this.own });
+    return Object.assign({}, output, reactiveResult ?? {});
+  }
+  async executeCollectIterations(analysis) {
+    const iterationCount = analysis.iterationCount;
+    const preserveOrder = this.task.preserveIterationOrder();
+    const batchSize = this.task.batchSize !== undefined && this.task.batchSize > 0 ? this.task.batchSize : iterationCount;
+    const requestedConcurrency = this.task.concurrencyLimit ?? iterationCount;
+    const concurrency = Math.max(1, Math.min(requestedConcurrency, iterationCount));
+    const orderedResults = preserveOrder ? new Array(iterationCount) : [];
+    const completionOrderResults = [];
+    for (let batchStart = 0;batchStart < iterationCount; batchStart += batchSize) {
+      if (this.abortController?.signal.aborted) {
+        break;
+      }
+      const batchEnd = Math.min(batchStart + batchSize, iterationCount);
+      const batchIndices = Array.from({ length: batchEnd - batchStart }, (_, i) => batchStart + i);
+      const batchResults = await this.executeBatch(batchIndices, analysis, iterationCount, concurrency);
+      for (const { index, result } of batchResults) {
+        if (result === undefined)
+          continue;
+        if (preserveOrder) {
+          orderedResults[index] = result;
+        } else {
+          completionOrderResults.push(result);
+        }
+      }
+      const progress = Math.round(batchEnd / iterationCount * 100);
+      await this.handleProgress(progress, `Completed ${batchEnd}/${iterationCount} iterations`);
+    }
+    const collected = preserveOrder ? orderedResults.filter((result) => result !== undefined) : completionOrderResults;
+    return this.task.collectResults(collected);
+  }
+  async executeReduceIterations(analysis) {
+    const iterationCount = analysis.iterationCount;
+    let accumulator = this.task.getInitialAccumulator();
+    for (let index = 0;index < iterationCount; index++) {
+      if (this.abortController?.signal.aborted) {
+        break;
+      }
+      const iterationInput = this.task.buildIterationRunInput(analysis, index, iterationCount, {
+        accumulator
+      });
+      const iterationResult = await this.executeSubgraphIteration(iterationInput);
+      accumulator = this.task.mergeIterationIntoAccumulator(accumulator, iterationResult, index);
+      const progress = Math.round((index + 1) / iterationCount * 100);
+      await this.handleProgress(progress, `Completed ${index + 1}/${iterationCount} iterations`);
+    }
+    return accumulator;
+  }
+  async executeBatch(indices, analysis, iterationCount, concurrency) {
+    const results = [];
+    let cursor = 0;
+    const workerCount = Math.max(1, Math.min(concurrency, indices.length));
+    const workers = Array.from({ length: workerCount }, async () => {
+      while (true) {
+        if (this.abortController?.signal.aborted) {
+          return;
+        }
+        const position = cursor;
+        cursor += 1;
+        if (position >= indices.length) {
+          return;
+        }
+        const index = indices[position];
+        const iterationInput = this.task.buildIterationRunInput(analysis, index, iterationCount);
+        const result = await this.executeSubgraphIteration(iterationInput);
+        results.push({ index, result });
+      }
+    });
+    await Promise.all(workers);
+    return results;
+  }
+  async executeSubgraphIteration(input) {
+    let releaseTurn;
+    const waitForPreviousRun = this.subGraphRunChain;
+    this.subGraphRunChain = new Promise((resolve) => {
+      releaseTurn = resolve;
+    });
+    await waitForPreviousRun;
+    try {
+      if (this.abortController?.signal.aborted) {
+        return;
+      }
+      const results = await this.task.subGraph.run(input, {
+        parentSignal: this.abortController?.signal,
+        outputCache: this.outputCache
+      });
+      if (results.length === 0) {
+        return;
+      }
+      return this.task.subGraph.mergeExecuteOutputsToRunOutput(results, this.task.compoundMerge);
+    } finally {
+      releaseTurn?.();
+    }
+  }
+}
+
+// src/task/IteratorTask.ts
+var ITERATOR_CONTEXT_SCHEMA = {
+  type: "object",
+  properties: {
+    _iterationIndex: {
+      type: "integer",
+      minimum: 0,
+      title: "Iteration Index",
+      description: "Current iteration index (0-based)",
+      "x-ui-iteration": true
+    },
+    _iterationCount: {
+      type: "integer",
+      minimum: 0,
+      title: "Iteration Count",
+      description: "Total number of iterations",
+      "x-ui-iteration": true
+    }
+  }
+};
+function isArrayVariant(schema) {
+  if (!schema || typeof schema !== "object")
+    return false;
+  const record = schema;
+  return record.type === "array" || record.items !== undefined;
+}
+function getExplicitIterationFlag(schema) {
+  if (!schema || typeof schema !== "object")
+    return;
+  const record = schema;
+  const flag = record["x-ui-iteration"];
+  if (flag === true)
+    return true;
+  if (flag === false)
+    return false;
+  return;
+}
+function inferIterationFromSchema(schema) {
+  if (!schema || typeof schema !== "object")
+    return;
+  const record = schema;
+  if (record.type === "array" || record.items !== undefined) {
+    return true;
+  }
+  const variants = record.oneOf ?? record.anyOf;
+  if (!Array.isArray(variants) || variants.length === 0) {
+    if (record.type !== undefined) {
+      return false;
+    }
+    return;
+  }
+  let hasArrayVariant = false;
+  let hasNonArrayVariant = false;
+  for (const variant of variants) {
+    if (isArrayVariant(variant)) {
+      hasArrayVariant = true;
+    } else {
+      hasNonArrayVariant = true;
+    }
+  }
+  if (hasArrayVariant && hasNonArrayVariant)
+    return;
+  if (hasArrayVariant)
+    return true;
+  return false;
+}
+function createFlexibleSchema(baseSchema) {
+  if (typeof baseSchema === "boolean")
+    return baseSchema;
+  return {
+    anyOf: [baseSchema, { type: "array", items: baseSchema }]
+  };
+}
+function createArraySchema(baseSchema) {
+  if (typeof baseSchema === "boolean")
+    return baseSchema;
+  return {
+    type: "array",
+    items: baseSchema
+  };
+}
+function extractBaseSchema(schema) {
+  if (typeof schema === "boolean")
+    return schema;
+  const schemaType = schema.type;
+  if (schemaType === "array" && schema.items) {
+    return schema.items;
+  }
+  const variants = schema.oneOf ?? schema.anyOf;
+  if (Array.isArray(variants)) {
+    for (const variant of variants) {
+      if (typeof variant === "object") {
+        const variantType = variant.type;
+        if (variantType !== "array") {
+          return variant;
+        }
+      }
+    }
+    for (const variant of variants) {
+      if (typeof variant === "object") {
+        const variantType = variant.type;
+        if (variantType === "array" && variant.items) {
+          return variant.items;
+        }
+      }
+    }
+  }
+  return schema;
+}
+function schemaAcceptsArray(schema) {
+  if (typeof schema === "boolean")
+    return false;
+  const schemaType = schema.type;
+  if (schemaType === "array")
+    return true;
+  const variants = schema.oneOf ?? schema.anyOf;
+  if (Array.isArray(variants)) {
+    return variants.some((variant) => isArrayVariant(variant));
+  }
+  return false;
+}
+
+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;
+  static getIterationContextSchema() {
+    return ITERATOR_CONTEXT_SCHEMA;
+  }
+  _iteratorPortInfo;
+  _iterationInputSchema;
+  constructor(input = {}, config = {}) {
+    super(input, config);
+  }
+  get runner() {
+    if (!this._runner) {
+      this._runner = new IteratorTaskRunner(this);
+    }
+    return this._runner;
+  }
+  set subGraph(subGraph) {
+    super.subGraph = subGraph;
+    this.invalidateIterationInputSchema();
+    this.events.emit("regenerate");
+  }
+  get subGraph() {
+    return super.subGraph;
+  }
+  regenerateGraph() {
+    this.invalidateIterationInputSchema();
+    super.regenerateGraph();
+  }
+  preserveIterationOrder() {
+    return true;
+  }
+  isReduceTask() {
+    return false;
+  }
+  getInitialAccumulator() {
+    return {};
+  }
+  buildIterationRunInput(analysis, index, iterationCount, extraInput = {}) {
+    return {
+      ...analysis.getIterationInput(index),
+      ...extraInput,
+      _iterationIndex: index,
+      _iterationCount: iterationCount
+    };
+  }
+  mergeIterationIntoAccumulator(accumulator, iterationResult, _index) {
+    return iterationResult ?? accumulator;
+  }
+  getEmptyResult() {
+    return {};
+  }
+  collectResults(results) {
+    if (results.length === 0) {
+      return {};
+    }
+    const merged = {};
+    for (const result of results) {
+      if (!result || typeof result !== "object")
+        continue;
+      for (const [key, value] of Object.entries(result)) {
+        if (!merged[key]) {
+          merged[key] = [];
+        }
+        merged[key].push(value);
+      }
+    }
+    return merged;
+  }
+  get concurrencyLimit() {
+    return this.config.concurrencyLimit;
+  }
+  get batchSize() {
+    return this.config.batchSize;
+  }
+  get iterationInputConfig() {
+    return this.config.iterationInputConfig;
+  }
+  buildDefaultIterationInputSchema() {
+    const innerSchema = this.getInnerInputSchema();
+    if (!innerSchema || typeof innerSchema === "boolean") {
+      return { type: "object", properties: {}, additionalProperties: true };
+    }
+    const properties = {};
+    const innerProps = innerSchema.properties || {};
+    for (const [key, propSchema] of Object.entries(innerProps)) {
+      if (typeof propSchema === "boolean")
+        continue;
+      if (propSchema["x-ui-iteration"]) {
+        continue;
+      }
+      const baseSchema = propSchema;
+      properties[key] = createFlexibleSchema(baseSchema);
+    }
+    return {
+      type: "object",
+      properties,
+      additionalProperties: innerSchema.additionalProperties ?? true
+    };
+  }
+  buildConfiguredIterationInputSchema() {
+    const innerSchema = this.getInnerInputSchema();
+    if (!innerSchema || typeof innerSchema === "boolean") {
+      return { type: "object", properties: {}, additionalProperties: true };
+    }
+    const config = this.iterationInputConfig || {};
+    const properties = {};
+    const innerProps = innerSchema.properties || {};
+    for (const [key, propSchema] of Object.entries(innerProps)) {
+      if (typeof propSchema === "boolean")
+        continue;
+      if (propSchema["x-ui-iteration"]) {
+        continue;
+      }
+      const baseSchema = propSchema;
+      const propConfig = config[key];
+      if (!propConfig) {
+        properties[key] = createFlexibleSchema(baseSchema);
+        continue;
+      }
+      switch (propConfig.mode) {
+        case "array":
+          properties[key] = createArraySchema(propConfig.baseSchema);
+          break;
+        case "scalar":
+          properties[key] = propConfig.baseSchema;
+          break;
+        case "flexible":
+        default:
+          properties[key] = createFlexibleSchema(propConfig.baseSchema);
+          break;
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      additionalProperties: innerSchema.additionalProperties ?? true
+    };
+  }
+  getInnerInputSchema() {
+    if (!this.hasChildren())
+      return;
+    const tasks = this.subGraph.getTasks();
+    if (tasks.length === 0)
+      return;
+    const startingNodes = tasks.filter((task) => this.subGraph.getSourceDataflows(task.config.id).length === 0);
+    const sources = startingNodes.length > 0 ? startingNodes : tasks;
+    const properties = {};
+    const required = [];
+    let additionalProperties = false;
+    for (const task of sources) {
+      const inputSchema = task.inputSchema();
+      if (typeof inputSchema === "boolean") {
+        if (inputSchema === true) {
+          additionalProperties = true;
+        }
+        continue;
+      }
+      additionalProperties = additionalProperties || inputSchema.additionalProperties === true;
+      for (const [key, prop] of Object.entries(inputSchema.properties || {})) {
+        if (typeof prop === "boolean")
+          continue;
+        if (!properties[key]) {
+          properties[key] = prop;
+        }
+      }
+      for (const key of inputSchema.required || []) {
+        if (!required.includes(key)) {
+          required.push(key);
+        }
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      ...required.length > 0 ? { required } : {},
+      additionalProperties
+    };
+  }
+  getIterationInputSchema() {
+    if (this._iterationInputSchema) {
+      return this._iterationInputSchema;
+    }
+    this._iterationInputSchema = this.iterationInputConfig ? this.buildConfiguredIterationInputSchema() : this.buildDefaultIterationInputSchema();
+    return this._iterationInputSchema;
+  }
+  setIterationInputSchema(schema) {
+    this._iterationInputSchema = schema;
+    this._inputSchemaNode = undefined;
+    this.events.emit("regenerate");
+  }
+  setPropertyInputMode(propertyName, mode, baseSchema) {
+    const currentSchema = this.getIterationInputSchema();
+    if (typeof currentSchema === "boolean")
+      return;
+    const currentProps = currentSchema.properties || {};
+    const existingProp = currentProps[propertyName];
+    const base = baseSchema ?? (existingProp ? extractBaseSchema(existingProp) : { type: "string" });
+    let newPropSchema;
+    switch (mode) {
+      case "array":
+        newPropSchema = createArraySchema(base);
+        break;
+      case "scalar":
+        newPropSchema = base;
+        break;
+      case "flexible":
+      default:
+        newPropSchema = createFlexibleSchema(base);
+        break;
+    }
+    this._iterationInputSchema = {
+      ...currentSchema,
+      properties: {
+        ...currentProps,
+        [propertyName]: newPropSchema
+      }
+    };
+    this._inputSchemaNode = undefined;
+    this.events.emit("regenerate");
+  }
+  invalidateIterationInputSchema() {
+    this._iterationInputSchema = undefined;
+    this._iteratorPortInfo = undefined;
+    this._inputSchemaNode = undefined;
+  }
+  analyzeIterationInput(input) {
+    const inputData = input;
+    const schema = this.hasChildren() ? this.getIterationInputSchema() : this.inputSchema();
+    const schemaProps = typeof schema === "object" && schema.properties ? schema.properties : {};
+    const keys = new Set([...Object.keys(schemaProps), ...Object.keys(inputData)]);
+    const arrayPorts = [];
+    const scalarPorts = [];
+    const iteratedValues = {};
+    const arrayLengths = [];
+    for (const key of keys) {
+      if (key.startsWith("_iteration"))
+        continue;
+      const value = inputData[key];
+      const portSchema = schemaProps[key];
+      let shouldIterate;
+      const explicitFlag = getExplicitIterationFlag(portSchema);
+      if (explicitFlag !== undefined) {
+        shouldIterate = explicitFlag;
+      } else {
+        const schemaInference = inferIterationFromSchema(portSchema);
+        shouldIterate = schemaInference ?? Array.isArray(value);
+      }
+      if (!shouldIterate) {
+        scalarPorts.push(key);
+        continue;
+      }
+      if (!Array.isArray(value)) {
+        throw new TaskConfigurationError(`${this.type}: Input '${key}' is configured for iteration but value is not an array.`);
+      }
+      iteratedValues[key] = value;
+      arrayPorts.push(key);
+      arrayLengths.push(value.length);
+    }
+    if (arrayPorts.length === 0) {
+      throw new TaskConfigurationError(`${this.type}: At least one array input is required for iteration. ` + `Mark a port with x-ui-iteration=true, provide array-typed schema, or pass array values at runtime.`);
+    }
+    const uniqueLengths = new Set(arrayLengths);
+    if (uniqueLengths.size > 1) {
+      const lengthInfo = arrayPorts.map((port, index) => `${port}=${arrayLengths[index]}`).join(", ");
+      throw new TaskConfigurationError(`${this.type}: All iterated array inputs must have the same length (zip semantics). ` + `Found different lengths: ${lengthInfo}`);
+    }
+    const iterationCount = arrayLengths[0] ?? 0;
+    const getIterationInput = (index) => {
+      const iterInput = {};
+      for (const key of arrayPorts) {
+        iterInput[key] = iteratedValues[key][index];
+      }
+      for (const key of scalarPorts) {
+        if (key in inputData) {
+          iterInput[key] = inputData[key];
+        }
+      }
+      return iterInput;
+    };
+    return {
+      iterationCount,
+      arrayPorts,
+      scalarPorts,
+      getIterationInput
+    };
+  }
+  getIterationContextSchema() {
+    return this.constructor.getIterationContextSchema();
+  }
+  inputSchema() {
+    if (this.hasChildren()) {
+      return this.getIterationInputSchema();
+    }
+    return this.constructor.inputSchema();
+  }
+  outputSchema() {
+    if (!this.hasChildren()) {
+      return this.constructor.outputSchema();
+    }
+    return this.getWrappedOutputSchema();
+  }
+  getWrappedOutputSchema() {
+    if (!this.hasChildren()) {
+      return { type: "object", properties: {}, additionalProperties: false };
+    }
+    const endingNodes = this.subGraph.getTasks().filter((task) => this.subGraph.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;
+      for (const [key, schema] of Object.entries(taskOutputSchema.properties || {})) {
+        properties[key] = {
+          type: "array",
+          items: schema
+        };
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      additionalProperties: false
+    };
+  }
+}
+
+// src/task/WhileTaskRunner.ts
+class WhileTaskRunner extends GraphAsTaskRunner {
+  async executeTask(input) {
+    const result = await this.task.execute(input, {
+      signal: this.abortController.signal,
+      updateProgress: this.handleProgress.bind(this),
+      own: this.own,
+      registry: this.registry
+    });
+    return result;
+  }
+  async executeTaskReactive(input, output) {
+    const reactiveResult = await this.task.executeReactive(input, output, { own: this.own });
+    return Object.assign({}, output, reactiveResult ?? {});
+  }
+}
+
+// src/task/WhileTask.ts
+var WHILE_CONTEXT_SCHEMA = {
+  type: "object",
+  properties: {
+    _iterationIndex: {
+      type: "integer",
+      minimum: 0,
+      title: "Iteration Number",
+      description: "Current iteration number (0-based)",
+      "x-ui-iteration": true
+    }
+  }
+};
+
+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;
+  static getIterationContextSchema() {
+    return WHILE_CONTEXT_SCHEMA;
+  }
+  _currentIteration = 0;
+  constructor(input = {}, config = {}) {
+    super(input, config);
+  }
+  get runner() {
+    if (!this._runner) {
+      this._runner = new WhileTaskRunner(this);
+    }
+    return this._runner;
+  }
+  get condition() {
+    return this.config.condition;
+  }
+  get maxIterations() {
+    if (this.config.maxIterations !== undefined)
+      return this.config.maxIterations;
+    const wc = this.config.extras?.whileConfig;
+    return wc?.maxIterations ?? 100;
+  }
+  get chainIterations() {
+    if (this.config.chainIterations !== undefined)
+      return this.config.chainIterations;
+    const wc = this.config.extras?.whileConfig;
+    return wc?.chainIterations ?? true;
+  }
+  get currentIteration() {
+    return this._currentIteration;
+  }
+  buildConditionFromExtras() {
+    const wc = this.config.extras?.whileConfig;
+    if (!wc?.conditionOperator) {
+      return;
+    }
+    const { conditionField, conditionOperator, conditionValue } = wc;
+    return (output) => {
+      const fieldValue = conditionField ? getNestedValue(output, conditionField) : output;
+      return evaluateCondition(fieldValue, conditionOperator, conditionValue ?? "");
+    };
+  }
+  analyzeArrayInputs(input) {
+    const wc = this.config.extras?.whileConfig;
+    if (!wc?.iterationInputConfig) {
+      return null;
+    }
+    const inputData = input;
+    const config = wc.iterationInputConfig;
+    const arrayPorts = [];
+    const scalarPorts = [];
+    const iteratedValues = {};
+    const arrayLengths = [];
+    for (const [key, propConfig] of Object.entries(config)) {
+      const value = inputData[key];
+      if (propConfig.mode === "array") {
+        if (!Array.isArray(value)) {
+          scalarPorts.push(key);
+          continue;
+        }
+        iteratedValues[key] = value;
+        arrayPorts.push(key);
+        arrayLengths.push(value.length);
+      } else {
+        scalarPorts.push(key);
+      }
+    }
+    for (const key of Object.keys(inputData)) {
+      if (!config[key] && !key.startsWith("_iteration")) {
+        scalarPorts.push(key);
+      }
+    }
+    if (arrayPorts.length === 0) {
+      return null;
+    }
+    const uniqueLengths = new Set(arrayLengths);
+    if (uniqueLengths.size > 1) {
+      const lengthInfo = arrayPorts.map((port, index) => `${port}=${arrayLengths[index]}`).join(", ");
+      throw new TaskConfigurationError(`${this.type}: All iterated array inputs must have the same length. ` + `Found different lengths: ${lengthInfo}`);
+    }
+    return {
+      arrayPorts,
+      scalarPorts,
+      iteratedValues,
+      iterationCount: arrayLengths[0] ?? 0
+    };
+  }
+  buildIterationInput(input, analysis, index) {
+    const inputData = input;
+    const iterInput = {};
+    for (const key of analysis.arrayPorts) {
+      iterInput[key] = analysis.iteratedValues[key][index];
+    }
+    for (const key of analysis.scalarPorts) {
+      if (key in inputData) {
+        iterInput[key] = inputData[key];
+      }
+    }
+    return iterInput;
+  }
+  async execute(input, context) {
+    if (!this.hasChildren()) {
+      throw new TaskConfigurationError(`${this.type}: No subgraph set for while loop`);
+    }
+    const condition = this.condition ?? this.buildConditionFromExtras();
+    if (!condition) {
+      throw new TaskConfigurationError(`${this.type}: No condition function provided`);
+    }
+    const arrayAnalysis = this.analyzeArrayInputs(input);
+    this._currentIteration = 0;
+    let currentInput = { ...input };
+    let currentOutput = {};
+    const effectiveMax = arrayAnalysis ? Math.min(this.maxIterations, arrayAnalysis.iterationCount) : this.maxIterations;
+    while (this._currentIteration < effectiveMax) {
+      if (context.signal?.aborted) {
+        break;
+      }
+      let iterationInput;
+      if (arrayAnalysis) {
+        iterationInput = {
+          ...this.buildIterationInput(currentInput, arrayAnalysis, this._currentIteration),
+          _iterationIndex: this._currentIteration
+        };
+      } else {
+        iterationInput = {
+          ...currentInput,
+          _iterationIndex: this._currentIteration
+        };
+      }
+      const results = await this.subGraph.run(iterationInput, {
+        parentSignal: context.signal
+      });
+      currentOutput = this.subGraph.mergeExecuteOutputsToRunOutput(results, this.compoundMerge);
+      if (!condition(currentOutput, this._currentIteration)) {
+        break;
+      }
+      if (this.chainIterations) {
+        currentInput = { ...currentInput, ...currentOutput };
+      }
+      this._currentIteration++;
+      const progress = Math.min(this._currentIteration / effectiveMax * 100, 99);
+      await context.updateProgress(progress, `Iteration ${this._currentIteration}`);
+    }
+    return currentOutput;
+  }
+  getIterationContextSchema() {
+    return this.constructor.getIterationContextSchema();
+  }
+  getChainedOutputSchema() {
+    if (!this.chainIterations)
+      return;
+    const outputSchema = this.outputSchema();
+    if (typeof outputSchema === "boolean")
+      return;
+    const properties = {};
+    if (outputSchema.properties && typeof outputSchema.properties === "object") {
+      for (const [key, schema] of Object.entries(outputSchema.properties)) {
+        if (key === "_iterations")
+          continue;
+        if (typeof schema === "object" && schema !== null) {
+          properties[key] = { ...schema, "x-ui-iteration": true };
+        }
+      }
+    }
+    if (Object.keys(properties).length === 0)
+      return;
+    return { type: "object", properties };
+  }
+  inputSchema() {
+    if (!this.hasChildren()) {
+      return this.constructor.inputSchema();
+    }
+    const baseSchema = super.inputSchema();
+    if (typeof baseSchema === "boolean")
+      return baseSchema;
+    const wc = this.config.extras?.whileConfig;
+    if (!wc?.iterationInputConfig) {
+      return baseSchema;
+    }
+    const properties = { ...baseSchema.properties || {} };
+    for (const [key, propConfig] of Object.entries(wc.iterationInputConfig)) {
+      if (propConfig.mode === "array" && properties[key]) {
+        const scalarSchema = properties[key];
+        properties[key] = {
+          anyOf: [scalarSchema, { type: "array", items: scalarSchema }]
+        };
+      }
+    }
+    return {
+      ...baseSchema,
+      properties
+    };
+  }
+  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.hasChildren()) {
+      return this.constructor.outputSchema();
+    }
+    const tasks = this.subGraph.getTasks();
+    const endingNodes = tasks.filter((task) => this.subGraph.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/iterationSchema.ts
+function isFlexibleSchema(schema) {
+  if (typeof schema === "boolean")
+    return false;
+  const variants = schema.oneOf ?? schema.anyOf;
+  const arr = Array.isArray(variants) ? variants : undefined;
+  if (!arr || arr.length !== 2)
+    return false;
+  let hasScalar = false;
+  let hasArray = false;
+  for (const variant of arr) {
+    if (typeof variant !== "object")
+      continue;
+    const v = variant;
+    if (v.type === "array" || "items" in v) {
+      hasArray = true;
+    } else {
+      hasScalar = true;
+    }
+  }
+  return hasScalar && hasArray;
+}
+function isStrictArraySchema(schema) {
+  if (typeof schema === "boolean")
+    return false;
+  const s = schema;
+  return s.type === "array" && !isFlexibleSchema(schema);
+}
+function getInputModeFromSchema(schema) {
+  if (isFlexibleSchema(schema))
+    return "flexible";
+  if (isStrictArraySchema(schema))
+    return "array";
+  return "scalar";
+}
+function getIterationContextSchemaForType(taskType) {
+  if (taskType === "MapTask" || taskType === "ReduceTask") {
+    return ITERATOR_CONTEXT_SCHEMA;
+  }
+  if (taskType === "WhileTask") {
+    return WHILE_CONTEXT_SCHEMA;
+  }
+  return;
+}
+function addIterationContextToSchema(existingSchema, parentTaskType) {
+  const contextSchema = getIterationContextSchemaForType(parentTaskType);
+  if (!contextSchema) {
+    return existingSchema ?? { type: "object", properties: {} };
+  }
+  const baseProperties = existingSchema && typeof existingSchema !== "boolean" && existingSchema.properties && typeof existingSchema.properties !== "boolean" ? existingSchema.properties : {};
+  const contextProperties = typeof contextSchema !== "boolean" && contextSchema.properties && typeof contextSchema.properties !== "boolean" ? contextSchema.properties : {};
+  return {
+    type: "object",
+    properties: {
+      ...baseProperties,
+      ...contextProperties
+    }
+  };
+}
+function isIterationProperty(schema) {
+  if (!schema || typeof schema === "boolean")
+    return false;
+  return schema["x-ui-iteration"] === true;
+}
+function filterIterationProperties(schema) {
+  if (!schema || typeof schema === "boolean")
+    return schema;
+  const props = schema.properties;
+  if (!props || typeof props === "boolean")
+    return schema;
+  const filteredProps = {};
+  for (const [key, propSchema] of Object.entries(props)) {
+    if (!isIterationProperty(propSchema)) {
+      filteredProps[key] = propSchema;
+    }
+  }
+  if (Object.keys(filteredProps).length === 0) {
+    return { type: "object", properties: {} };
+  }
+  return { ...schema, properties: filteredProps };
+}
+function extractIterationProperties(schema) {
+  if (!schema || typeof schema === "boolean")
+    return;
+  const props = schema.properties;
+  if (!props || typeof props === "boolean")
+    return;
+  const iterProps = {};
+  for (const [key, propSchema] of Object.entries(props)) {
+    if (isIterationProperty(propSchema)) {
+      iterProps[key] = propSchema;
+    }
+  }
+  if (Object.keys(iterProps).length === 0)
+    return;
+  return { type: "object", properties: iterProps };
+}
+function removeIterationProperties(schema) {
+  return filterIterationProperties(schema);
+}
+function mergeChainedOutputToInput(inputSchema, outputSchema) {
+  const baseSchema = filterIterationProperties(inputSchema) ?? {
+    type: "object",
+    properties: {}
+  };
+  if (!outputSchema || typeof outputSchema === "boolean") {
+    return baseSchema;
+  }
+  const outProps = outputSchema.properties;
+  if (!outProps || typeof outProps === "boolean") {
+    return baseSchema;
+  }
+  const baseProps = typeof baseSchema !== "boolean" && baseSchema.properties && typeof baseSchema.properties !== "boolean" ? baseSchema.properties : {};
+  const mergedProperties = { ...baseProps };
+  for (const [key, propSchema] of Object.entries(outProps)) {
+    if (typeof propSchema === "object" && propSchema !== null) {
+      mergedProperties[key] = { ...propSchema, "x-ui-iteration": true };
+    }
+  }
+  return {
+    type: "object",
+    properties: mergedProperties
+  };
+}
+function buildIterationInputSchema(innerSchema, config) {
+  if (!innerSchema || typeof innerSchema === "boolean") {
+    return { type: "object", properties: {} };
+  }
+  const innerProps = innerSchema.properties;
+  if (!innerProps || typeof innerProps === "boolean") {
+    return { type: "object", properties: {} };
+  }
+  const properties = {};
+  const propsRecord = innerProps;
+  for (const [key, propSchema] of Object.entries(propsRecord)) {
+    if (typeof propSchema === "boolean")
+      continue;
+    if (propSchema["x-ui-iteration"]) {
+      continue;
+    }
+    const originalProps = propSchema;
+    const metadata = {};
+    for (const metaKey of Object.keys(originalProps)) {
+      if (metaKey === "title" || metaKey === "description" || metaKey.startsWith("x-")) {
+        metadata[metaKey] = originalProps[metaKey];
+      }
+    }
+    const baseSchema = extractBaseSchema(propSchema);
+    const propConfig = config?.[key];
+    const mode = propConfig?.mode ?? "flexible";
+    const base = propConfig?.baseSchema ?? baseSchema;
+    let wrappedSchema;
+    switch (mode) {
+      case "array":
+        wrappedSchema = createArraySchema(base);
+        break;
+      case "scalar":
+        wrappedSchema = base;
+        break;
+      case "flexible":
+      default:
+        wrappedSchema = createFlexibleSchema(base);
+        break;
+    }
+    if (Object.keys(metadata).length > 0 && typeof wrappedSchema === "object") {
+      properties[key] = { ...metadata, ...wrappedSchema };
+    } else {
+      properties[key] = wrappedSchema;
+    }
+  }
+  return {
+    type: "object",
+    properties
+  };
+}
+function findArrayPorts(schema) {
+  if (!schema || typeof schema === "boolean")
+    return [];
+  const props = schema.properties;
+  if (!props || typeof props === "boolean")
+    return [];
+  const arrayPorts = [];
+  const propsRecord = props;
+  for (const [key, propSchema] of Object.entries(propsRecord)) {
+    if (typeof propSchema === "boolean")
+      continue;
+    if (propSchema.type === "array") {
+      arrayPorts.push(key);
+    }
+  }
+  return arrayPorts;
+}
+function wrapSchemaInArray(schema) {
+  if (!schema || typeof schema === "boolean")
+    return schema;
+  const props = schema.properties;
+  if (!props || typeof props === "boolean")
+    return schema;
+  const propsRecord = props;
+  const wrappedProperties = {};
+  for (const [key, propSchema] of Object.entries(propsRecord)) {
+    wrappedProperties[key] = {
+      type: "array",
+      items: propSchema
+    };
+  }
+  return {
+    type: "object",
+    properties: wrappedProperties
+  };
+}
+// src/task/JobQueueFactory.ts
+import {
+  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
@@ -2780,6 +4125,155 @@ 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 array inputs by running a workflow per item";
+  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;
+  }
+  preserveIterationOrder() {
+    return this.preserveOrder;
+  }
+  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()) {
+      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;
+  }
+}
+queueMicrotask(() => {
+  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 iterated inputs sequentially with an accumulator (fold)";
+  constructor(input = {}, config = {}) {
+    const reduceConfig = {
+      ...config,
+      concurrencyLimit: 1,
+      batchSize: 1
+    };
+    super(input, reduceConfig);
+  }
+  get initialValue() {
+    return this.config.initialValue ?? {};
+  }
+  isReduceTask() {
+    return true;
+  }
+  getInitialAccumulator() {
+    const value = this.initialValue;
+    if (Array.isArray(value)) {
+      return [...value];
+    }
+    if (value && typeof value === "object") {
+      return { ...value };
+    }
+    return value;
+  }
+  buildIterationRunInput(analysis, index, iterationCount, extraInput = {}) {
+    return super.buildIterationRunInput(analysis, index, iterationCount, {
+      accumulator: extraInput.accumulator
+    });
+  }
+  getEmptyResult() {
+    return this.getInitialAccumulator();
+  }
+  static inputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+  }
+  static outputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+  }
+  outputSchema() {
+    if (!this.hasChildren()) {
+      return this.constructor.outputSchema();
+    }
+    const endingNodes = this.subGraph.getTasks().filter((task) => this.subGraph.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;
+      for (const [key, schema] of Object.entries(taskOutputSchema.properties || {})) {
+        if (!properties[key]) {
+          properties[key] = schema;
+        }
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      additionalProperties: false
+    };
+  }
+}
+queueMicrotask(() => {
+  Workflow.prototype.reduce = CreateLoopWorkflow(ReduceTask);
+  Workflow.prototype.endReduce = CreateEndLoopWorkflow("endReduce");
+});
 // src/task/TaskRegistry.ts
 var taskConstructors = new Map;
 function registerTask(baseClass) {
@@ -2849,7 +4343,7 @@ var createGraphFromGraphJSON = (graphJsonObj) => {
 };
 // src/task/index.ts
 var registerBaseTasks = () => {
-  const tasks = [ConditionalTask, GraphAsTask];
+  const tasks = [GraphAsTask, ConditionalTask, MapTask, WhileTask, ReduceTask];
   tasks.map(TaskRegistry.registerTask);
   return tasks;
 };
@@ -3010,25 +4504,47 @@ class TaskOutputTabularRepository extends TaskOutputRepository {
   }
 }
 export {
+  wrapSchemaInArray,
   setTaskQueueRegistry,
   serialGraph,
+  schemaAcceptsArray,
   resolveSchemaInputs,
+  removeIterationProperties,
   registerJobQueueFactory,
   registerBaseTasks,
   pipe,
   parallel,
+  mergeChainedOutputToInput,
+  isStrictArraySchema,
+  isIterationProperty,
+  isFlexibleSchema,
   getTaskQueueRegistry,
+  getNestedValue,
   getLastTask,
   getJobQueueFactory,
+  getIterationContextSchemaForType,
+  getInputModeFromSchema,
+  findArrayPorts,
+  filterIterationProperties,
+  extractIterationProperties,
+  extractBaseSchema,
+  evaluateCondition,
   ensureTask,
   createTaskFromGraphJSON,
   createTaskFromDependencyJSON,
   createJobQueueFactoryWithOptions,
   createGraphFromGraphJSON,
   createGraphFromDependencyJSON,
+  createFlexibleSchema,
+  createArraySchema,
   connect,
+  buildIterationInputSchema,
+  addIterationContextToSchema,
   WorkflowError,
   Workflow,
+  WhileTaskRunner,
+  WhileTask,
+  WHILE_CONTEXT_SCHEMA,
   TaskStatus,
   TaskRegistry,
   TaskQueueRegistry,
@@ -3051,10 +4567,15 @@ export {
   Task,
   TASK_OUTPUT_REPOSITORY,
   TASK_GRAPH_REPOSITORY,
+  ReduceTask,
   PROPERTY_ARRAY,
+  MapTask,
   JobTaskFailedError,
   JobQueueTask,
   JOB_QUEUE_FACTORY,
+  IteratorTaskRunner,
+  IteratorTask,
+  ITERATOR_CONTEXT_SCHEMA,
   GraphAsTaskRunner,
   GraphAsTask,
   GRAPH_RESULT_ARRAY,
@@ -3065,7 +4586,9 @@ export {
   DATAFLOW_ERROR_PORT,
   DATAFLOW_ALL_PORTS,
   CreateWorkflow,
+  CreateLoopWorkflow,
+  CreateEndLoopWorkflow,
   ConditionalTask
 };
 
-//# debugId=0C9B0184C88D909D64756E2164756E21
+//# debugId=4D22DE67A27A853E64756E2164756E21