@workglow/task-graph 0.0.89 → 0.0.91

package/dist/bun.js

@@ -7,6 +7,7 @@ var TaskStatus = {
   PENDING: "PENDING",
   DISABLED: "DISABLED",
   PROCESSING: "PROCESSING",
+  STREAMING: "STREAMING",
   COMPLETED: "COMPLETED",
   ABORTING: "ABORTING",
   FAILED: "FAILED"
@@ -36,10 +37,62 @@ class Dataflow {
   value = undefined;
   status = TaskStatus.PENDING;
   error;
+  stream = undefined;
+  setStream(stream) {
+    this.stream = stream;
+  }
+  getStream() {
+    return this.stream;
+  }
+  async awaitStreamValue() {
+    if (!this.stream)
+      return;
+    const reader = this.stream.getReader();
+    let accumulatedText = "";
+    let lastSnapshotData = undefined;
+    let finishData = undefined;
+    let hasTextDelta = false;
+    try {
+      while (true) {
+        const { done, value: event } = await reader.read();
+        if (done)
+          break;
+        switch (event.type) {
+          case "text-delta":
+            hasTextDelta = true;
+            accumulatedText += event.textDelta;
+            break;
+          case "snapshot":
+            lastSnapshotData = event.data;
+            break;
+          case "finish":
+            finishData = event.data;
+            break;
+          case "error":
+            break;
+        }
+      }
+    } finally {
+      reader.releaseLock();
+      this.stream = undefined;
+    }
+    if (lastSnapshotData !== undefined) {
+      this.setPortData(lastSnapshotData);
+    } else if (finishData && Object.keys(finishData).length > 0) {
+      this.setPortData(finishData);
+    } else if (hasTextDelta) {
+      if (this.sourceTaskPortId === DATAFLOW_ALL_PORTS) {
+        this.value = { text: accumulatedText };
+      } else {
+        this.value = accumulatedText;
+      }
+    }
+  }
   reset() {
     this.status = TaskStatus.PENDING;
     this.error = undefined;
     this.value = undefined;
+    this.stream = undefined;
     this.emit("reset");
     this.emit("status", this.status);
   }
@@ -51,6 +104,9 @@ class Dataflow {
       case TaskStatus.PROCESSING:
         this.emit("start");
         break;
+      case TaskStatus.STREAMING:
+        this.emit("streaming");
+        break;
       case TaskStatus.COMPLETED:
         this.emit("complete");
         break;
@@ -162,7 +218,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 +261,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,
@@ -331,6 +454,49 @@ async function resolveSchemaInputs(input, schema, config) {
   return resolved;
 }
 
+// src/task/StreamTypes.ts
+function getPortStreamMode(schema, portId) {
+  if (typeof schema === "boolean")
+    return "none";
+  const prop = schema.properties?.[portId];
+  if (!prop || typeof prop === "boolean")
+    return "none";
+  const xStream = prop["x-stream"];
+  if (xStream === "append" || xStream === "replace")
+    return xStream;
+  return "none";
+}
+function getOutputStreamMode(outputSchema) {
+  if (typeof outputSchema === "boolean")
+    return "none";
+  const props = outputSchema.properties;
+  if (!props)
+    return "none";
+  let found = "none";
+  for (const prop of Object.values(props)) {
+    if (!prop || typeof prop === "boolean")
+      continue;
+    const xStream = prop["x-stream"];
+    if (xStream === "append")
+      return "append";
+    if (xStream === "replace")
+      found = "replace";
+  }
+  return found;
+}
+function isTaskStreamable(task) {
+  if (typeof task.executeStream !== "function")
+    return false;
+  return getOutputStreamMode(task.outputSchema()) !== "none";
+}
+function edgeNeedsAccumulation(sourceSchema, sourcePort, targetSchema, targetPort) {
+  const sourceMode = getPortStreamMode(sourceSchema, sourcePort);
+  if (sourceMode === "none")
+    return false;
+  const targetMode = getPortStreamMode(targetSchema, targetPort);
+  return sourceMode !== targetMode;
+}
+
 // src/task/TaskRunner.ts
 class TaskRunner {
   running = false;
@@ -360,14 +526,27 @@ class TaskRunner {
       }
       const inputs = this.task.runInputData;
       let outputs;
+      const isStreamable = isTaskStreamable(this.task);
       if (this.task.cacheable) {
         outputs = await this.outputCache?.getOutput(this.task.type, inputs);
         if (outputs) {
-          this.task.runOutputData = await this.executeTaskReactive(inputs, outputs);
+          if (isStreamable) {
+            this.task.runOutputData = outputs;
+            this.task.emit("stream_start");
+            this.task.emit("stream_chunk", { type: "finish", data: outputs });
+            this.task.emit("stream_end", outputs);
+            this.task.runOutputData = await this.executeTaskReactive(inputs, outputs);
+          } else {
+            this.task.runOutputData = await this.executeTaskReactive(inputs, outputs);
+          }
         }
       }
       if (!outputs) {
-        outputs = await this.executeTask(inputs);
+        if (isStreamable) {
+          outputs = await this.executeStreamingTask(inputs);
+        } else {
+          outputs = await this.executeTask(inputs);
+        }
         if (this.task.cacheable && outputs !== undefined) {
           await this.outputCache?.saveOutput(this.task.type, inputs, outputs);
         }
@@ -426,6 +605,64 @@ class TaskRunner {
     const reactiveResult = await this.task.executeReactive(input, output, { own: this.own });
     return Object.assign({}, output, reactiveResult ?? {});
   }
+  async executeStreamingTask(input) {
+    const streamMode = getOutputStreamMode(this.task.outputSchema());
+    let accumulated = "";
+    let chunkCount = 0;
+    let finalOutput;
+    this.task.emit("stream_start");
+    const stream = this.task.executeStream(input, {
+      signal: this.abortController.signal,
+      updateProgress: this.handleProgress.bind(this),
+      own: this.own,
+      registry: this.registry
+    });
+    for await (const event of stream) {
+      chunkCount++;
+      if (chunkCount === 1) {
+        this.task.status = TaskStatus.STREAMING;
+        this.task.emit("status", this.task.status);
+      }
+      if (event.type === "snapshot") {
+        this.task.runOutputData = event.data;
+      }
+      this.task.emit("stream_chunk", event);
+      switch (event.type) {
+        case "text-delta": {
+          accumulated += event.textDelta;
+          const progress = Math.min(99, Math.round(100 * (1 - Math.exp(-0.02 * chunkCount))));
+          await this.handleProgress(progress);
+          break;
+        }
+        case "snapshot": {
+          const progress = Math.min(99, Math.round(100 * (1 - Math.exp(-0.02 * chunkCount))));
+          await this.handleProgress(progress);
+          break;
+        }
+        case "finish": {
+          if (streamMode === "append") {
+            const text = accumulated.length > 0 ? accumulated : event.data?.text ?? "";
+            finalOutput = { ...event.data || {}, text };
+          } else if (streamMode === "replace") {
+            finalOutput = event.data;
+          }
+          break;
+        }
+        case "error": {
+          throw event.error;
+        }
+      }
+    }
+    if (this.abortController?.signal.aborted) {
+      throw new TaskAbortedError("Task aborted during streaming");
+    }
+    if (finalOutput !== undefined) {
+      this.task.runOutputData = finalOutput;
+    }
+    this.task.emit("stream_end", this.task.runOutputData);
+    const reactiveResult = await this.executeTaskReactive(input, this.task.runOutputData || {});
+    return reactiveResult;
+  }
   async handleStart(config = {}) {
     if (this.task.status === TaskStatus.PROCESSING)
       return;
@@ -544,13 +781,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 +1149,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 +1218,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)
@@ -1039,6 +1356,7 @@ class TopologicalScheduler {
     }
   }
   onTaskCompleted(taskId) {}
+  onTaskStreaming(taskId) {}
   reset() {
     this.sortedNodes = this.dag.topologicallySortedNodes();
     this.currentIndex = 0;
@@ -1048,11 +1366,13 @@ class TopologicalScheduler {
 class DependencyBasedScheduler {
   dag;
   completedTasks;
+  streamingTasks;
   pendingTasks;
   nextResolver = null;
   constructor(dag) {
     this.dag = dag;
     this.completedTasks = new Set;
+    this.streamingTasks = new Set;
     this.pendingTasks = new Set;
     this.reset();
   }
@@ -1067,8 +1387,23 @@ class DependencyBasedScheduler {
         return false;
       }
     }
-    const dependencies = sourceDataflows.filter((df) => df.status !== TaskStatus.DISABLED).map((dataflow) => dataflow.sourceTaskId);
-    return dependencies.every((dep) => this.completedTasks.has(dep));
+    const activeDataflows = sourceDataflows.filter((df) => df.status !== TaskStatus.DISABLED);
+    return activeDataflows.every((df) => {
+      const depId = df.sourceTaskId;
+      if (this.completedTasks.has(depId))
+        return true;
+      if (this.streamingTasks.has(depId)) {
+        const sourceTask = this.dag.getTask(depId);
+        if (sourceTask) {
+          const sourceMode = getPortStreamMode(sourceTask.outputSchema(), df.sourceTaskPortId);
+          const targetMode = getPortStreamMode(task.inputSchema(), df.targetTaskPortId);
+          if (sourceMode !== "none" && sourceMode === targetMode) {
+            return true;
+          }
+        }
+      }
+      return false;
+    });
   }
   async waitForNextTask() {
     if (this.pendingTasks.size === 0)
@@ -1123,8 +1458,26 @@ class DependencyBasedScheduler {
       }
     }
   }
+  onTaskStreaming(taskId) {
+    this.streamingTasks.add(taskId);
+    for (const task of Array.from(this.pendingTasks)) {
+      if (task.status === TaskStatus.DISABLED) {
+        this.pendingTasks.delete(task);
+      }
+    }
+    if (this.nextResolver) {
+      const readyTask = Array.from(this.pendingTasks).find((task) => this.isTaskReady(task));
+      if (readyTask) {
+        this.pendingTasks.delete(readyTask);
+        const resolver = this.nextResolver;
+        this.nextResolver = null;
+        resolver(readyTask);
+      }
+    }
+  }
   reset() {
     this.completedTasks.clear();
+    this.streamingTasks.clear();
     this.pendingTasks = new Set(this.dag.topologicallySortedNodes());
     this.nextResolver = null;
   }
@@ -1361,7 +1714,12 @@ class TaskGraphRunner {
     }
   }
   async runTask(task, input) {
+    const isStreamable = isTaskStreamable(task);
+    await this.awaitStreamInputs(task);
     this.copyInputFromEdgesToNode(task);
+    if (isStreamable) {
+      return this.runStreamingTask(task, input);
+    }
     const results = await task.runner.run(input, {
       outputCache: this.outputCache,
       updateProgress: async (task2, progress, message, ...args) => await this.handleProgress(task2, progress, message, ...args),
@@ -1374,6 +1732,93 @@ class TaskGraphRunner {
       data: results
     };
   }
+  async awaitStreamInputs(task) {
+    const dataflows = this.graph.getSourceDataflows(task.config.id);
+    const streamPromises = dataflows.filter((df) => df.stream !== undefined).map((df) => df.awaitStreamValue());
+    if (streamPromises.length > 0) {
+      await Promise.all(streamPromises);
+    }
+  }
+  async runStreamingTask(task, input) {
+    const streamMode = getOutputStreamMode(task.outputSchema());
+    let streamingNotified = false;
+    const onStatus = (status) => {
+      if (status === TaskStatus.STREAMING && !streamingNotified) {
+        streamingNotified = true;
+        this.pushStatusFromNodeToEdges(this.graph, task, TaskStatus.STREAMING);
+        this.pushStreamToEdges(task, streamMode);
+        this.processScheduler.onTaskStreaming(task.config.id);
+      }
+    };
+    const onStreamStart = () => {
+      this.graph.emit("task_stream_start", task.config.id);
+    };
+    const onStreamChunk = (event) => {
+      this.graph.emit("task_stream_chunk", task.config.id, event);
+    };
+    const onStreamEnd = (output) => {
+      this.graph.emit("task_stream_end", task.config.id, output);
+    };
+    task.on("status", onStatus);
+    task.on("stream_start", onStreamStart);
+    task.on("stream_chunk", onStreamChunk);
+    task.on("stream_end", onStreamEnd);
+    try {
+      const results = await task.runner.run(input, {
+        outputCache: this.outputCache,
+        updateProgress: async (task2, progress, message, ...args) => await this.handleProgress(task2, progress, message, ...args),
+        registry: this.registry
+      });
+      await this.pushOutputFromNodeToEdges(task, results);
+      return {
+        id: task.config.id,
+        type: task.constructor.runtype || task.constructor.type,
+        data: results
+      };
+    } finally {
+      task.off("status", onStatus);
+      task.off("stream_start", onStreamStart);
+      task.off("stream_chunk", onStreamChunk);
+      task.off("stream_end", onStreamEnd);
+    }
+  }
+  pushStreamToEdges(task, streamMode) {
+    const targetDataflows = this.graph.getTargetDataflows(task.config.id);
+    if (targetDataflows.length === 0)
+      return;
+    const stream = new ReadableStream({
+      start: (controller) => {
+        const onChunk = (event) => {
+          try {
+            controller.enqueue(event);
+          } catch {}
+        };
+        const onEnd = () => {
+          try {
+            controller.close();
+          } catch {}
+          task.off("stream_chunk", onChunk);
+          task.off("stream_end", onEnd);
+        };
+        task.on("stream_chunk", onChunk);
+        task.on("stream_end", onEnd);
+      }
+    });
+    if (targetDataflows.length === 1) {
+      targetDataflows[0].setStream(stream);
+    } else {
+      let currentStream = stream;
+      for (let i = 0;i < targetDataflows.length; i++) {
+        if (i === targetDataflows.length - 1) {
+          targetDataflows[i].setStream(currentStream);
+        } else {
+          const [s1, s2] = currentStream.tee();
+          targetDataflows[i].setStream(s1);
+          currentStream = s2;
+        }
+      }
+    }
+  }
   resetTask(graph, task, runId) {
     task.status = TaskStatus.PENDING;
     task.resetInputData();
@@ -1457,7 +1902,7 @@ class TaskGraphRunner {
   }
   async handleError(error) {
     await Promise.allSettled(this.graph.getTasks().map(async (task) => {
-      if (task.status === TaskStatus.PROCESSING) {
+      if (task.status === TaskStatus.PROCESSING || task.status === TaskStatus.STREAMING) {
         task.abort();
       }
     }));
@@ -1469,7 +1914,7 @@ class TaskGraphRunner {
   }
   async handleAbort() {
     this.graph.getTasks().map(async (task) => {
-      if (task.status === TaskStatus.PROCESSING) {
+      if (task.status === TaskStatus.PROCESSING || task.status === TaskStatus.STREAMING) {
         task.abort();
       }
     });
@@ -1547,9 +1992,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 = {}) {
@@ -1729,38 +2174,112 @@ 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();
+  };
+}
+var TYPED_ARRAY_FORMAT_PREFIX = "TypedArray";
+function schemaHasTypedArrayFormat(schema) {
+  if (typeof schema === "boolean")
+    return false;
+  if (!schema || typeof schema !== "object" || Array.isArray(schema))
+    return false;
+  const s = schema;
+  if (typeof s.format === "string" && s.format.startsWith(TYPED_ARRAY_FORMAT_PREFIX)) {
+    return true;
+  }
+  const checkUnion = (schemas) => {
+    if (!Array.isArray(schemas))
+      return false;
+    return schemas.some((sub) => schemaHasTypedArrayFormat(sub));
+  };
+  if (checkUnion(s.oneOf) || checkUnion(s.anyOf))
+    return true;
+  const items = s.items;
+  if (items && typeof items === "object" && !Array.isArray(items)) {
+    if (schemaHasTypedArrayFormat(items))
+      return true;
+  }
+  return false;
+}
+function hasVectorOutput(task) {
+  const outputSchema = task.outputSchema();
+  if (typeof outputSchema === "boolean" || !outputSchema?.properties)
+    return false;
+  return Object.values(outputSchema.properties).some((prop) => schemaHasTypedArrayFormat(prop));
+}
+function hasVectorLikeInput(input) {
+  if (!input || typeof input !== "object")
+    return false;
+  const v = input.vectors;
+  return Array.isArray(v) && v.length > 0 && typeof v[0] === "object" && v[0] !== null && ArrayBuffer.isView(v[0]);
+}
+function CreateAdaptiveWorkflow(scalarClass, vectorClass) {
+  const scalarHelper = Workflow.createWorkflow(scalarClass);
+  const vectorHelper = Workflow.createWorkflow(vectorClass);
+  return function(input = {}, config = {}) {
+    const parent = getLastTask(this);
+    const useVector = parent !== undefined && hasVectorOutput(parent) || hasVectorLikeInput(input);
+    if (useVector) {
+      return vectorHelper.call(this, input, config);
+    }
+    return scalarHelper.call(this, input, config);
+  };
+}
+
 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;
@@ -1771,158 +2290,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);
           }
@@ -1965,12 +2349,25 @@ 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;
+    const unsubStreaming = this.graph.subscribeToTaskStreaming({
+      onStreamStart: (taskId) => this.events.emit("stream_start", taskId),
+      onStreamChunk: (taskId, event) => this.events.emit("stream_chunk", taskId, event),
+      onStreamEnd: (taskId, output) => this.events.emit("stream_end", taskId, output)
+    });
     try {
       const output = await this.graph.run(input, {
         parentSignal: this._abortController.signal,
-        outputCache: this._repository
+        outputCache: this._outputCache
       });
       const results = this.graph.mergeExecuteOutputsToRunOutput(output, PROPERTY_ARRAY);
       this.events.emit("complete");
@@ -1979,10 +2376,14 @@ class Workflow {
       this.events.emit("error", String(error));
       throw error;
     } finally {
+      unsubStreaming();
       this._abortController = undefined;
     }
   }
   async abort() {
+    if (this._parentWorkflow) {
+      return this._parentWorkflow.abort();
+    }
     this._abortController?.abort();
   }
   pop() {
@@ -2051,10 +2452,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 = "";
@@ -2109,53 +2512,294 @@ 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);
-}
-
-// src/task-graph/Conversions.ts
-class ListeningGraphAsTask extends GraphAsTask {
-  constructor(input, config) {
-    super(input, config);
-    this.subGraph.on("start", () => {
-      this.emit("start");
-    });
-    this.subGraph.on("complete", () => {
-      this.emit("complete");
-    });
-    this.subGraph.on("error", (e) => {
-      this.emit("error", e);
-    });
+  addTask(taskClass, input, config) {
+    const helper = Workflow.createWorkflow(taskClass);
+    return helper.call(this, input, config);
   }
-}
-
-class OwnGraphTask extends ListeningGraphAsTask {
-  static type = "Own[Graph]";
-}
-
-class OwnWorkflowTask extends ListeningGraphAsTask {
-  static type = "Own[Workflow]";
-}
-
-class GraphTask extends GraphAsTask {
-  static type = "Graph";
-}
-
-class WorkflowTask2 extends GraphAsTask {
-  static type = "Workflow";
-}
-function convertPipeFunctionToTask(fn, config) {
-
-  class QuickTask extends Task {
-    static type = fn.name ? `\uD835\uDC53 ${fn.name}` : "\uD835\uDC53";
-    static inputSchema = () => {
+  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 [toInputPortId, toPortInputSchema] of Object.entries(toSchema.properties || {})) {
+        if (matches.has(toInputPortId))
+          continue;
+        const candidates = [];
+        for (const [fromOutputPortId, fromPortOutputSchema] of Object.entries(fromSchema.properties || {})) {
+          if (comparator([fromOutputPortId, fromPortOutputSchema], [toInputPortId, toPortInputSchema])) {
+            candidates.push(fromOutputPortId);
+          }
+        }
+        if (candidates.length === 0)
+          continue;
+        let winner = candidates[0];
+        if (candidates.length > 1) {
+          const targetStreamMode = getPortStreamMode(toSchema, toInputPortId);
+          const streamMatch = candidates.find((portId) => getPortStreamMode(fromSchema, portId) === targetStreamMode);
+          if (streamMatch)
+            winner = streamMatch;
+        }
+        matches.set(toInputPortId, winner);
+        graph.addDataflow(new Dataflow(fromTaskId, winner, 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
+class ListeningGraphAsTask extends GraphAsTask {
+  constructor(input, config) {
+    super(input, config);
+    this.subGraph.on("start", () => {
+      this.emit("start");
+    });
+    this.subGraph.on("complete", () => {
+      this.emit("complete");
+    });
+    this.subGraph.on("error", (e) => {
+      this.emit("error", e);
+    });
+  }
+}
+
+class OwnGraphTask extends ListeningGraphAsTask {
+  static type = "Own[Graph]";
+}
+
+class OwnWorkflowTask extends ListeningGraphAsTask {
+  static type = "Own[Workflow]";
+}
+
+class GraphTask extends GraphAsTask {
+  static type = "Graph";
+}
+
+class WorkflowTask2 extends GraphAsTask {
+  static type = "Workflow";
+}
+function convertPipeFunctionToTask(fn, config) {
+
+  class QuickTask extends Task {
+    static type = fn.name ? `\uD835\uDC53 ${fn.name}` : "\uD835\uDC53";
+    static inputSchema = () => {
       return {
         type: "object",
         properties: {
@@ -2357,7 +3001,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());
@@ -2479,6 +3123,24 @@ class TaskGraph {
       unsubscribes.forEach((unsub) => unsub());
     };
   }
+  subscribeToTaskStreaming(callbacks) {
+    const unsubscribes = [];
+    if (callbacks.onStreamStart) {
+      const unsub = this.subscribe("task_stream_start", callbacks.onStreamStart);
+      unsubscribes.push(unsub);
+    }
+    if (callbacks.onStreamChunk) {
+      const unsub = this.subscribe("task_stream_chunk", callbacks.onStreamChunk);
+      unsubscribes.push(unsub);
+    }
+    if (callbacks.onStreamEnd) {
+      const unsub = this.subscribe("task_stream_end", callbacks.onStreamEnd);
+      unsubscribes.push(unsub);
+    }
+    return () => {
+      unsubscribes.forEach((unsub) => unsub());
+    };
+  }
   on(name, fn) {
     const dagEvent = EventTaskGraphToDagMapping[name];
     if (dagEvent) {
@@ -2522,122 +3184,1186 @@ 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);
-  }
-  return globalServiceRegistry3.get(JOB_QUEUE_FACTORY);
-}
-if (!globalServiceRegistry3.has(JOB_QUEUE_FACTORY)) {
-  registerJobQueueFactory(defaultJobQueueFactory);
-}
-// src/task/JobQueueTask.ts
-import { Job as Job2 } from "@workglow/job-queue";
-
-// 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`);
+// 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);
     }
-    this.queues.set(queueName, queue);
-  }
-  getQueue(queueName) {
-    return this.queues.get(queueName);
+    const result = this.task.isReduceTask() ? await this.executeReduceIterations(analysis) : await this.executeCollectIterations(analysis);
+    return this.executeTaskReactive(input, result);
   }
-  startQueues() {
-    for (const queue of this.queues.values()) {
-      queue.server.start();
-    }
-    return this;
+  async executeTaskReactive(input, output) {
+    const reactiveResult = await this.task.executeReactive(input, output, { own: this.own });
+    return Object.assign({}, output, reactiveResult ?? {});
   }
-  stopQueues() {
-    for (const queue of this.queues.values()) {
-      queue.server.stop();
+  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`);
     }
-    return this;
+    const collected = preserveOrder ? orderedResults.filter((result) => result !== undefined) : completionOrderResults;
+    return this.task.collectResults(collected);
   }
-  clearQueues() {
-    for (const queue of this.queues.values()) {
-      queue.storage.deleteAll();
+  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 this;
+    return accumulator;
   }
-}
-function getTaskQueueRegistry() {
-  if (!taskQueueRegistry) {
-    taskQueueRegistry = new TaskQueueRegistry;
+  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
+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;
 }
@@ -2782,6 +4508,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) {
@@ -2851,7 +4726,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;
 };
@@ -3012,25 +4887,53 @@ class TaskOutputTabularRepository extends TaskOutputRepository {
   }
 }
 export {
+  wrapSchemaInArray,
   setTaskQueueRegistry,
   serialGraph,
+  schemaAcceptsArray,
   resolveSchemaInputs,
+  removeIterationProperties,
   registerJobQueueFactory,
   registerBaseTasks,
   pipe,
   parallel,
+  mergeChainedOutputToInput,
+  isTaskStreamable,
+  isStrictArraySchema,
+  isIterationProperty,
+  isFlexibleSchema,
+  hasVectorOutput,
+  hasVectorLikeInput,
   getTaskQueueRegistry,
+  getPortStreamMode,
+  getOutputStreamMode,
+  getNestedValue,
   getLastTask,
   getJobQueueFactory,
+  getIterationContextSchemaForType,
+  getInputModeFromSchema,
+  findArrayPorts,
+  filterIterationProperties,
+  extractIterationProperties,
+  extractBaseSchema,
+  evaluateCondition,
   ensureTask,
+  edgeNeedsAccumulation,
   createTaskFromGraphJSON,
   createTaskFromDependencyJSON,
   createJobQueueFactoryWithOptions,
   createGraphFromGraphJSON,
   createGraphFromDependencyJSON,
+  createFlexibleSchema,
+  createArraySchema,
   connect,
+  buildIterationInputSchema,
+  addIterationContextToSchema,
   WorkflowError,
   Workflow,
+  WhileTaskRunner,
+  WhileTask,
+  WHILE_CONTEXT_SCHEMA,
   TaskStatus,
   TaskRegistry,
   TaskQueueRegistry,
@@ -3053,10 +4956,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,
@@ -3067,7 +4975,10 @@ export {
   DATAFLOW_ERROR_PORT,
   DATAFLOW_ALL_PORTS,
   CreateWorkflow,
+  CreateLoopWorkflow,
+  CreateEndLoopWorkflow,
+  CreateAdaptiveWorkflow,
   ConditionalTask
 };
 
-//# debugId=B92DF56229C4FC4064756E2164756E21
+//# debugId=65C6DA6762951D4864756E2164756E21