@workglow/task-graph 0.2.10 → 0.2.12

package/dist/browser.js

@@ -1719,6 +1719,7 @@ class Task {
   static passthroughInputsToOutputs = false;
   static customizable = false;
   static isGraphOutput = false;
+  static isPassthrough = false;
   static hasDynamicEntitlements = false;
   static entitlements() {
     return EMPTY_ENTITLEMENTS;
@@ -2686,7 +2687,9 @@ class DependencyBasedScheduler {
 // src/task-graph/TaskGraphRunner.ts
 function taskPrototypeHasOwnExecute(task) {
   const Ctor = task.constructor;
-  return Object.hasOwn(Ctor.prototype, "execute");
+  if (Ctor.isPassthrough)
+    return false;
+  return Object.hasOwn(Ctor.prototype, "execute") || Object.hasOwn(Ctor.prototype, "executeStream") || task.hasChildren();
 }
 var PROPERTY_ARRAY = "PROPERTY_ARRAY";
 var GRAPH_RESULT_ARRAY = "GRAPH_RESULT_ARRAY";
@@ -3378,7 +3381,7 @@ class TaskGraphRunner {
 class GraphAsTaskRunner extends TaskRunner {
   async executeTaskChildren(input) {
     const unsubscribe = this.task.subGraph.subscribe("graph_progress", (progress, message, ...args) => {
-      this.task.emit("progress", progress, message, ...args);
+      this.handleProgress(progress, message, ...args);
     });
     const results = await this.task.subGraph.run(input, {
       parentSignal: this.abortController?.signal,
@@ -5365,30 +5368,41 @@ class FallbackTaskRunner extends GraphAsTaskRunner {
     }
     const errors = [];
     const totalAttempts = alternatives.length;
-    for (let i = 0;i < alternatives.length; i++) {
-      if (this.abortController?.signal.aborted) {
-        throw new TaskAbortedError("Fallback aborted");
-      }
-      const alternative = alternatives[i];
-      const attemptNumber = i + 1;
-      await this.handleProgress(Math.round((i + 0.5) / totalAttempts * 100), `Trying data alternative ${attemptNumber}/${totalAttempts}`);
-      try {
-        this.resetSubgraph();
-        const mergedInput = { ...input, ...alternative };
-        const results = await this.task.subGraph.run(mergedInput, {
-          parentSignal: this.abortController?.signal,
-          outputCache: this.outputCache,
-          registry: this.registry
-        });
-        const mergedOutput = this.task.subGraph.mergeExecuteOutputsToRunOutput(results, this.task.compoundMerge);
-        await this.handleProgress(100, `Data alternative ${attemptNumber}/${totalAttempts} succeeded`);
-        return await this.executeTaskReactive(input, mergedOutput);
-      } catch (error) {
-        if (error instanceof TaskAbortedError && !(error instanceof TaskTimeoutError)) {
-          throw error;
+    let currentAttemptIndex = 0;
+    const onSubgraphProgress = (innerProgress, message) => {
+      const blended = Math.round((currentAttemptIndex + innerProgress / 100) / totalAttempts * 100);
+      this.handleProgress(blended, message ?? `Data alternative ${currentAttemptIndex + 1}/${totalAttempts}`);
+    };
+    const unsubscribeSubgraphProgress = this.task.subGraph.subscribe("graph_progress", onSubgraphProgress);
+    try {
+      for (let i = 0;i < alternatives.length; i++) {
+        if (this.abortController?.signal.aborted) {
+          throw new TaskAbortedError("Fallback aborted");
+        }
+        currentAttemptIndex = i;
+        const alternative = alternatives[i];
+        const attemptNumber = i + 1;
+        await this.handleProgress(Math.round((i + 0.5) / totalAttempts * 100), `Trying data alternative ${attemptNumber}/${totalAttempts}`);
+        try {
+          this.resetSubgraph();
+          const mergedInput = { ...input, ...alternative };
+          const results = await this.task.subGraph.run(mergedInput, {
+            parentSignal: this.abortController?.signal,
+            outputCache: this.outputCache,
+            registry: this.registry
+          });
+          const mergedOutput = this.task.subGraph.mergeExecuteOutputsToRunOutput(results, this.task.compoundMerge);
+          await this.handleProgress(100, `Data alternative ${attemptNumber}/${totalAttempts} succeeded`);
+          return await this.executeTaskReactive(input, mergedOutput);
+        } catch (error) {
+          if (error instanceof TaskAbortedError && !(error instanceof TaskTimeoutError)) {
+            throw error;
+          }
+          errors.push({ alternative, error });
         }
-        errors.push({ alternative, error });
       }
+    } finally {
+      unsubscribeSubgraphProgress();
     }
     throw this.buildAggregateError(errors, "data");
   }
@@ -5729,18 +5743,14 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
     }
     const graphClone = this.cloneGraph(this.task.subGraph);
     this.task.emit("iteration_start", index, iterationCount);
-    const taskProgressUnsubs = [];
-    for (const t of graphClone.getTasks()) {
-      const fn = (p, message) => {
-        this.task.emit("iteration_progress", index, iterationCount, p, message);
-        if (this.aggregatingParentMapProgress && this.mapPartialIterationCount > 0) {
-          this.mapPartialProgress[index] = Math.max(this.mapPartialProgress[index] ?? 0, p);
-          this.emitMapParentProgressFromPartials(message);
-        }
-      };
-      t.events.on("progress", fn);
-      taskProgressUnsubs.push({ task: t, fn });
-    }
+    const onGraphProgress = (p, message) => {
+      this.task.emit("iteration_progress", index, iterationCount, p, message);
+      if (this.aggregatingParentMapProgress && this.mapPartialIterationCount > 0) {
+        this.mapPartialProgress[index] = Math.max(this.mapPartialProgress[index] ?? 0, p);
+        this.emitMapParentProgressFromPartials(message);
+      }
+    };
+    const unsubscribeGraphProgress = graphClone.subscribe("graph_progress", onGraphProgress);
     try {
       const results = await graphClone.run(input, {
         parentSignal: this.abortController?.signal,
@@ -5753,9 +5763,7 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
       }
       return graphClone.mergeExecuteOutputsToRunOutput(results, this.task.compoundMerge);
     } finally {
-      for (const { task, fn } of taskProgressUnsubs) {
-        task.events.off("progress", fn);
-      }
+      unsubscribeGraphProgress();
       if (this.aggregatingParentMapProgress && this.mapPartialIterationCount > 0) {
         this.mapPartialProgress[index] = 100;
         this.emitMapParentProgressFromPartials();
@@ -6421,55 +6429,65 @@ class WhileTask extends GraphAsTask {
     let currentInput = { ...input };
     let currentOutput = {};
     const effectiveMax = arrayAnalysis ? Math.min(this.maxIterations, arrayAnalysis.iterationCount) : this.maxIterations;
-    while (this._currentIteration < effectiveMax) {
-      if (context.signal?.aborted) {
-        break;
-      }
-      let iterationInput;
-      if (arrayAnalysis) {
-        iterationInput = {
-          ...this.buildIterationInput(currentInput, arrayAnalysis, this._currentIteration),
-          _iterationIndex: this._currentIteration
-        };
-      } else {
-        iterationInput = {
-          ...currentInput,
-          _iterationIndex: this._currentIteration
-        };
-      }
-      const results = await this.subGraph.run(iterationInput, {
-        parentSignal: context.signal
-      });
-      currentOutput = this.subGraph.mergeExecuteOutputsToRunOutput(results, this.compoundMerge);
-      let shouldContinue;
-      try {
-        shouldContinue = condition(currentOutput, this._currentIteration);
-      } catch (err) {
-        if (err instanceof TaskFailedError) {
-          throw err;
+    const onInnerGraphProgress = (innerProgress, innerMessage) => {
+      const blended = Math.min(Math.round((this._currentIteration + innerProgress / 100) / effectiveMax * 100), 99);
+      const message = innerMessage ? `Iteration ${this._currentIteration + 1}/${effectiveMax}: ${innerMessage}` : `Iteration ${this._currentIteration + 1}/${effectiveMax}`;
+      context.updateProgress(blended, message);
+    };
+    const unsubscribeInnerProgress = this.subGraph.subscribe("graph_progress", onInnerGraphProgress);
+    try {
+      while (this._currentIteration < effectiveMax) {
+        if (context.signal?.aborted) {
+          break;
         }
-        const message = `${this.type}: Condition function threw at iteration ${this._currentIteration}: ${err instanceof Error ? err.message : String(err)}`;
-        const wrappedError = new TaskFailedError(message);
-        if (err instanceof Error && err.stack) {
-          if (wrappedError.stack) {
-            wrappedError.stack += `
+        let iterationInput;
+        if (arrayAnalysis) {
+          iterationInput = {
+            ...this.buildIterationInput(currentInput, arrayAnalysis, this._currentIteration),
+            _iterationIndex: this._currentIteration
+          };
+        } else {
+          iterationInput = {
+            ...currentInput,
+            _iterationIndex: this._currentIteration
+          };
+        }
+        const results = await this.subGraph.run(iterationInput, {
+          parentSignal: context.signal
+        });
+        currentOutput = this.subGraph.mergeExecuteOutputsToRunOutput(results, this.compoundMerge);
+        let shouldContinue;
+        try {
+          shouldContinue = condition(currentOutput, this._currentIteration);
+        } catch (err) {
+          if (err instanceof TaskFailedError) {
+            throw err;
+          }
+          const message = `${this.type}: Condition function threw at iteration ${this._currentIteration}: ${err instanceof Error ? err.message : String(err)}`;
+          const wrappedError = new TaskFailedError(message);
+          if (err instanceof Error && err.stack) {
+            if (wrappedError.stack) {
+              wrappedError.stack += `
 Caused by original error:
 ${err.stack}`;
-          } else {
-            wrappedError.stack = err.stack;
+            } else {
+              wrappedError.stack = err.stack;
+            }
           }
+          throw wrappedError;
         }
-        throw wrappedError;
-      }
-      if (!shouldContinue) {
-        break;
-      }
-      if (this.chainIterations) {
-        currentInput = { ...currentInput, ...currentOutput };
+        if (!shouldContinue) {
+          break;
+        }
+        if (this.chainIterations) {
+          currentInput = { ...currentInput, ...currentOutput };
+        }
+        this._currentIteration++;
+        const progress = Math.min(Math.round(this._currentIteration / effectiveMax * 100), 99);
+        await context.updateProgress(progress, `Completed ${this._currentIteration}/${effectiveMax} iterations`);
       }
-      this._currentIteration++;
-      const progress = Math.min(Math.round(this._currentIteration / effectiveMax * 100), 99);
-      await context.updateProgress(progress, `Completed ${this._currentIteration}/${effectiveMax} iterations`);
+    } finally {
+      unsubscribeInnerProgress();
     }
     return currentOutput;
   }
@@ -6486,40 +6504,50 @@ ${err.stack}`;
     let currentInput = { ...input };
     let currentOutput = {};
     const effectiveMax = arrayAnalysis ? Math.min(this.maxIterations, arrayAnalysis.iterationCount) : this.maxIterations;
-    while (this._currentIteration < effectiveMax) {
-      if (context.signal?.aborted)
-        break;
-      let iterationInput;
-      if (arrayAnalysis) {
-        iterationInput = {
-          ...this.buildIterationInput(currentInput, arrayAnalysis, this._currentIteration),
-          _iterationIndex: this._currentIteration
-        };
-      } else {
-        iterationInput = {
-          ...currentInput,
-          _iterationIndex: this._currentIteration
-        };
-      }
-      const results = await this.subGraph.run(iterationInput, {
-        parentSignal: context.signal
-      });
-      currentOutput = this.subGraph.mergeExecuteOutputsToRunOutput(results, this.compoundMerge);
-      let shouldContinue;
-      try {
-        shouldContinue = condition(currentOutput, this._currentIteration);
-      } catch (err) {
-        throw new TaskFailedError(`${this.type}: Condition function threw at iteration ${this._currentIteration}: ${err instanceof Error ? err.message : String(err)}`);
-      }
-      if (!shouldContinue) {
-        break;
-      }
-      if (this.chainIterations) {
-        currentInput = { ...currentInput, ...currentOutput };
+    const onInnerGraphProgress = (innerProgress, innerMessage) => {
+      const blended = Math.min(Math.round((this._currentIteration + innerProgress / 100) / effectiveMax * 100), 99);
+      const message = innerMessage ? `Iteration ${this._currentIteration + 1}/${effectiveMax}: ${innerMessage}` : `Iteration ${this._currentIteration + 1}/${effectiveMax}`;
+      context.updateProgress(blended, message);
+    };
+    const unsubscribeInnerProgress = this.subGraph.subscribe("graph_progress", onInnerGraphProgress);
+    try {
+      while (this._currentIteration < effectiveMax) {
+        if (context.signal?.aborted)
+          break;
+        let iterationInput;
+        if (arrayAnalysis) {
+          iterationInput = {
+            ...this.buildIterationInput(currentInput, arrayAnalysis, this._currentIteration),
+            _iterationIndex: this._currentIteration
+          };
+        } else {
+          iterationInput = {
+            ...currentInput,
+            _iterationIndex: this._currentIteration
+          };
+        }
+        const results = await this.subGraph.run(iterationInput, {
+          parentSignal: context.signal
+        });
+        currentOutput = this.subGraph.mergeExecuteOutputsToRunOutput(results, this.compoundMerge);
+        let shouldContinue;
+        try {
+          shouldContinue = condition(currentOutput, this._currentIteration);
+        } catch (err) {
+          throw new TaskFailedError(`${this.type}: Condition function threw at iteration ${this._currentIteration}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        if (!shouldContinue) {
+          break;
+        }
+        if (this.chainIterations) {
+          currentInput = { ...currentInput, ...currentOutput };
+        }
+        this._currentIteration++;
+        const progress = Math.min(Math.round(this._currentIteration / effectiveMax * 100), 99);
+        await context.updateProgress(progress, `Completed ${this._currentIteration}/${effectiveMax} iterations`);
       }
-      this._currentIteration++;
-      const progress = Math.min(Math.round(this._currentIteration / effectiveMax * 100), 99);
-      await context.updateProgress(progress, `Completed ${this._currentIteration}/${effectiveMax} iterations`);
+    } finally {
+      unsubscribeInnerProgress();
     }
     yield { type: "finish", data: currentOutput };
   }
@@ -8242,4 +8270,4 @@ export {
   BROWSER_GRANTS
 };
 
-//# debugId=108A162D578570C764756E2164756E21
+//# debugId=E3C5AA591E51471C64756E2164756E21