@workglow/task-graph 0.0.87 → 0.0.89

package/src/EXECUTION_MODEL.md

@@ -0,0 +1,433 @@
+# Task Graph Execution Model
+
+This document explains the internal execution model of the task graph system. It is intended for developers (human or AI) who need to understand or modify the execution logic.
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Task Lifecycle](#task-lifecycle)
+- [Normal Execution (run)](#normal-execution-run)
+- [Reactive Execution (runReactive)](#reactive-execution-runreactive)
+- [Dataflow and Input Propagation](#dataflow-and-input-propagation)
+- [GraphAsTask (Subgraphs)](#graphastask-subgraphs)
+- [Key Invariants](#key-invariants)
+- [Common Pitfalls](#common-pitfalls)
+
+---
+
+## Overview
+
+The task graph system has two execution modes:
+
+1. **`run()`** - Full execution that produces cached, immutable results
+2. **`runReactive()`** - Lightweight execution for UI updates and previews
+
+These modes serve different purposes and have different semantics regarding task state and data flow.
+
+---
+
+## Task Lifecycle
+
+### Task Statuses
+
+```
+PENDING → PROCESSING → COMPLETED
+                    ↘ FAILED
+                    ↘ ABORTED
+```
+
+| Status       | Description                                                         |
+| ------------ | ------------------------------------------------------------------- |
+| `PENDING`    | Task has not been executed yet. Inputs can be modified.             |
+| `PROCESSING` | Task is currently executing.                                        |
+| `COMPLETED`  | Task has finished successfully. **Output is locked and immutable.** |
+| `FAILED`     | Task execution threw an error.                                      |
+| `ABORTED`    | Task was cancelled via `abort()`.                                   |
+
+### Key Properties
+
+Each task maintains:
+
+- `defaults` - Default input values set at construction time
+- `runInputData` - The actual input used for execution (defaults + overrides)
+- `runOutputData` - The output produced by execution
+- `status` - Current lifecycle status
+
+---
+
+## Normal Execution (run)
+
+### Purpose
+
+Full execution that:
+
+- Runs the task's `execute()` method
+- Produces cached, deterministic results
+- Transitions task to `COMPLETED` status
+- Makes output immutable
+
+### Flow
+
+```
+Task.run(overrides)
+    ↓
+TaskRunner.run(overrides)
+    ↓
+1. setInput(overrides)           # Merge overrides into runInputData
+2. resolveSchemaInputs()         # Resolve model/repository strings to instances
+3. validateInput()               # Validate against input schema
+4. Check cache                   # If cacheable, check for cached result
+5. executeTask()                 # Call task.execute(input, context)
+6. Store in cache                # If cacheable, cache the result
+7. handleComplete()              # Set status = COMPLETED
+    ↓
+Return runOutputData (locked)
+```
+
+### Graph-Level Execution
+
+```
+TaskGraph.run(input)
+    ↓
+TaskGraphRunner.runGraph(input)
+    ↓
+For each task (in topological order):
+    1. copyInputFromEdgesToNode()  # Pull data from incoming dataflows
+    2. runTask(task, input)        # Execute the task
+    3. pushOutputFromNodeToEdges() # Push output to outgoing dataflows
+    ↓
+Return results from ending nodes (no outgoing dataflows)
+```
+
+---
+
+## Reactive Execution (runReactive)
+
+### Purpose
+
+Lightweight execution for:
+
+- UI previews and updates
+- Fast transformations (e.g., image filters)
+- Propagating intermediate results through PENDING tasks
+
+**Important:** Reactive execution only affects `PENDING` tasks. `COMPLETED` tasks return their cached output unchanged.
+
+### Use Case Example
+
+```
+User edits an InputNode default → Task is PENDING
+    ↓
+runReactive() is called
+    ↓
+InputTask (PENDING) receives new value
+    ↓
+Downstream tasks (PENDING) get reactive updates
+    ↓
+Tasks run their executeReactive() for quick previews
+    ↓
+Eventually run() is called → All tasks become COMPLETED (locked)
+```
+
+### Task-Level Flow
+
+```
+Task.runReactive(overrides)
+    ↓
+TaskRunner.runReactive(overrides)
+    ↓
+1. If status == PROCESSING: return existing output (no re-entry)
+2. setInput(overrides)                    # Update runInputData
+3. resolveSchemaInputs()                  # Resolve strings to instances
+4. handleStartReactive()                  # Status → PROCESSING
+5. validateInput()
+6. executeTaskReactive(input, output)     # Call task.executeReactive()
+7. runOutputData = merge(output, result)  # Merge with previous output
+8. handleCompleteReactive()               # Status → back to previous
+    ↓
+Return runOutputData
+```
+
+### Graph-Level Flow
+
+```
+TaskGraph.runReactive(input)
+    ↓
+TaskGraphRunner.runGraphReactive(input)
+    ↓
+For each task (in topological order):
+    ↓
+    ┌─ If status == PENDING:
+    │      resetInputData()              # Reset to defaults
+    │      copyInputFromEdgesToNode()    # Pull from incoming dataflows
+    └─ Else (COMPLETED):
+           Skip input modification       # Output is locked
+    ↓
+    If isRootTask (no incoming dataflows):
+        taskInput = input                # Pass graph input to root tasks
+    Else:
+        taskInput = {}
+    ↓
+    task.runReactive(taskInput)
+    ↓
+    pushOutputFromNodeToEdges()          # Push output to dataflows
+    ↓
+Return results from ending nodes
+```
+
+### The executeReactive Method
+
+```typescript
+// Default implementation - just returns existing output
+async executeReactive(input, output, context): Promise<Output | undefined> {
+    return output;
+}
+
+// Custom implementation for quick transformations
+async executeReactive(input, output, context): Promise<Output | undefined> {
+    // Lightweight operation (e.g., < 1ms)
+    return { ...output, preview: this.quickTransform(input) };
+}
+```
+
+---
+
+## Dataflow and Input Propagation
+
+### How Data Flows Between Tasks
+
+```
+TaskA (source)                    TaskB (target)
+    ↓                                 ↓
+outputSchema: {                  inputSchema: {
+  result: number                   value: number
+}                                }
+    ↓                                 ↓
+Dataflow("taskA", "result", "taskB", "value")
+    ↓
+TaskA.runOutputData.result → TaskB.runInputData.value
+```
+
+### Key Methods
+
+| Method                                    | Purpose                                                          |
+| ----------------------------------------- | ---------------------------------------------------------------- |
+| `copyInputFromEdgesToNode(task)`          | Pull data from all incoming dataflows into task's `runInputData` |
+| `pushOutputFromNodeToEdges(task, output)` | Push task's output to all outgoing dataflows                     |
+| `addInputData(task, data)`                | Merge data into task's `runInputData`                            |
+
+### When Input is Copied
+
+| Execution Mode  | Task Status | Input Copied?             |
+| --------------- | ----------- | ------------------------- |
+| `run()`         | Any         | Yes (always)              |
+| `runReactive()` | PENDING     | Yes                       |
+| `runReactive()` | COMPLETED   | **No** (output is locked) |
+
+---
+
+## GraphAsTask (Subgraphs)
+
+### What is GraphAsTask?
+
+A `GraphAsTask` is a task that contains an internal `TaskGraph` (subgraph). This enables:
+
+- Hierarchical workflow composition
+- Encapsulation of complex logic
+- Reusable workflow components
+
+### Execution Flow
+
+```
+GraphAsTask.run(input)
+    ↓
+GraphAsTaskRunner.executeTask(input)
+    ↓
+executeTaskChildren(input)
+    ↓
+subGraph.run(input)      # Execute the entire subgraph
+    ↓
+mergeExecuteOutputsToRunOutput()  # Combine results from ending nodes
+```
+
+### Reactive Execution with Subgraphs
+
+```
+GraphAsTask.runReactive(input)
+    ↓
+GraphAsTaskRunner.executeTaskReactive(input, output)
+    ↓
+executeTaskChildrenReactive()
+    ↓
+subGraph.runReactive(this.task.runInputData)  # ← IMPORTANT: Pass parent's input
+    ↓
+mergeExecuteOutputsToRunOutput()
+```
+
+**Critical:** The parent's `runInputData` is passed to `subGraph.runReactive()` so that root tasks in the subgraph (like InputTask) receive the input values.
+
+### Root Task Input Propagation
+
+In `runGraphReactive()`:
+
+```typescript
+const isRootTask = this.graph.getSourceDataflows(task.config.id).length === 0;
+
+// For root tasks, pass the input parameter (from parent GraphAsTask)
+const taskInput = isRootTask ? input : {};
+
+const taskResult = await task.runReactive(taskInput);
+```
+
+This ensures:
+
+1. Root tasks (no incoming dataflows) receive input from the parent
+2. Non-root tasks receive input from their upstream dataflows
+
+---
+
+## Key Invariants
+
+### 1. COMPLETED Tasks Are Immutable
+
+Once a task's `run()` completes and status becomes `COMPLETED`:
+
+- `runOutputData` is **locked** and **cacheable**
+- `runInputData` should not be modified
+- `runReactive()` returns the cached output unchanged
+
+### 2. Only PENDING Tasks Receive Dataflow Updates in Reactive Mode
+
+```typescript
+if (task.status === TaskStatus.PENDING) {
+  task.resetInputData();
+  this.copyInputFromEdgesToNode(task);
+}
+```
+
+### 3. Root Tasks Receive Parent Input
+
+In subgraphs, root tasks (no incoming dataflows) receive the parent's input:
+
+```typescript
+const taskInput = isRootTask ? input : {};
+task.runReactive(taskInput);
+```
+
+### 4. executeReactive is Lightweight
+
+The `executeReactive()` method should:
+
+- Complete quickly (< 1ms ideally)
+- Not perform heavy computation
+- Return UI preview data
+
+Heavy computation belongs in `execute()`.
+
+### 5. Reactive Execution Respects Task Order
+
+Tasks are executed in topological order (via `reactiveScheduler`), ensuring:
+
+- Upstream tasks run before downstream tasks
+- Data is available when needed
+
+---
+
+## Common Pitfalls
+
+### 1. Modifying COMPLETED Task Input
+
+**Wrong:**
+
+```typescript
+// Trying to update a COMPLETED task's input
+task.setInput({ newValue: 42 }); // ❌ Violates immutability
+```
+
+**Correct:**
+Only modify input for PENDING tasks, or reset the entire graph first.
+
+### 2. Missing Root Task Input Propagation
+
+**Wrong:**
+
+```typescript
+protected async executeTaskChildrenReactive() {
+    return this.task.subGraph!.runReactive();  // ❌ No input passed
+}
+```
+
+**Correct:**
+
+```typescript
+protected async executeTaskChildrenReactive() {
+    return this.task.subGraph!.runReactive(this.task.runInputData);  // ✓
+}
+```
+
+### 3. Copying Input to COMPLETED Tasks
+
+**Wrong:**
+
+```typescript
+// In runGraphReactive
+this.copyInputFromEdgesToNode(task); // ❌ Always copies, even for COMPLETED
+```
+
+**Correct:**
+
+```typescript
+if (task.status === TaskStatus.PENDING) {
+  task.resetInputData();
+  this.copyInputFromEdgesToNode(task); // ✓ Only for PENDING
+}
+```
+
+### 4. Heavy Computation in executeReactive
+
+**Wrong:**
+
+```typescript
+async executeReactive(input, output) {
+    // ❌ Takes 30 seconds
+    const result = await this.trainNeuralNetwork(input);
+    return { result };
+}
+```
+
+**Correct:**
+
+```typescript
+async executeReactive(input, output) {
+    // ✓ Quick preview (< 1ms)
+    return { preview: this.quickPreview(input) };
+}
+
+async execute(input) {
+    // Heavy work belongs here
+    const result = await this.trainNeuralNetwork(input);
+    return { result };
+}
+```
+
+---
+
+## Summary
+
+| Aspect               | `run()`           | `runReactive()`     |
+| -------------------- | ----------------- | ------------------- |
+| **Purpose**          | Full execution    | UI previews         |
+| **Method called**    | `execute()`       | `executeReactive()` |
+| **Final status**     | COMPLETED         | Unchanged           |
+| **Output**           | Locked/cached     | Temporary           |
+| **Dataflow updates** | Always            | Only PENDING tasks  |
+| **Performance**      | Can be slow       | Should be < 1ms     |
+| **User edits**       | Before run starts | Before run starts   |
+
+### Key Takeaways
+
+1. Users only edit inputs on PENDING tasks
+2. Once `run()` completes, the task is COMPLETED and immutable
+3. `runReactive()` propagates lightweight updates through PENDING tasks
+4. COMPLETED tasks return cached results in reactive mode
+5. Root tasks in subgraphs receive input from the parent GraphAsTask

package/dist/task/BatchTask.d.ts

@@ -1,154 +0,0 @@
-/**
- * @license
- * Copyright 2025 Steven Roussey <sroussey@gmail.com>
- * SPDX-License-Identifier: Apache-2.0
- */
-import { type DataPortSchema } from "@workglow/util";
-import { IteratorTask, IteratorTaskConfig } from "./IteratorTask";
-import type { TaskInput, TaskOutput, TaskTypeName } from "./TaskTypes";
-/**
- * Configuration for BatchTask.
- */
-export interface BatchTaskConfig extends IteratorTaskConfig {
-    /**
-     * Number of items per batch.
-     * @default 10
-     */
-    readonly batchSize?: number;
-    /**
-     * Whether to flatten results from all batches into a single array.
-     * When false, results are grouped by batch.
-     * @default true
-     */
-    readonly flattenResults?: boolean;
-    /**
-     * Whether to execute batches in parallel or sequentially.
-     * @default "sequential"
-     */
-    readonly batchExecutionMode?: "parallel" | "sequential";
-}
-/**
- * BatchTask processes an array in configurable chunks/batches.
- *
- * This task is useful for:
- * - Rate-limited API calls that accept multiple items
- * - Memory-constrained processing
- * - Progress tracking at batch granularity
- *
- * ## Features
- *
- * - Groups array into chunks of batchSize
- * - Runs inner workflow per batch (receives array of items)
- * - Configurable batch and within-batch execution
- * - Optional result flattening
- *
- * ## Usage
- *
- * ```typescript
- * // Process in batches of 10
- * workflow
- *   .input({ documents: [...100 docs...] })
- *   .batch({ batchSize: 10 })
- *     .bulkEmbed()
- *     .bulkStore()
- *   .endBatch()
- *
- * // Sequential batches for rate limiting
- * workflow
- *   .batch({ batchSize: 5, batchExecutionMode: "sequential" })
- *     .apiCall()
- *   .endBatch()
- * ```
- *
- * @template Input - The input type containing the array to batch
- * @template Output - The output type (collected batch results)
- * @template Config - The configuration type
- */
-export declare class BatchTask<Input extends TaskInput = TaskInput, Output extends TaskOutput = TaskOutput, Config extends BatchTaskConfig = BatchTaskConfig> extends IteratorTask<Input, Output, Config> {
-    static type: TaskTypeName;
-    static category: string;
-    static title: string;
-    static description: string;
-    /**
-     * BatchTask always uses PROPERTY_ARRAY merge strategy.
-     */
-    static readonly compoundMerge: "PROPERTY_ARRAY";
-    /**
-     * Static input schema for BatchTask.
-     */
-    static inputSchema(): DataPortSchema;
-    /**
-     * Static output schema for BatchTask.
-     */
-    static outputSchema(): DataPortSchema;
-    /**
-     * Gets the batch size.
-     */
-    get batchSize(): number;
-    /**
-     * Whether to flatten results from all batches.
-     */
-    get flattenResults(): boolean;
-    /**
-     * Batch execution mode.
-     */
-    get batchExecutionMode(): "parallel" | "sequential";
-    /**
-     * Override to group items into batches instead of individual items.
-     */
-    protected getIterableItems(input: Input): unknown[];
-    /**
-     * Groups items into batches of batchSize.
-     */
-    protected groupIntoBatches(items: unknown[]): unknown[][];
-    /**
-     * Creates iteration tasks for batches.
-     * Each batch receives the array of items for that batch.
-     */
-    protected createIterationTasks(batches: unknown[]): void;
-    /**
-     * Returns the empty result for BatchTask.
-     */
-    protected getEmptyResult(): Output;
-    /**
-     * Output schema for BatchTask.
-     * Similar to MapTask - wraps inner outputs in arrays.
-     */
-    outputSchema(): DataPortSchema;
-    /**
-     * Collects and optionally flattens results from all batches.
-     */
-    protected collectResults(results: TaskOutput[]): Output;
-    /**
-     * Regenerates the graph for batch execution.
-     */
-    regenerateGraph(): void;
-}
-declare module "../task-graph/Workflow" {
-    interface Workflow {
-        /**
-         * Starts a batch loop that processes arrays in chunks.
-         * Use .endBatch() to close the loop and return to the parent workflow.
-         *
-         * @param config - Configuration for the batch loop
-         * @returns A Workflow in loop builder mode for defining the batch processing
-         *
-         * @example
-         * ```typescript
-         * workflow
-         *   .batch({ batchSize: 10 })
-         *     .bulkProcess()
-         *   .endBatch()
-         * ```
-         */
-        batch: CreateLoopWorkflow<TaskInput, TaskOutput, BatchTaskConfig>;
-        /**
-         * Ends the batch loop and returns to the parent workflow.
-         * Only callable on workflows in loop builder mode.
-         *
-         * @returns The parent workflow
-         */
-        endBatch(): Workflow;
-    }
-}
-//# sourceMappingURL=BatchTask.d.ts.map

package/dist/task/BatchTask.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BatchTask.d.ts","sourceRoot":"","sources":["../../src/task/BatchTask.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAQrD,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEvE;;GAEG;AACH,MAAM,WAAW,eAAgB,SAAQ,kBAAkB;IACzD;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAE5B;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAElC;;;OAGG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,UAAU,GAAG,YAAY,CAAC;CACzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,qBAAa,SAAS,CACpB,KAAK,SAAS,SAAS,GAAG,SAAS,EACnC,MAAM,SAAS,UAAU,GAAG,UAAU,EACtC,MAAM,SAAS,eAAe,GAAG,eAAe,CAChD,SAAQ,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC;IAC3C,OAAc,IAAI,EAAE,YAAY,CAAe;IAC/C,OAAc,QAAQ,EAAE,MAAM,CAAkB;IAChD,OAAc,KAAK,EAAE,MAAM,CAAW;IACtC,OAAc,WAAW,EAAE,MAAM,CAAgD;IAEjF;;OAEG;IACH,gBAAuB,aAAa,mBAAkB;IAEtD;;OAEG;WACW,WAAW,IAAI,cAAc;IAQ3C;;OAEG;WACW,YAAY,IAAI,cAAc;IAQ5C;;OAEG;IACH,IAAoB,SAAS,IAAI,MAAM,CAEtC;IAED;;OAEG;IACH,IAAW,cAAc,IAAI,OAAO,CAEnC;IAED;;OAEG;IACH,IAAW,kBAAkB,IAAI,UAAU,GAAG,YAAY,CAEzD;IAED;;OAEG;cACgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,EAAE;IAK5D;;OAEG;IACH,SAAS,CAAC,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,EAAE;IAWzD;;;OAGG;cACgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,IAAI;IA0BjE;;OAEG;cACgB,cAAc,IAAI,MAAM;IAc3C;;;OAGG;IACa,YAAY,IAAI,cAAc;IAQ9C;;OAEG;cACgB,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,MAAM;IAqBhE;;OAEG;IACa,eAAe,IAAI,IAAI;CAqBxC;AAMD,OAAO,QAAQ,wBAAwB,CAAC;IACtC,UAAU,QAAQ;QAChB;;;;;;;;;;;;;;WAcG;QAEH,KAAK,EAAE,kBAAkB,CAAC,SAAS,EAAE,UAAU,EAAE,eAAe,CAAC,CAAC;QAElE;;;;;WAKG;QACH,QAAQ,IAAI,QAAQ,CAAC;KACtB;CACF"}

package/dist/task/ForEachTask.d.ts

@@ -1,120 +0,0 @@
-/**
- * @license
- * Copyright 2025 Steven Roussey <sroussey@gmail.com>
- * SPDX-License-Identifier: Apache-2.0
- */
-import type { DataPortSchema } from "@workglow/util";
-import { IteratorTask, IteratorTaskConfig } from "./IteratorTask";
-import type { TaskInput, TaskOutput, TaskTypeName } from "./TaskTypes";
-/**
- * Configuration for ForEachTask.
- */
-export interface ForEachTaskConfig extends IteratorTaskConfig {
-    /**
-     * Whether to collect and return results from each iteration.
-     * When false (default), ForEachTask is optimized for side effects.
-     * When true, results are collected but not transformed.
-     * @default false
-     */
-    readonly shouldCollectResults?: boolean;
-}
-/**
- * ForEachTask iterates over an array and runs a workflow for each element.
- *
- * This task is optimized for side-effect operations where the primary goal
- * is to process each item rather than collect transformed results.
- * For transformations that collect results, use MapTask instead.
- *
- * ## Features
- *
- * - Iterates over array input
- * - Runs inner workflow for each element
- * - Configurable execution modes (parallel, sequential, etc.)
- * - Optimized for side effects (default: doesn't collect results)
- *
- * ## Usage
- *
- * ```typescript
- * // Using Workflow API
- * workflow
- *   .input({ items: ["a", "b", "c"] })
- *   .forEach()
- *     .processItem()
- *     .saveToDatabase()
- *   .endForEach()
- *
- * // With sequential execution
- * workflow
- *   .forEach({ executionMode: "sequential" })
- *     .processItem()
- *   .endForEach()
- * ```
- *
- * @template Input - The input type containing the array to iterate
- * @template Output - The output type (typically empty for side-effect operations)
- * @template Config - The configuration type
- */
-export declare class ForEachTask<Input extends TaskInput = TaskInput, Output extends TaskOutput = TaskOutput, Config extends ForEachTaskConfig = ForEachTaskConfig> extends IteratorTask<Input, Output, Config> {
-    static type: TaskTypeName;
-    static category: string;
-    static title: string;
-    static description: string;
-    /**
-     * Static input schema for ForEachTask.
-     * Accepts any object with at least one array property.
-     */
-    static inputSchema(): DataPortSchema;
-    /**
-     * Static output schema for ForEachTask.
-     * By default, returns an empty object (side-effect focused).
-     */
-    static outputSchema(): DataPortSchema;
-    /**
-     * Whether to collect results from iterations.
-     */
-    get shouldCollectResults(): boolean;
-    /**
-     * Returns the empty result for ForEachTask.
-     * Indicates completion with zero items processed.
-     */
-    protected getEmptyResult(): Output;
-    /**
-     * Output schema for ForEachTask instance.
-     * If shouldCollectResults is enabled, wraps inner output in arrays.
-     * Otherwise, returns the simple completion status schema.
-     */
-    outputSchema(): DataPortSchema;
-    /**
-     * Collects results from all iterations.
-     * For ForEachTask, this primarily returns completion status.
-     */
-    protected collectResults(results: TaskOutput[]): Output;
-}
-declare module "../task-graph/Workflow" {
-    interface Workflow {
-        /**
-         * Starts a forEach loop that iterates over an array.
-         * Use .endForEach() to close the loop and return to the parent workflow.
-         *
-         * @param config - Configuration for the forEach loop
-         * @returns A Workflow in loop builder mode for defining the loop body
-         *
-         * @example
-         * ```typescript
-         * workflow
-         *   .forEach({ executionMode: "sequential" })
-         *     .processItem()
-         *   .endForEach()
-         * ```
-         */
-        forEach: CreateLoopWorkflow<TaskInput, TaskOutput, ForEachTaskConfig>;
-        /**
-         * Ends the forEach loop and returns to the parent workflow.
-         * Only callable on workflows in loop builder mode.
-         *
-         * @returns The parent workflow
-         */
-        endForEach(): Workflow;
-    }
-}
-//# sourceMappingURL=ForEachTask.d.ts.map