@workglow/task-graph 0.2.13 → 0.2.15

package/dist/browser.js

@@ -2,6 +2,98 @@
 import { areSemanticallyCompatible } from "@workglow/util/schema";
 import { EventEmitter } from "@workglow/util";
 
+// src/task/TaskError.ts
+import { BaseError } from "@workglow/util";
+
+class TaskError extends BaseError {
+  static type = "TaskError";
+  taskType;
+  taskId;
+  constructor(message) {
+    super(message);
+  }
+}
+
+class TaskConfigurationError extends TaskError {
+  static type = "TaskConfigurationError";
+  constructor(message) {
+    super(message);
+  }
+}
+
+class WorkflowError extends TaskError {
+  static type = "WorkflowError";
+  constructor(message) {
+    super(message);
+  }
+}
+
+class TaskAbortedError extends TaskError {
+  static type = "TaskAbortedError";
+  constructor(message = "Task aborted") {
+    super(message);
+  }
+}
+
+class TaskTimeoutError extends TaskAbortedError {
+  static type = "TaskTimeoutError";
+  constructor(timeoutMs) {
+    super(timeoutMs ? `Task timed out after ${timeoutMs}ms` : "Task timed out");
+  }
+}
+
+class TaskGraphTimeoutError extends TaskTimeoutError {
+  static type = "TaskGraphTimeoutError";
+  constructor(timeoutMs) {
+    super(timeoutMs);
+    this.message = timeoutMs ? `Graph execution timed out after ${timeoutMs}ms` : "Graph execution timed out";
+  }
+}
+
+class TaskFailedError extends TaskError {
+  static type = "TaskFailedError";
+  constructor(message = "Task failed") {
+    super(message);
+  }
+}
+
+class JobTaskFailedError extends TaskFailedError {
+  static type = "JobTaskFailedError";
+  jobError;
+  constructor(err) {
+    super(String(err));
+    this.jobError = err;
+  }
+}
+
+class TaskJSONError extends TaskError {
+  static type = "TaskJSONError";
+  constructor(message = "Error converting JSON to a Task") {
+    super(message);
+  }
+}
+
+class TaskInvalidInputError extends TaskError {
+  static type = "TaskInvalidInputError";
+  constructor(message = "Invalid input data") {
+    super(message);
+  }
+}
+
+class TaskEntitlementError extends TaskError {
+  static type = "TaskEntitlementError";
+  constructor(message = "Required entitlements denied") {
+    super(message);
+  }
+}
+
+class TaskSerializationError extends TaskError {
+  static type = "TaskSerializationError";
+  constructor(taskType) {
+    super(`Task "${taskType}" cannot be serialized: config contains non-serializable values. ` + `Use a declarative config alternative or remove function-valued config properties.`);
+  }
+}
+
 // src/task/TaskTypes.ts
 var TaskStatus = {
   PENDING: "PENDING",
@@ -48,6 +140,21 @@ var TaskConfigSchema = {
   additionalProperties: false
 };
 
+// src/task-graph/TransformRegistry.ts
+import { createServiceToken, globalServiceRegistry } from "@workglow/util";
+var transformDefs = new Map;
+var TransformRegistry = {
+  all: transformDefs,
+  registerTransform(def) {
+    transformDefs.set(def.id, def);
+  },
+  unregisterTransform(id) {
+    transformDefs.delete(id);
+  }
+};
+var TRANSFORM_DEFS = createServiceToken("transform.defs");
+globalServiceRegistry.registerIfAbsent(TRANSFORM_DEFS, () => TransformRegistry.all, true);
+
 // src/task-graph/Dataflow.ts
 var DATAFLOW_ALL_PORTS = "*";
 var DATAFLOW_ERROR_PORT = "[error]";
@@ -177,18 +284,62 @@ class Dataflow {
     return result;
   }
   toJSON() {
-    return {
+    const base = {
       sourceTaskId: this.sourceTaskId,
       sourceTaskPortId: this.sourceTaskPortId,
       targetTaskId: this.targetTaskId,
       targetTaskPortId: this.targetTaskPortId
     };
+    if (this._transforms.length > 0) {
+      base.transforms = this._transforms.map((s) => ({ id: s.id, params: s.params }));
+    }
+    return base;
   }
   _compatibilityCache;
+  _transforms = [];
+  getTransforms() {
+    return this._transforms;
+  }
+  setTransforms(steps) {
+    this._transforms = steps.map((s) => ({ id: s.id, params: s.params }));
+    this.invalidateCompatibilityCache();
+  }
+  addTransform(step) {
+    this._transforms.push({ id: step.id, params: step.params });
+    this.invalidateCompatibilityCache();
+  }
+  removeTransform(index) {
+    this._transforms.splice(index, 1);
+    this.invalidateCompatibilityCache();
+  }
+  async applyTransforms(registry) {
+    if (this._transforms.length === 0)
+      return;
+    const defs = registry.get(TRANSFORM_DEFS);
+    let cur = this.value;
+    try {
+      for (const step of this._transforms) {
+        const def = defs.get(step.id);
+        if (!def) {
+          throw new Error(`Unknown transform: ${step.id}`);
+        }
+        cur = await def.apply(cur, step.params ?? {});
+      }
+      this.value = cur;
+    } catch (e) {
+      const error = e instanceof TaskError ? e : new TaskError(e instanceof Error ? e.message : String(e));
+      if (!(e instanceof TaskError) && e instanceof Error && e.stack) {
+        error.stack = e.stack;
+      }
+      this.error = error;
+      this.setStatus(TaskStatus.FAILED);
+      throw e;
+    }
+  }
   invalidateCompatibilityCache() {
     this._compatibilityCache = undefined;
   }
-  semanticallyCompatible(graph, dataflow) {
+  semanticallyCompatible(graph, dataflow, registry) {
     const sourceTask = graph.getTask(dataflow.sourceTaskId);
     const targetTask = graph.getTask(dataflow.targetTaskId);
     const shouldCache = !(sourceTask.constructor.hasDynamicSchemas ?? true) && !(targetTask.constructor.hasDynamicSchemas ?? true);
@@ -217,7 +368,26 @@ class Dataflow {
     if (sourceSchemaProperty === undefined && sourceSchema.additionalProperties === true) {
       sourceSchemaProperty = true;
     }
-    const result = areSemanticallyCompatible(sourceSchemaProperty, targetSchemaProperty);
+    let effectiveSourceSchema = sourceSchemaProperty;
+    if (this._transforms.length > 0) {
+      const defs = registry ? registry.get(TRANSFORM_DEFS) : TransformRegistry.all;
+      try {
+        let cur = effectiveSourceSchema === true ? {} : effectiveSourceSchema;
+        for (const step of this._transforms) {
+          const def = defs.get(step.id);
+          if (!def) {
+            return "incompatible";
+          }
+          cur = def.inferOutputSchema(cur, step.params ?? {});
+        }
+        effectiveSourceSchema = cur;
+      } catch {
+        if (shouldCache)
+          this._compatibilityCache = "incompatible";
+        return "incompatible";
+      }
+    }
+    const result = areSemanticallyCompatible(effectiveSourceSchema, targetSchemaProperty);
     if (shouldCache) {
       this._compatibilityCache = result;
     }
@@ -636,7 +806,8 @@ function computeGraphInputSchema(graph, options) {
     for (const [inputName, inputProp] of Object.entries(taskProperties)) {
       if (!properties[inputName]) {
         properties[inputName] = inputProp;
-        if (taskInputSchema.required && taskInputSchema.required.includes(inputName)) {
+        const isRequired = taskInputSchema.required?.includes(inputName) === true && !(task.defaults && task.defaults[inputName] !== undefined);
+        if (isRequired) {
           required.push(inputName);
         }
         if (trackOrigins) {
@@ -949,6 +1120,7 @@ import { DirectedAcyclicGraph } from "@workglow/util/graph";
 
 // src/task/GraphAsTask.ts
 import { getLogger as getLogger4 } from "@workglow/util";
+import { CycleError } from "@workglow/util/graph";
 import { compileSchema as compileSchema2 } from "@workglow/util/schema";
 
 // src/task-graph/TaskGraphRunner.ts
@@ -956,15 +1128,15 @@ import {
   collectPropertyValues,
   getLogger as getLogger3,
   getTelemetryProvider as getTelemetryProvider2,
-  globalServiceRegistry as globalServiceRegistry2,
+  globalServiceRegistry as globalServiceRegistry3,
   ServiceRegistry as ServiceRegistry2,
   SpanStatusCode as SpanStatusCode2,
   uuid4 as uuid43
 } from "@workglow/util";
 
 // src/storage/TaskOutputRepository.ts
-import { createServiceToken, EventEmitter as EventEmitter2 } from "@workglow/util";
-var TASK_OUTPUT_REPOSITORY = createServiceToken("taskgraph.taskOutputRepository");
+import { createServiceToken as createServiceToken2, EventEmitter as EventEmitter2 } from "@workglow/util";
+var TASK_OUTPUT_REPOSITORY = createServiceToken2("taskgraph.taskOutputRepository");
 
 class TaskOutputRepository {
   outputCompression;
@@ -1066,103 +1238,11 @@ function getNestedValue(obj, path) {
 import { deepEqual, EventEmitter as EventEmitter3, uuid4 as uuid42 } from "@workglow/util";
 import { compileSchema } from "@workglow/util/schema";
 
-// src/task/TaskError.ts
-import { BaseError } from "@workglow/util";
-
-class TaskError extends BaseError {
-  static type = "TaskError";
-  taskType;
-  taskId;
-  constructor(message) {
-    super(message);
-  }
-}
-
-class TaskConfigurationError extends TaskError {
-  static type = "TaskConfigurationError";
-  constructor(message) {
-    super(message);
-  }
-}
-
-class WorkflowError extends TaskError {
-  static type = "WorkflowError";
-  constructor(message) {
-    super(message);
-  }
-}
-
-class TaskAbortedError extends TaskError {
-  static type = "TaskAbortedError";
-  constructor(message = "Task aborted") {
-    super(message);
-  }
-}
-
-class TaskTimeoutError extends TaskAbortedError {
-  static type = "TaskTimeoutError";
-  constructor(timeoutMs) {
-    super(timeoutMs ? `Task timed out after ${timeoutMs}ms` : "Task timed out");
-  }
-}
-
-class TaskGraphTimeoutError extends TaskTimeoutError {
-  static type = "TaskGraphTimeoutError";
-  constructor(timeoutMs) {
-    super(timeoutMs);
-    this.message = timeoutMs ? `Graph execution timed out after ${timeoutMs}ms` : "Graph execution timed out";
-  }
-}
-
-class TaskFailedError extends TaskError {
-  static type = "TaskFailedError";
-  constructor(message = "Task failed") {
-    super(message);
-  }
-}
-
-class JobTaskFailedError extends TaskFailedError {
-  static type = "JobTaskFailedError";
-  jobError;
-  constructor(err) {
-    super(String(err));
-    this.jobError = err;
-  }
-}
-
-class TaskJSONError extends TaskError {
-  static type = "TaskJSONError";
-  constructor(message = "Error converting JSON to a Task") {
-    super(message);
-  }
-}
-
-class TaskInvalidInputError extends TaskError {
-  static type = "TaskInvalidInputError";
-  constructor(message = "Invalid input data") {
-    super(message);
-  }
-}
-
-class TaskEntitlementError extends TaskError {
-  static type = "TaskEntitlementError";
-  constructor(message = "Required entitlements denied") {
-    super(message);
-  }
-}
-
-class TaskSerializationError extends TaskError {
-  static type = "TaskSerializationError";
-  constructor(taskType) {
-    super(`Task "${taskType}" cannot be serialized: config contains non-serializable values. ` + `Use a declarative config alternative or remove function-valued config properties.`);
-  }
-}
-
 // src/task/TaskRunner.ts
 import {
   getLogger,
   getTelemetryProvider,
-  globalServiceRegistry,
+  globalServiceRegistry as globalServiceRegistry2,
   SpanStatusCode
 } from "@workglow/util";
 
@@ -1278,7 +1358,7 @@ class TaskRunner {
   task;
   abortController;
   outputCache;
-  registry = globalServiceRegistry;
+  registry = globalServiceRegistry2;
   resourceScope;
   inputStreams;
   timeoutTimer;
@@ -1549,7 +1629,7 @@ class TaskRunner {
     });
     const cache = config.outputCache ?? this.task.runConfig?.outputCache;
     if (cache === true) {
-      let instance = globalServiceRegistry.get(TASK_OUTPUT_REPOSITORY);
+      let instance = globalServiceRegistry2.get(TASK_OUTPUT_REPOSITORY);
       this.outputCache = instance;
     } else if (cache === false) {
       this.outputCache = undefined;
@@ -2436,7 +2516,7 @@ class ConditionalTask extends Task {
 }
 
 // src/task/EntitlementEnforcer.ts
-import { createServiceToken as createServiceToken3 } from "@workglow/util";
+import { createServiceToken as createServiceToken4 } from "@workglow/util";
 
 // src/task/EntitlementPolicy.ts
 var EMPTY_POLICY = Object.freeze({
@@ -2473,9 +2553,14 @@ function evaluatePolicy(policy, required) {
   }
   return results;
 }
+function can(policy, id, resources) {
+  const required = resources !== undefined ? { id, resources } : { id };
+  const [result] = evaluatePolicy(policy, { entitlements: [required] });
+  return result;
+}
 
 // src/task/EntitlementResolver.ts
-import { createServiceToken as createServiceToken2 } from "@workglow/util";
+import { createServiceToken as createServiceToken3 } from "@workglow/util";
 var PERMISSIVE_RESOLVER = {
   lookup: () => "grant",
   prompt: async () => "grant",
@@ -2486,9 +2571,19 @@ var DENY_ALL_RESOLVER = {
   prompt: async () => "deny",
   save: () => {}
 };
-var ENTITLEMENT_RESOLVER = createServiceToken2("workglow.entitlementResolver");
+var ENTITLEMENT_RESOLVER = createServiceToken3("workglow.entitlementResolver");
 
 // src/task/EntitlementEnforcer.ts
+function formatEntitlementDenial(denial) {
+  switch (denial.reason) {
+    case "policy-deny":
+      return `${denial.entitlement.id} (denied by rule ${denial.matchedRule.id})`;
+    case "user-deny":
+      return `${denial.entitlement.id} (denied by user)`;
+    case "default-deny":
+      return `${denial.entitlement.id} (no matching grant)`;
+  }
+}
 var PERMISSIVE_ENFORCER = {
   checkAll: async () => [],
   checkTask: async () => []
@@ -2499,24 +2594,35 @@ function createPolicyEnforcer(policy, resolver = PERMISSIVE_RESOLVER) {
     const denied = [];
     for (const result of results) {
       if (result.verdict === "denied") {
-        denied.push(result.entitlement);
+        if (result.matchedRule) {
+          denied.push({
+            entitlement: result.entitlement,
+            reason: "policy-deny",
+            matchedRule: result.matchedRule
+          });
+        } else {
+          denied.push({ entitlement: result.entitlement, reason: "default-deny" });
+        }
       } else if (result.verdict === "ask") {
         const request = {
           entitlement: result.entitlement,
           taskType: taskType ?? "unknown",
           taskId: taskId ?? "unknown"
         };
-        const saved = resolver.lookup(request);
-        if (saved !== undefined) {
-          if (saved === "deny") {
-            denied.push(result.entitlement);
-          }
-          continue;
+        let answer = resolver.lookup(request);
+        if (answer === undefined) {
+          answer = await resolver.prompt(request);
+          resolver.save(request, answer);
         }
-        const answer = await resolver.prompt(request);
-        resolver.save(request, answer);
         if (answer === "deny") {
-          denied.push(result.entitlement);
+          if (!result.matchedRule) {
+            throw new Error(`Invariant violation: ask verdict for "${result.entitlement.id}" is missing matchedRule`);
+          }
+          denied.push({
+            entitlement: result.entitlement,
+            reason: "user-deny",
+            matchedRule: result.matchedRule
+          });
         }
       }
     }
@@ -2538,7 +2644,7 @@ function createScopedEnforcer(grants) {
 function createGrantListEnforcer(grants) {
   return createScopedEnforcer(grants.map((id) => ({ id })));
 }
-var ENTITLEMENT_ENFORCER = createServiceToken3("workglow.entitlementEnforcer");
+var ENTITLEMENT_ENFORCER = createServiceToken4("workglow.entitlementEnforcer");
 
 // src/task-graph/TaskGraphScheduler.ts
 class TopologicalScheduler {
@@ -2702,7 +2808,7 @@ class TaskGraphRunner {
   graph;
   outputCache;
   accumulateLeafOutputs = true;
-  registry = globalServiceRegistry2;
+  registry = globalServiceRegistry3;
   resourceScope;
   abortController;
   inProgressTasks = new Map;
@@ -2784,6 +2890,21 @@ class TaskGraphRunner {
   }
   async runGraphReactive(input = {}, config) {
     await this.handleStartReactive(config);
+    const telemetry = getTelemetryProvider2();
+    const telemetryEnabled = telemetry.isEnabled;
+    const reactiveRunId = telemetryEnabled ? uuid43() : "";
+    let reactiveSpan;
+    if (telemetryEnabled) {
+      reactiveSpan = telemetry.startSpan("workglow.graph.runReactive", {
+        attributes: {
+          "workglow.graph.reactive.run_id": reactiveRunId,
+          "workglow.graph.task_count": this.graph.getTasks().length,
+          "workglow.graph.dataflow_count": this.graph.getDataflows().length
+        }
+      });
+    }
+    const t0 = telemetryEnabled ? performance.now() : 0;
+    const taskTimings = [];
     const results = [];
     try {
       for await (const task of this.reactiveScheduler.tasks()) {
@@ -2793,20 +2914,68 @@ class TaskGraphRunner {
           this.copyInputFromEdgesToNode(task);
         }
         const taskInput = isRootTask ? input : {};
-        const taskResult = await task.runReactive(taskInput);
-        await this.pushOutputFromNodeToEdges(task, taskResult);
-        if (this.graph.getTargetDataflows(task.id).length === 0) {
-          results.push({
-            id: task.id,
-            type: task.constructor.runtype || task.constructor.type,
-            data: taskResult
-          });
+        if (telemetryEnabled) {
+          const taskType = String(task.constructor.runtype || task.constructor.type || "?");
+          const tReactive = performance.now();
+          const taskResult = await task.runReactive(taskInput);
+          const runReactiveMs = performance.now() - tReactive;
+          const tPush = performance.now();
+          await this.pushOutputFromNodeToEdges(task, taskResult);
+          const pushOutputMs = performance.now() - tPush;
+          taskTimings.push({ id: task.id, type: taskType, runReactiveMs, pushOutputMs });
+          if (this.graph.getTargetDataflows(task.id).length === 0) {
+            results.push({
+              id: task.id,
+              type: task.constructor.runtype || task.constructor.type,
+              data: taskResult
+            });
+          }
+        } else {
+          const taskResult = await task.runReactive(taskInput);
+          await this.pushOutputFromNodeToEdges(task, taskResult);
+          if (this.graph.getTargetDataflows(task.id).length === 0) {
+            results.push({
+              id: task.id,
+              type: task.constructor.runtype || task.constructor.type,
+              data: taskResult
+            });
+          }
         }
       }
       await this.handleCompleteReactive();
+      if (reactiveSpan) {
+        const totalMs = performance.now() - t0;
+        reactiveSpan.setAttributes({
+          "workglow.graph.reactive.duration_ms": Math.round(totalMs * 1000) / 1000,
+          "workglow.graph.reactive.tasks_executed": taskTimings.length
+        });
+        reactiveSpan.setStatus(SpanStatusCode2.OK);
+        reactiveSpan.end();
+        getLogger3().debug("task graph runReactive timings", {
+          reactiveRunId,
+          totalMs: Math.round(totalMs * 1000) / 1000,
+          taskTimings
+        });
+      }
       return this.filterLeafResults(results);
     } catch (error) {
       await this.handleErrorReactive();
+      if (reactiveSpan) {
+        const totalMs = performance.now() - t0;
+        const message = error instanceof Error ? error.message : String(error);
+        reactiveSpan.setAttributes({
+          "workglow.graph.reactive.duration_ms": Math.round(totalMs * 1000) / 1000,
+          "workglow.graph.reactive.tasks_executed": taskTimings.length
+        });
+        reactiveSpan.setStatus(SpanStatusCode2.ERROR, message);
+        reactiveSpan.end();
+        getLogger3().debug("task graph runReactive failed", {
+          reactiveRunId,
+          totalMs: Math.round(totalMs * 1000) / 1000,
+          taskTimings,
+          error
+        });
+      }
       throw error;
     }
   }
@@ -2874,13 +3043,17 @@ class TaskGraphRunner {
   async pushOutputFromNodeToEdges(node, results) {
     const dataflows = this.graph.getTargetDataflows(node.id);
     for (const dataflow of dataflows) {
-      const compatibility = dataflow.semanticallyCompatible(this.graph, dataflow);
+      if (dataflow.stream !== undefined)
+        continue;
+      const compatibility = dataflow.semanticallyCompatible(this.graph, dataflow, this.registry);
       if (compatibility === "static") {
         dataflow.setPortData(results);
+        await dataflow.applyTransforms(this.registry);
       } else if (compatibility === "runtime") {
         const task = this.graph.getTask(dataflow.targetTaskId);
         const narrowed = await task.narrowInput({ ...results }, this.registry);
         dataflow.setPortData(narrowed);
+        await dataflow.applyTransforms(this.registry);
       } else {
         const resultsKeys = Object.keys(results);
         if (resultsKeys.length > 0) {
@@ -2906,6 +3079,8 @@ class TaskGraphRunner {
       }
       const activeBranches = node.getActiveBranches();
       for (const dataflow of dataflows) {
+        if (dataflow.status === TaskStatus.FAILED)
+          continue;
         const branchId = portToBranch.get(dataflow.sourceTaskPortId);
         if (branchId !== undefined) {
           if (activeBranches.has(branchId)) {
@@ -2921,6 +3096,8 @@ class TaskGraphRunner {
       return;
     }
     dataflows.forEach((dataflow) => {
+      if (dataflow.status === TaskStatus.FAILED)
+        return;
       dataflow.setStatus(effectiveStatus);
     });
   }
@@ -3024,7 +3201,7 @@ class TaskGraphRunner {
     if (this.activeEnforcer && task.constructor.hasDynamicEntitlements) {
       const denied = await this.activeEnforcer.checkTask(task);
       if (denied.length > 0) {
-        throw new TaskEntitlementError(`Task ${task.constructor.type} denied entitlements: ${denied.map((e) => e.id).join(", ")}`);
+        throw new TaskEntitlementError(`Task ${task.constructor.type} denied entitlements: ${denied.map(formatEntitlementDenial).join(", ")}`);
       }
     }
     if (isStreamable) {
@@ -3045,10 +3222,13 @@ class TaskGraphRunner {
   }
   async awaitStreamInputs(task) {
     const dataflows = this.graph.getSourceDataflows(task.id);
-    const streamPromises = dataflows.filter((df) => df.stream !== undefined).map((df) => df.awaitStreamValue());
-    if (streamPromises.length > 0) {
-      await Promise.all(streamPromises);
-    }
+    const streamingDataflows = dataflows.filter((df) => df.stream !== undefined);
+    if (streamingDataflows.length === 0)
+      return;
+    await Promise.all(streamingDataflows.map(async (df) => {
+      await df.awaitStreamValue();
+      await df.applyTransforms(this.registry);
+    }));
   }
   async runStreamingTask(task, input) {
     const streamMode = getOutputStreamMode(task.outputSchema());
@@ -3183,7 +3363,7 @@ class TaskGraphRunner {
     if (config?.registry !== undefined) {
       this.registry = config.registry;
     } else if (this.registry === undefined) {
-      this.registry = new ServiceRegistry2(globalServiceRegistry2.container.createChildContainer());
+      this.registry = new ServiceRegistry2(globalServiceRegistry3.container.createChildContainer());
     }
     if (config?.resourceScope !== undefined) {
       this.resourceScope = config.resourceScope;
@@ -3247,7 +3427,7 @@ class TaskGraphRunner {
         const enforcer = this.registry.get(ENTITLEMENT_ENFORCER);
         const denied = await enforcer.checkAll(computeGraphEntitlements(this.graph));
         if (denied.length > 0) {
-          throw new TaskEntitlementError(`Denied entitlements: ${denied.map((e) => e.id).join(", ")}`);
+          throw new TaskEntitlementError(`Denied entitlements: ${denied.map(formatEntitlementDenial).join(", ")}`);
         }
         this.activeEnforcer = enforcer;
       } else {
@@ -3591,11 +3771,23 @@ class GraphAsTask extends Task {
       yield { type: "finish", data: input };
     }
   }
-  regenerateGraph() {
-    this._inputSchemaNode = undefined;
-    this.events.emit("regenerate");
-    this.emitEntitlementChange();
-  }
+  validateAcyclic() {
+    if (!this.hasChildren())
+      return;
+    if (!this.subGraph.isAcyclic()) {
+      throw new CycleError(`${this.type} (${this.id}): subgraph contains a cycle — loop tasks must wrap an acyclic subgraph.`);
+    }
+    for (const child of this.subGraph.getTasks()) {
+      if (child instanceof GraphAsTask) {
+        child.validateAcyclic();
+      }
+    }
+  }
+  regenerateGraph() {
+    this._inputSchemaNode = undefined;
+    this.events.emit("regenerate");
+    this.emitEntitlementChange();
+  }
   _entitlementUnsub;
   _subscribingEntitlements = false;
   _subscribeToSubGraphEntitlements(graph) {
@@ -3741,7 +3933,7 @@ function convertPipeFunctionToTask(fn, config) {
         properties: {
           [DATAFLOW_ALL_PORTS]: {}
         },
-        additionalProperties: false
+        additionalProperties: true
       };
     };
     static outputSchema = () => {
@@ -3750,7 +3942,7 @@ function convertPipeFunctionToTask(fn, config) {
         properties: {
           [DATAFLOW_ALL_PORTS]: {}
         },
-        additionalProperties: false
+        additionalProperties: true
       };
     };
     static cacheable = false;
@@ -3859,6 +4051,9 @@ class TaskGraph {
   topologicallySortedNodes() {
     return this._dag.topologicallySortedNodes();
   }
+  isAcyclic() {
+    return this._dag.isAcyclic();
+  }
   addTask(task, config) {
     return this._dag.addNode(ensureTask(task, config));
   }
@@ -4132,7 +4327,315 @@ function serialGraph(tasks, inputHandle, outputHandle) {
   return graph;
 }
 // src/task-graph/Workflow.ts
-import { EventEmitter as EventEmitter5, getLogger as getLogger5, uuid4 as uuid45 } from "@workglow/util";
+import { EventEmitter as EventEmitter5, getLogger as getLogger5, uuid4 as uuid46 } from "@workglow/util";
+
+// src/task-graph/autoConnect.ts
+function autoConnect(graph, sourceTask, targetTask, options) {
+  const matches = new Map;
+  const sourceSchema = sourceTask.outputSchema();
+  const targetSchema = targetTask.inputSchema();
+  const providedInputKeys = options?.providedInputKeys ?? new Set;
+  const connectedInputKeys = options?.connectedInputKeys ?? new Set;
+  const earlierTasks = options?.earlierTasks ?? [];
+  const dryRun = options?.dryRun ?? false;
+  const addDataflow = (df) => {
+    if (!dryRun)
+      graph.addDataflow(df);
+  };
+  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) {
+        const outputKeys = Object.keys(fromSchema.properties || {});
+        if (outputKeys.length > 0) {
+          for (const fromOutputPortId of outputKeys) {
+            if (matches.has(fromOutputPortId))
+              continue;
+            matches.set(fromOutputPortId, fromOutputPortId);
+            addDataflow(new Dataflow(fromTaskId, fromOutputPortId, toTaskId, fromOutputPortId));
+          }
+        } else if (fromSchema.additionalProperties === true) {
+          const sourceGraphTask = graph.getTask(fromTaskId);
+          if (sourceGraphTask && sourceGraphTask.constructor.passthroughInputsToOutputs === true) {
+            const incomingDfs = graph.getSourceDataflows(fromTaskId);
+            for (const df of incomingDfs) {
+              const portId = df.targetTaskPortId;
+              if (portId === DATAFLOW_ALL_PORTS)
+                continue;
+              if (matches.has(portId))
+                continue;
+              if (connectedInputKeys.has(portId))
+                continue;
+              matches.set(portId, portId);
+              addDataflow(new Dataflow(fromTaskId, portId, toTaskId, portId));
+            }
+          }
+        }
+        return;
+      }
+    }
+    if (typeof fromSchema === "object" && fromSchema.additionalProperties === true && typeof toSchema === "object" && (sourceTask.type === "InputTask" || sourceTask.type === "OutputTask")) {
+      for (const toInputPortId of Object.keys(toSchema.properties || {})) {
+        if (matches.has(toInputPortId))
+          continue;
+        if (connectedInputKeys.has(toInputPortId))
+          continue;
+        matches.set(toInputPortId, toInputPortId);
+        addDataflow(new Dataflow(fromTaskId, toInputPortId, toTaskId, toInputPortId));
+      }
+      return;
+    }
+    if (typeof fromSchema === "boolean" || typeof toSchema === "boolean") {
+      return;
+    }
+    for (const [toInputPortId, toPortInputSchema] of Object.entries(toSchema.properties || {})) {
+      if (matches.has(toInputPortId))
+        continue;
+      if (connectedInputKeys.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);
+      addDataflow(new Dataflow(fromTaskId, winner, toTaskId, toInputPortId));
+    }
+  };
+  makeMatch(sourceSchema, targetSchema, sourceTask.id, targetTask.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.id, targetTask.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) && !connectedInputKeys.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();
+      if (earlierTask.type === "InputTask") {
+        const inputConfig = earlierTask.config;
+        const inputSchema = inputConfig?.inputSchema ?? inputConfig?.outputSchema;
+        const isManualSchema = inputSchema && typeof inputSchema === "object" && inputSchema["x-ui-manual"] === true;
+        const inputProperties = isManualSchema && inputSchema && typeof inputSchema === "object" && "properties" in inputSchema && inputSchema.properties && typeof inputSchema.properties === "object" ? new Set(Object.keys(inputSchema.properties)) : undefined;
+        for (const requiredInputId of [...unmatchedRequired]) {
+          if (matches.has(requiredInputId))
+            continue;
+          if (inputProperties && !inputProperties.has(requiredInputId))
+            continue;
+          matches.set(requiredInputId, requiredInputId);
+          addDataflow(new Dataflow(earlierTask.id, requiredInputId, targetTask.id, requiredInputId));
+        }
+        unmatchedRequired = unmatchedRequired.filter((r) => !matches.has(r));
+        continue;
+      }
+      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);
+              addDataflow(new Dataflow(earlierTask.id, fromOutputPortId, targetTask.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 existingTargetConnections = graph.getSourceDataflows(targetTask.id);
+    if (existingTargetConnections.length > 0) {
+      return { matches, unmatchedRequired: [] };
+    }
+    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: []
+  };
+}
+
+// src/task-graph/ConditionalBuilder.ts
+import { uuid4 as uuid45 } from "@workglow/util";
+class ConditionalBuilder {
+  workflow;
+  condition;
+  thenSpec;
+  elseSpec;
+  constructor(workflow, condition) {
+    this.workflow = workflow;
+    this.condition = condition;
+  }
+  then(taskClass, input, config) {
+    this.thenSpec = { taskClass, input, config };
+    return this;
+  }
+  else(taskClass, input, config) {
+    this.elseSpec = { taskClass, input, config };
+    return this;
+  }
+  endIf() {
+    if (!this.thenSpec) {
+      throw new WorkflowError(".endIf() called without a prior .then(...) call");
+    }
+    const thenPort = "then";
+    const elsePort = "else";
+    const branches = [
+      {
+        id: thenPort,
+        condition: this.condition,
+        outputPort: thenPort
+      }
+    ];
+    if (this.elseSpec) {
+      branches.push({
+        id: elsePort,
+        condition: (input) => !this.condition(input),
+        outputPort: elsePort
+      });
+    }
+    const conditionalTask = new ConditionalTask({
+      id: uuid45(),
+      branches,
+      exclusive: true,
+      defaultBranch: this.elseSpec ? elsePort : undefined
+    });
+    this.workflow.graph.addTask(conditionalTask);
+    const thenTask = instantiate(this.thenSpec);
+    this.workflow.graph.addTask(thenTask);
+    this.workflow.graph.addDataflow(new Dataflow(conditionalTask.id, thenPort, thenTask.id, "*"));
+    if (this.elseSpec) {
+      const elseTask = instantiate(this.elseSpec);
+      this.workflow.graph.addTask(elseTask);
+      this.workflow.graph.addDataflow(new Dataflow(conditionalTask.id, elsePort, elseTask.id, "*"));
+    }
+    return this.workflow;
+  }
+}
+function instantiate(spec) {
+  const config = {
+    id: uuid45(),
+    ...spec.config,
+    defaults: spec.input
+  };
+  return new spec.taskClass(config);
+}
+
+// src/task-graph/Workflow.ts
 function getLastTask(workflow) {
   const tasks = workflow.graph.getTasks();
   return tasks.length > 0 ? tasks[tasks.length - 1] : undefined;
@@ -4275,7 +4778,7 @@ class Workflow {
       this._error = "";
       const parent = getLastTask(this);
       const task = this.addTaskToGraph(taskClass, {
-        id: uuid45(),
+        id: uuid46(),
         ...config,
         defaults: input
       });
@@ -4429,8 +4932,10 @@ class Workflow {
   static parallel(args, mergeFn) {
     return parallel(args, mergeFn ?? PROPERTY_ARRAY, new Workflow);
   }
-  rename(source, target, index = -1) {
+  rename(source, target, indexOrOptions = -1) {
     this._error = "";
+    const index = typeof indexOrOptions === "number" ? indexOrOptions : indexOrOptions.index ?? -1;
+    const transforms = typeof indexOrOptions === "number" ? undefined : indexOrOptions.transforms;
     const nodes = this._graph.getTasks();
     if (-index > nodes.length) {
       const errorMsg = `Back index greater than number of tasks`;
@@ -4453,7 +4958,10 @@ class Workflow {
       getLogger5().error(this._error);
       throw new WorkflowError(errorMsg);
     }
-    this._dataFlows.push(new Dataflow(lastNode.id, source, undefined, target));
+    const df = new Dataflow(lastNode.id, source, undefined, target);
+    if (transforms && transforms.length > 0)
+      df.setTransforms(transforms);
+    this._dataFlows.push(df);
     return this;
   }
   onError(handler) {
@@ -4556,7 +5064,11 @@ class Workflow {
   addLoopTask(taskClass, config = {}) {
     this._error = "";
     const parent = getLastTask(this);
-    const task = this.addTaskToGraph(taskClass, { id: uuid45(), ...config });
+    const schema = taskClass.configSchema?.();
+    const required = typeof schema === "object" && schema !== null ? schema.required : undefined;
+    const needsMaxIterations = Array.isArray(required) && required.includes("maxIterations");
+    const resolvedConfig = needsMaxIterations && config.maxIterations === undefined ? { ...config, maxIterations: "unbounded" } : config;
+    const task = this.addTaskToGraph(taskClass, { id: uuid46(), ...resolvedConfig });
     if (this._dataFlows.length > 0) {
       this._dataFlows.forEach((dataflow) => {
         const taskSchema = task.inputSchema();
@@ -4576,6 +5088,9 @@ class Workflow {
     }
     return loopBuilder;
   }
+  if(condition) {
+    return new ConditionalBuilder(this, condition);
+  }
   autoConnectLoopTask(pending) {
     if (!pending)
       return;
@@ -4696,243 +5211,14 @@ class Workflow {
   }
   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 connectedInputKeys = options?.connectedInputKeys ?? 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) {
-          const outputKeys = Object.keys(fromSchema.properties || {});
-          if (outputKeys.length > 0) {
-            for (const fromOutputPortId of outputKeys) {
-              if (matches.has(fromOutputPortId))
-                continue;
-              matches.set(fromOutputPortId, fromOutputPortId);
-              graph.addDataflow(new Dataflow(fromTaskId, fromOutputPortId, toTaskId, fromOutputPortId));
-            }
-          } else if (fromSchema.additionalProperties === true) {
-            const sourceGraphTask = graph.getTask(fromTaskId);
-            if (sourceGraphTask && sourceGraphTask.constructor.passthroughInputsToOutputs === true) {
-              const incomingDfs = graph.getSourceDataflows(fromTaskId);
-              for (const df of incomingDfs) {
-                const portId = df.targetTaskPortId;
-                if (portId === DATAFLOW_ALL_PORTS)
-                  continue;
-                if (matches.has(portId))
-                  continue;
-                if (connectedInputKeys.has(portId))
-                  continue;
-                matches.set(portId, portId);
-                graph.addDataflow(new Dataflow(fromTaskId, portId, toTaskId, portId));
-              }
-            }
-          }
-          return;
-        }
-      }
-      if (typeof fromSchema === "object" && fromSchema.additionalProperties === true && typeof toSchema === "object" && (sourceTask.type === "InputTask" || sourceTask.type === "OutputTask")) {
-        for (const toInputPortId of Object.keys(toSchema.properties || {})) {
-          if (matches.has(toInputPortId))
-            continue;
-          if (connectedInputKeys.has(toInputPortId))
-            continue;
-          matches.set(toInputPortId, toInputPortId);
-          graph.addDataflow(new Dataflow(fromTaskId, toInputPortId, toTaskId, toInputPortId));
-        }
-        return;
-      }
-      if (typeof fromSchema === "boolean" || typeof toSchema === "boolean") {
-        return;
-      }
-      for (const [toInputPortId, toPortInputSchema] of Object.entries(toSchema.properties || {})) {
-        if (matches.has(toInputPortId))
-          continue;
-        if (connectedInputKeys.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.id, targetTask.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.id, targetTask.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) && !connectedInputKeys.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();
-        if (earlierTask.type === "InputTask") {
-          const inputConfig = earlierTask.config;
-          const inputSchema = inputConfig?.inputSchema ?? inputConfig?.outputSchema;
-          const isManualSchema = inputSchema && typeof inputSchema === "object" && inputSchema["x-ui-manual"] === true;
-          const inputProperties = isManualSchema && inputSchema && typeof inputSchema === "object" && "properties" in inputSchema && inputSchema.properties && typeof inputSchema.properties === "object" ? new Set(Object.keys(inputSchema.properties)) : undefined;
-          for (const requiredInputId of [...unmatchedRequired]) {
-            if (matches.has(requiredInputId))
-              continue;
-            if (inputProperties && !inputProperties.has(requiredInputId))
-              continue;
-            matches.set(requiredInputId, requiredInputId);
-            graph.addDataflow(new Dataflow(earlierTask.id, requiredInputId, targetTask.id, requiredInputId));
-          }
-          unmatchedRequired = unmatchedRequired.filter((r) => !matches.has(r));
-          continue;
-        }
-        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.id, fromOutputPortId, targetTask.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 existingTargetConnections = graph.getSourceDataflows(targetTask.id);
-      if (existingTargetConnections.length > 0) {
-        return { matches, unmatchedRequired: [] };
-      }
-      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: []
-    };
+    return autoConnect(graph, sourceTask, targetTask, options);
   }
   finalizeTemplate() {
     if (!this._iteratorTask || this.graph.getTasks().length === 0) {
       return;
     }
     this._iteratorTask.subGraph = this.graph;
+    this._iteratorTask.validateAcyclic();
   }
   finalizeAndReturn() {
     if (!this._parentWorkflow) {
@@ -4967,6 +5253,7 @@ function getMethodNameMap() {
 }
 var LOOP_TASK_TYPES = {
   MapTask: { method: "map", endMethod: "endMap" },
+  ForEachTask: { method: "forEach", endMethod: "endForEach" },
   ReduceTask: { method: "reduce", endMethod: "endReduce" },
   WhileTask: { method: "while", endMethod: "endWhile" },
   GraphAsTask: { method: "group", endMethod: "endGroup" }
@@ -5149,7 +5436,8 @@ function extractLoopConfig(task) {
       }
       break;
     }
-    case "MapTask": {
+    case "MapTask":
+    case "ForEachTask": {
       if (rawConfig.preserveOrder !== undefined && rawConfig.preserveOrder !== true) {
         config.preserveOrder = rawConfig.preserveOrder;
       }
@@ -5162,16 +5450,22 @@ function extractLoopConfig(task) {
       if (rawConfig.batchSize !== undefined) {
         config.batchSize = rawConfig.batchSize;
       }
+      if (rawConfig.maxIterations !== undefined) {
+        config.maxIterations = rawConfig.maxIterations;
+      }
       break;
     }
     case "ReduceTask": {
       if (rawConfig.initialValue !== undefined) {
         config.initialValue = rawConfig.initialValue;
       }
+      if (rawConfig.maxIterations !== undefined) {
+        config.maxIterations = rawConfig.maxIterations;
+      }
       break;
     }
     case "WhileTask": {
-      if (rawConfig.maxIterations !== undefined && rawConfig.maxIterations !== 100) {
+      if (rawConfig.maxIterations !== undefined) {
         config.maxIterations = rawConfig.maxIterations;
       }
       if (rawConfig.chainIterations !== undefined && rawConfig.chainIterations !== true) {
@@ -5281,6 +5575,304 @@ ${baseIndent}}`;
 function resetMethodNameCache() {
   methodNameCache = undefined;
 }
+// src/task-graph/transforms/pick.ts
+import { areSemanticallyCompatible as areSemanticallyCompatible2 } from "@workglow/util/schema";
+function walk(value, path) {
+  if (value == null)
+    return;
+  const parts = path.split(".");
+  let cur = value;
+  for (const p of parts) {
+    if (cur == null)
+      return;
+    cur = cur[p];
+  }
+  return cur;
+}
+function walkSchema(schema, path) {
+  const parts = path.split(".");
+  let cur = schema;
+  for (const p of parts) {
+    if (!cur || typeof cur !== "object")
+      return {};
+    if (cur.type !== "object" || !cur.properties || !cur.properties[p]) {
+      return {};
+    }
+    cur = cur.properties[p];
+  }
+  return cur;
+}
+var pickTransform = {
+  id: "pick",
+  title: "Pick field",
+  category: "Structural",
+  paramsSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Dotted property path" }
+    },
+    required: ["path"]
+  },
+  inferOutputSchema(inputSchema, params) {
+    return walkSchema(inputSchema, params.path);
+  },
+  apply(value, params) {
+    return walk(value, params.path);
+  },
+  suggestFromSchemas(source, target) {
+    if (source.type !== "object" || !source.properties) {
+      return;
+    }
+    const props = source.properties;
+    for (const [name, propSchema] of Object.entries(props)) {
+      const compat = areSemanticallyCompatible2(propSchema, target);
+      if (compat === "static")
+        return { score: 1, params: { path: name } };
+      if (compat === "runtime")
+        return { score: 0.6, params: { path: name } };
+    }
+    return;
+  }
+};
+
+// src/task-graph/transforms/index-access.ts
+import { areSemanticallyCompatible as areSemanticallyCompatible3 } from "@workglow/util/schema";
+function doIndex(value, idx) {
+  if (!Array.isArray(value))
+    return;
+  const i = idx < 0 ? value.length + idx : idx;
+  return value[i];
+}
+var indexTransform = {
+  id: "index",
+  title: "Array index",
+  category: "Structural",
+  paramsSchema: {
+    type: "object",
+    properties: {
+      index: { type: "integer", description: "Array index (negative counts from end)" }
+    },
+    required: ["index"]
+  },
+  inferOutputSchema(inputSchema) {
+    const s = inputSchema;
+    if (s?.type === "array" && s.items)
+      return s.items;
+    return {};
+  },
+  apply(value, params) {
+    return doIndex(value, params.index);
+  },
+  suggestFromSchemas(source, target) {
+    const s = source;
+    if (s?.type !== "array" || !s.items)
+      return;
+    const compat = areSemanticallyCompatible3(s.items, target);
+    if (compat === "static")
+      return { score: 0.9, params: { index: 0 } };
+    if (compat === "runtime")
+      return { score: 0.5, params: { index: 0 } };
+    return;
+  }
+};
+
+// src/task-graph/transforms/coalesce.ts
+function stripNullable(schema) {
+  const s = schema;
+  if (!s || typeof s !== "object")
+    return schema;
+  if (Array.isArray(s.type)) {
+    const nonNull = s.type.filter((t) => t !== "null");
+    if (nonNull.length === 1)
+      return { ...s, type: nonNull[0] };
+    return { ...s, type: nonNull };
+  }
+  return schema;
+}
+var coalesceTransform = {
+  id: "coalesce",
+  title: "Coalesce null",
+  category: "Conversion",
+  paramsSchema: {
+    type: "object",
+    properties: { defaultValue: {} },
+    required: ["defaultValue"]
+  },
+  inferOutputSchema: (input) => stripNullable(input),
+  apply: (v, { defaultValue }) => v == null ? defaultValue : v
+};
+
+// src/task-graph/transforms/string-casts.ts
+var stringSchema = { type: "string" };
+var uppercaseTransform = {
+  id: "uppercase",
+  title: "Uppercase",
+  category: "String",
+  paramsSchema: undefined,
+  inferOutputSchema: () => stringSchema,
+  apply: (v) => String(v ?? "").toUpperCase()
+};
+var lowercaseTransform = {
+  id: "lowercase",
+  title: "Lowercase",
+  category: "String",
+  paramsSchema: undefined,
+  inferOutputSchema: () => stringSchema,
+  apply: (v) => String(v ?? "").toLowerCase()
+};
+var truncateTransform = {
+  id: "truncate",
+  title: "Truncate",
+  category: "String",
+  paramsSchema: {
+    type: "object",
+    properties: { max: { type: "integer", minimum: 0 } },
+    required: ["max"]
+  },
+  inferOutputSchema: () => stringSchema,
+  apply: (v, { max }) => String(v ?? "").slice(0, max)
+};
+var substringTransform = {
+  id: "substring",
+  title: "Substring",
+  category: "String",
+  paramsSchema: {
+    type: "object",
+    properties: {
+      start: { type: "integer" },
+      end: { type: "integer" }
+    },
+    required: ["start"]
+  },
+  inferOutputSchema: () => stringSchema,
+  apply: (v, { start, end }) => String(v ?? "").slice(start, end)
+};
+
+// src/task-graph/transforms/date-conversions.ts
+var isoSchema = { type: "string", format: "date-time" };
+var numberSchema = { type: "number" };
+function hasDateTimeFormat(schema) {
+  const s = schema;
+  return s?.type === "string" && s.format === "date-time";
+}
+var unixToIsoDateTransform = {
+  id: "unixToIsoDate",
+  title: "Unix timestamp → ISO date",
+  category: "Date",
+  paramsSchema: {
+    type: "object",
+    properties: {
+      unit: { type: "string", enum: ["s", "ms"] }
+    },
+    required: ["unit"]
+  },
+  inferOutputSchema: () => isoSchema,
+  apply: (v, { unit }) => {
+    const n = Number(v);
+    return new Date(unit === "s" ? n * 1000 : n).toISOString();
+  },
+  suggestFromSchemas(source, target) {
+    const s = source;
+    if (s?.type !== "number" && s?.type !== "integer")
+      return;
+    if (!hasDateTimeFormat(target))
+      return;
+    return { score: 0.85, params: { unit: "s" } };
+  }
+};
+var isoDateToUnixTransform = {
+  id: "isoDateToUnix",
+  title: "ISO date → Unix ms",
+  category: "Date",
+  paramsSchema: undefined,
+  inferOutputSchema: () => numberSchema,
+  apply: (v) => new Date(String(v)).getTime(),
+  suggestFromSchemas(source, target) {
+    if (!hasDateTimeFormat(source))
+      return;
+    const t = target;
+    if (t?.type !== "number" && t?.type !== "integer")
+      return;
+    return { score: 0.9, params: {} };
+  }
+};
+
+// src/task-graph/transforms/scalar-conversions.ts
+var stringSchema2 = { type: "string" };
+var booleanSchema = { type: "boolean" };
+var numberToStringTransform = {
+  id: "numberToString",
+  title: "Number → String",
+  category: "Conversion",
+  paramsSchema: undefined,
+  inferOutputSchema: () => stringSchema2,
+  apply: (v) => String(v),
+  suggestFromSchemas(source, target) {
+    const s = source;
+    const t = target;
+    if ((s?.type === "number" || s?.type === "integer") && t?.type === "string") {
+      return { score: 0.8, params: {} };
+    }
+    return;
+  }
+};
+var toBooleanTransform = {
+  id: "toBoolean",
+  title: "To Boolean",
+  category: "Conversion",
+  paramsSchema: undefined,
+  inferOutputSchema: () => booleanSchema,
+  apply: (v) => {
+    if (typeof v === "boolean")
+      return v;
+    if (typeof v === "number")
+      return v !== 0;
+    if (typeof v === "string")
+      return v.toLowerCase() === "true" || v === "1";
+    return Boolean(v);
+  }
+};
+var stringifyTransform = {
+  id: "stringify",
+  title: "JSON.stringify",
+  category: "Conversion",
+  paramsSchema: undefined,
+  inferOutputSchema: () => stringSchema2,
+  apply: (v) => JSON.stringify(v),
+  suggestFromSchemas(source, target) {
+    const t = target;
+    return t?.type === "string" ? { score: 0.4, params: {} } : undefined;
+  }
+};
+var parseJsonTransform = {
+  id: "parseJson",
+  title: "Parse JSON",
+  category: "Conversion",
+  paramsSchema: undefined,
+  inferOutputSchema: () => ({}),
+  apply: (v) => JSON.parse(String(v))
+};
+
+// src/task-graph/transforms/index.ts
+function registerBuiltInTransforms() {
+  const all = [
+    pickTransform,
+    indexTransform,
+    coalesceTransform,
+    uppercaseTransform,
+    lowercaseTransform,
+    truncateTransform,
+    substringTransform,
+    unixToIsoDateTransform,
+    isoDateToUnixTransform,
+    numberToStringTransform,
+    toBooleanTransform,
+    stringifyTransform,
+    parseJsonTransform
+  ];
+  for (const t of all)
+    TransformRegistry.registerTransform(t);
+}
 // src/task/EntitlementProfiles.ts
 var BROWSER_GRANTS = [
   { id: Entitlements.NETWORK_HTTP },
@@ -5609,15 +6201,15 @@ async function compactSchemaInputs(input, schema, config, visited = new Set) {
   return compacted;
 }
 // src/task/IteratorTaskRunner.ts
-import { uuid4 as uuid46 } from "@workglow/util";
+import { uuid4 as uuid47 } from "@workglow/util";
 class IteratorTaskRunner extends GraphAsTaskRunner {
   aggregatingParentMapProgress = false;
   mapPartialProgress = [];
   mapPartialIterationCount = 0;
   async executeTask(input) {
     let analysis = this.task.analyzeIterationInput(input);
-    const maxIterations = this.task.config.maxIterations;
-    if (maxIterations !== undefined && maxIterations > 0 && analysis.iterationCount > maxIterations) {
+    const maxIterations = resolveIterationBound(this.task.config.maxIterations);
+    if (analysis.iterationCount > maxIterations) {
       analysis = { ...analysis, iterationCount: maxIterations };
     }
     if (analysis.iterationCount === 0) {
@@ -5723,7 +6315,7 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
     const idMap = new Map;
     for (const task of graph.getTasks()) {
       const ctor = task.constructor;
-      const newId = uuid46();
+      const newId = uuid47();
       idMap.set(task.config.id, newId);
       const clonedConfig = { ...task.config, id: newId };
       const newTask = new ctor({ ...clonedConfig, defaults: task.defaults }, task.runConfig);
@@ -5793,15 +6385,24 @@ var ITERATOR_CONTEXT_SCHEMA = {
     }
   }
 };
+function resolveIterationBound(bound) {
+  return bound === "unbounded" ? Number.POSITIVE_INFINITY : bound;
+}
 var iteratorTaskConfigSchema = {
   type: "object",
   properties: {
     ...graphAsTaskConfigSchema["properties"],
     concurrencyLimit: { type: "integer", minimum: 1 },
     batchSize: { type: "integer", minimum: 1 },
-    maxIterations: { type: "integer", minimum: 1 },
+    maxIterations: {
+      oneOf: [
+        { type: "integer", minimum: 1 },
+        { type: "string", const: "unbounded" }
+      ]
+    },
     iterationInputConfig: { type: "object", additionalProperties: true }
   },
+  required: ["maxIterations"],
   additionalProperties: false
 };
 function isArrayVariant(schema) {
@@ -5916,6 +6517,12 @@ class IteratorTask extends GraphAsTask {
   static configSchema() {
     return iteratorTaskConfigSchema;
   }
+  constructor(config = {}, runConfig = {}) {
+    if (config.maxIterations === undefined) {
+      throw new TaskConfigurationError(`${new.target.type ?? "IteratorTask"}: maxIterations is required. ` + `Pass a positive integer to cap iteration, or "unbounded" to opt out explicitly.`);
+    }
+    super(config, runConfig);
+  }
   static getIterationContextSchema() {
     return ITERATOR_CONTEXT_SCHEMA;
   }
@@ -6305,13 +6912,19 @@ var whileTaskConfigSchema = {
   properties: {
     ...graphAsTaskConfigSchema["properties"],
     condition: {},
-    maxIterations: { type: "integer", minimum: 1 },
+    maxIterations: {
+      oneOf: [
+        { type: "integer", minimum: 1 },
+        { type: "string", const: "unbounded" }
+      ]
+    },
     chainIterations: { type: "boolean" },
     conditionField: { type: "string" },
     conditionOperator: { type: "string" },
     conditionValue: { type: "string" },
     iterationInputConfig: { type: "object", additionalProperties: true }
   },
+  required: ["maxIterations"],
   additionalProperties: false
 };
 
@@ -6324,6 +6937,12 @@ class WhileTask extends GraphAsTask {
   static configSchema() {
     return whileTaskConfigSchema;
   }
+  constructor(config = {}, runConfig = {}) {
+    if (config.maxIterations === undefined) {
+      throw new TaskConfigurationError(`${new.target.type ?? "WhileTask"}: maxIterations is required. ` + `Pass a positive integer to cap iteration, or "unbounded" to opt out explicitly.`);
+    }
+    super(config, runConfig);
+  }
   static getIterationContextSchema() {
     return WHILE_CONTEXT_SCHEMA;
   }
@@ -6341,7 +6960,7 @@ class WhileTask extends GraphAsTask {
     return this.config.condition;
   }
   get maxIterations() {
-    return this.config.maxIterations ?? 100;
+    return resolveIterationBound(this.config.maxIterations);
   }
   get chainIterations() {
     return this.config.chainIterations ?? true;
@@ -6872,8 +7491,8 @@ import {
   JobQueueServer
 } from "@workglow/job-queue";
 import { InMemoryQueueStorage } from "@workglow/storage";
-import { createServiceToken as createServiceToken4, globalServiceRegistry as globalServiceRegistry3 } from "@workglow/util";
-var JOB_QUEUE_FACTORY = createServiceToken4("taskgraph.jobQueueFactory");
+import { createServiceToken as createServiceToken5, globalServiceRegistry as globalServiceRegistry4 } from "@workglow/util";
+var JOB_QUEUE_FACTORY = createServiceToken5("taskgraph.jobQueueFactory");
 var defaultJobQueueFactory = async ({
   queueName,
   jobClass,
@@ -6900,7 +7519,7 @@ var defaultJobQueueFactory = async ({
   return { server, client, storage };
 };
 function registerJobQueueFactory(factory) {
-  globalServiceRegistry3.registerInstance(JOB_QUEUE_FACTORY, factory);
+  globalServiceRegistry4.registerInstance(JOB_QUEUE_FACTORY, factory);
 }
 function createJobQueueFactoryWithOptions(defaultOptions = {}) {
   return async ({
@@ -6934,12 +7553,12 @@ function createJobQueueFactoryWithOptions(defaultOptions = {}) {
   };
 }
 function getJobQueueFactory() {
-  if (!globalServiceRegistry3.has(JOB_QUEUE_FACTORY)) {
+  if (!globalServiceRegistry4.has(JOB_QUEUE_FACTORY)) {
     registerJobQueueFactory(defaultJobQueueFactory);
   }
-  return globalServiceRegistry3.get(JOB_QUEUE_FACTORY);
+  return globalServiceRegistry4.get(JOB_QUEUE_FACTORY);
 }
-if (!globalServiceRegistry3.has(JOB_QUEUE_FACTORY)) {
+if (!globalServiceRegistry4.has(JOB_QUEUE_FACTORY)) {
   registerJobQueueFactory(defaultJobQueueFactory);
 }
 // src/task/MapTask.ts
@@ -6948,8 +7567,10 @@ var mapTaskConfigSchema = {
   properties: {
     ...iteratorTaskConfigSchema["properties"],
     preserveOrder: { type: "boolean" },
-    flatten: { type: "boolean" }
+    flatten: { type: "boolean" },
+    discardResults: { type: "boolean" }
   },
+  required: iteratorTaskConfigSchema.required,
   additionalProperties: false
 };
 
@@ -6982,6 +7603,9 @@ class MapTask extends IteratorTask {
   get flatten() {
     return this.config.flatten ?? false;
   }
+  get discardResults() {
+    return this.config.discardResults ?? false;
+  }
   preserveIterationOrder() {
     return this.preserveOrder;
   }
@@ -7003,6 +7627,9 @@ class MapTask extends IteratorTask {
     return this.getWrappedOutputSchema();
   }
   collectResults(results) {
+    if (this.discardResults) {
+      return this.getEmptyResult();
+    }
     const collected = super.collectResults(results);
     if (!this.flatten || typeof collected !== "object" || collected === null) {
       return collected;
@@ -7018,8 +7645,19 @@ class MapTask extends IteratorTask {
     return flattened;
   }
 }
+
+class ForEachTask extends MapTask {
+  static type = "ForEachTask";
+  static title = "For Each";
+  static description = "Runs a workflow per array item for side effects; discards collected results";
+  constructor(config = {}, runConfig = {}) {
+    super({ discardResults: true, ...config }, runConfig);
+  }
+}
 Workflow.prototype.map = CreateLoopWorkflow(MapTask);
 Workflow.prototype.endMap = CreateEndLoopWorkflow("endMap");
+Workflow.prototype.forEach = CreateLoopWorkflow(ForEachTask);
+Workflow.prototype.endForEach = CreateEndLoopWorkflow("endForEach");
 // src/task/ReduceTask.ts
 var reduceTaskConfigSchema = {
   type: "object",
@@ -7027,6 +7665,7 @@ var reduceTaskConfigSchema = {
     ...iteratorTaskConfigSchema["properties"],
     initialValue: {}
   },
+  required: iteratorTaskConfigSchema.required,
   additionalProperties: false
 };
 
@@ -7038,13 +7677,13 @@ class ReduceTask extends IteratorTask {
   static configSchema() {
     return reduceTaskConfigSchema;
   }
-  constructor(config = {}) {
+  constructor(config = {}, runConfig = {}) {
     const reduceConfig = {
       ...config,
       concurrencyLimit: 1,
       batchSize: 1
     };
-    super(reduceConfig);
+    super(reduceConfig, runConfig);
   }
   get initialValue() {
     return this.config.initialValue ?? {};
@@ -7116,9 +7755,9 @@ queueMicrotask(() => {
 });
 // src/task/TaskRegistry.ts
 import {
-  createServiceToken as createServiceToken5,
+  createServiceToken as createServiceToken6,
   getLogger as getLogger6,
-  globalServiceRegistry as globalServiceRegistry4,
+  globalServiceRegistry as globalServiceRegistry5,
   registerInputCompactor,
   registerInputResolver
 } from "@workglow/util";
@@ -7156,13 +7795,13 @@ var TaskRegistry = {
   registerTask,
   unregisterTask
 };
-var TASK_CONSTRUCTORS = createServiceToken5("task.constructors");
-globalServiceRegistry4.registerIfAbsent(TASK_CONSTRUCTORS, () => TaskRegistry.all, true);
+var TASK_CONSTRUCTORS = createServiceToken6("task.constructors");
+globalServiceRegistry5.registerIfAbsent(TASK_CONSTRUCTORS, () => TaskRegistry.all, true);
 function getGlobalTaskConstructors() {
-  return globalServiceRegistry4.get(TASK_CONSTRUCTORS);
+  return globalServiceRegistry5.get(TASK_CONSTRUCTORS);
 }
 function setGlobalTaskConstructors(map) {
-  globalServiceRegistry4.registerInstance(TASK_CONSTRUCTORS, map);
+  globalServiceRegistry5.registerInstance(TASK_CONSTRUCTORS, map);
 }
 function getTaskConstructors(registry) {
   if (!registry)
@@ -7259,7 +7898,11 @@ var createGraphFromGraphJSON = (graphJsonObj, registry, options) => {
     subGraph.addTask(createTaskFromGraphJSON(subitem, registry, options));
   }
   for (const subitem of graphJsonObj.dataflows) {
-    subGraph.addDataflow(new Dataflow(subitem.sourceTaskId, subitem.sourceTaskPortId, subitem.targetTaskId, subitem.targetTaskPortId));
+    const dataflow = new Dataflow(subitem.sourceTaskId, subitem.sourceTaskPortId, subitem.targetTaskId, subitem.targetTaskPortId);
+    if (subitem.transforms && subitem.transforms.length > 0) {
+      dataflow.setTransforms(subitem.transforms);
+    }
+    subGraph.addDataflow(dataflow);
   }
   return subGraph;
 };
@@ -7317,8 +7960,8 @@ var registerBaseTasks = () => {
   return tasks;
 };
 // src/storage/TaskGraphRepository.ts
-import { createServiceToken as createServiceToken6, EventEmitter as EventEmitter7 } from "@workglow/util";
-var TASK_GRAPH_REPOSITORY = createServiceToken6("taskgraph.taskGraphRepository");
+import { createServiceToken as createServiceToken7, EventEmitter as EventEmitter7 } from "@workglow/util";
+var TASK_GRAPH_REPOSITORY = createServiceToken7("taskgraph.taskGraphRepository");
 
 class TaskGraphRepository {
   type = "TaskGraphRepository";
@@ -8113,7 +8756,13 @@ function installDevToolsFormatters() {
 export {
   wrapSchemaInArray,
   whileTaskConfigSchema,
+  uppercaseTransform,
+  unixToIsoDateTransform,
+  truncateTransform,
+  toBooleanTransform,
   taskPrototypeHasOwnExecute,
+  substringTransform,
+  stringifyTransform,
   setTaskQueueRegistry,
   setGlobalTaskConstructors,
   serialGraph,
@@ -8123,25 +8772,33 @@ export {
   scanGraphForCredentials,
   resourcePatternMatches,
   resolveSchemaInputs,
+  resolveIterationBound,
   resetMethodNameCache,
   removeIterationProperties,
   registerJobQueueFactory,
+  registerBuiltInTransforms,
   registerBaseTasks,
   reduceTaskConfigSchema,
   pipe,
+  pickTransform,
+  parseJsonTransform,
   parallel,
+  numberToStringTransform,
   mergeResources,
   mergeEntitlements,
   mergeEntitlementPair,
   mergeChainedOutputToInput,
   mapTaskConfigSchema,
+  lowercaseTransform,
   iteratorTaskConfigSchema,
+  isoDateToUnixTransform,
   isTaskStreamable,
   isStrictArraySchema,
   isIterationProperty,
   isFlexibleSchema,
   isDarkMode,
   installDevToolsFormatters,
+  indexTransform,
   hasVectorOutput,
   hasVectorLikeInput,
   hasStructuredOutput,
@@ -8167,6 +8824,7 @@ export {
   getFormatPrefix,
   getAppendPortId,
   formatValue,
+  formatEntitlementDenial,
   findArrayPorts,
   filterIterationProperties,
   fallbackTaskConfigSchema,
@@ -8195,8 +8853,11 @@ export {
   computeGraphInputSchema,
   computeGraphEntitlements,
   compactSchemaInputs,
+  coalesceTransform,
+  can,
   calculateNodeDepths,
   buildIterationInputSchema,
+  autoConnect,
   addIterationContextToSchema,
   addBoundaryNodesToGraphJson,
   addBoundaryNodesToDependencyJson,
@@ -8205,6 +8866,7 @@ export {
   WhileTaskRunner,
   WhileTask,
   WHILE_CONTEXT_SCHEMA,
+  TransformRegistry,
   TaskTimeoutError,
   TaskStatus,
   TaskSerializationError,
@@ -8230,6 +8892,7 @@ export {
   TaskConfigSchema,
   TaskAbortedError,
   Task,
+  TRANSFORM_DEFS,
   TASK_OUTPUT_REPOSITORY,
   TASK_GRAPH_REPOSITORY,
   TASK_CONSTRUCTORS,
@@ -8247,6 +8910,7 @@ export {
   GraphAsTaskRunner,
   GraphAsTask,
   GRAPH_RESULT_ARRAY,
+  ForEachTask,
   FallbackTaskRunner,
   FallbackTask,
   EventTaskGraphToDagMapping,
@@ -8270,4 +8934,4 @@ export {
   BROWSER_GRANTS
 };
 
-//# debugId=A2F9041FD815B90264756E2164756E21
+//# debugId=B2CBA2397CBCF51264756E2164756E21