@workglow/task-graph 0.0.87 → 0.0.89

package/dist/bun.js

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