@workglow/task-graph 0.0.121 → 0.0.123

package/dist/bun.js

@@ -83,7 +83,8 @@ var init_TaskTypes = __esm(() => {
 });
 
 // src/task-graph/Dataflow.ts
-import { areSemanticallyCompatible, EventEmitter } from "@workglow/util";
+import { areSemanticallyCompatible } from "@workglow/util/schema";
+import { EventEmitter } from "@workglow/util";
 
 class Dataflow {
   sourceTaskId;
@@ -914,7 +915,6 @@ function getStructuredOutputSchemas(schema) {
 function hasStructuredOutput(schema) {
   return getStructuredOutputSchemas(schema).size > 0;
 }
-var init_StreamTypes = () => {};
 
 // src/task/TaskRunner.ts
 import {
@@ -1293,22 +1293,21 @@ class TaskRunner {
   }
   async handleProgress(progress, message, ...args) {
     this.task.progress = progress;
-    await this.updateProgress(this.task, progress, message, ...args);
     this.task.emit("progress", progress, message, ...args);
+    await this.updateProgress(this.task, progress, message, ...args);
   }
 }
 var init_TaskRunner = __esm(() => {
   init_TaskOutputRepository();
   init_Conversions();
   init_InputResolver();
-  init_StreamTypes();
   init_TaskError();
   init_TaskTypes();
 });
 
 // src/task/Task.ts
+import { compileSchema } from "@workglow/util/schema";
 import {
-  compileSchema,
   deepEqual,
   EventEmitter as EventEmitter3,
   uuid4 as uuid42
@@ -1601,7 +1600,7 @@ class Task {
     return this.events.waitOn(name);
   }
   emit(name, ...args) {
-    this._events?.emit(name, ...args);
+    this.events.emit(name, ...args);
   }
   emitSchemaChange(inputSchema, outputSchema) {
     const finalInputSchema = inputSchema ?? this.inputSchema();
@@ -1743,13 +1742,15 @@ class Task {
     const extras = config.extras;
     if (!extras || Object.keys(extras).length === 0)
       delete config.extras;
-    const json = this.stripSymbols({
+    const base = {
       id: this.id,
       type: this.type,
-      defaults: this.defaults,
-      config
-    });
-    return json;
+      defaults: this.defaults
+    };
+    if (Object.keys(config).length > 0) {
+      base.config = config;
+    }
+    return this.stripSymbols(base);
   }
   toDependencyJSON(options) {
     const json = this.toJSON(options);
@@ -1862,13 +1863,11 @@ function getNestedValue(obj, path) {
   }
   return current;
 }
-var init_ConditionUtils = () => {};
 
 // src/task/ConditionalTask.ts
 import { getLogger } from "@workglow/util";
 var conditionalTaskConfigSchema, ConditionalTask;
 var init_ConditionalTask = __esm(() => {
-  init_ConditionUtils();
   init_Task();
   init_TaskTypes();
   conditionalTaskConfigSchema = {
@@ -2222,7 +2221,6 @@ class DependencyBasedScheduler {
   }
 }
 var init_TaskGraphScheduler = __esm(() => {
-  init_StreamTypes();
   init_TaskTypes();
 });
 
@@ -2236,6 +2234,10 @@ import {
   SpanStatusCode as SpanStatusCode2,
   uuid4 as uuid43
 } from "@workglow/util";
+function taskPrototypeHasOwnExecute(task) {
+  const Ctor = task.constructor;
+  return Object.hasOwn(Ctor.prototype, "execute");
+}
 
 class TaskGraphRunner {
   processScheduler;
@@ -2822,23 +2824,25 @@ class TaskGraphRunner {
     this.graph.emit("disabled");
   }
   async handleProgress(task, progress, message, ...args) {
-    const total = this.graph.getTasks().length;
-    if (total > 1) {
-      const completed = this.graph.getTasks().reduce((acc, t) => acc + t.progress, 0);
-      progress = Math.round(completed / total);
+    const contributors = this.graph.getTasks().filter(taskPrototypeHasOwnExecute);
+    if (contributors.length > 1) {
+      const sum = contributors.reduce((acc, t) => acc + t.progress, 0);
+      progress = Math.round(sum / contributors.length);
+    } else if (contributors.length === 1) {
+      const [only] = contributors;
+      progress = only.progress;
     }
     this.pushStatusFromNodeToEdges(this.graph, task);
+    this.graph.emit("graph_progress", progress, message, args);
     if (task.runOutputData && Object.keys(task.runOutputData).length > 0) {
       await this.pushOutputFromNodeToEdges(task, task.runOutputData);
     }
-    this.graph.emit("graph_progress", progress, message, args);
   }
 }
 var PROPERTY_ARRAY = "PROPERTY_ARRAY", GRAPH_RESULT_ARRAY = "GRAPH_RESULT_ARRAY";
 var init_TaskGraphRunner = __esm(() => {
   init_TaskOutputRepository();
   init_ConditionalTask();
-  init_StreamTypes();
   init_TaskError();
   init_TaskTypes();
   init_Dataflow();
@@ -2902,7 +2906,7 @@ __export(exports_GraphAsTask, {
   graphAsTaskConfigSchema: () => graphAsTaskConfigSchema,
   GraphAsTask: () => GraphAsTask
 });
-import { compileSchema as compileSchema2 } from "@workglow/util";
+import { compileSchema as compileSchema2 } from "@workglow/util/schema";
 var graphAsTaskConfigSchema, GraphAsTask;
 var init_GraphAsTask = __esm(() => {
   init_GraphSchemaUtils();
@@ -3203,7 +3207,8 @@ var init_TaskGraphEvents = __esm(() => {
 });
 
 // src/task-graph/TaskGraph.ts
-import { DirectedAcyclicGraph, EventEmitter as EventEmitter4, uuid4 as uuid44 } from "@workglow/util";
+import { DirectedAcyclicGraph } from "@workglow/util/graph";
+import { EventEmitter as EventEmitter4, uuid4 as uuid44 } from "@workglow/util";
 
 class TaskGraph {
   outputCache;
@@ -3516,7 +3521,6 @@ init_Dataflow();
 
 // src/task-graph/Workflow.ts
 init_GraphAsTask();
-init_StreamTypes();
 init_TaskError();
 init_Conversions();
 init_Dataflow();
@@ -4615,7 +4619,6 @@ function resetMethodNameCache() {
 }
 // src/task/index.ts
 init_ConditionalTask();
-init_ConditionUtils();
 
 // src/task/FallbackTask.ts
 init_GraphAsTask();
@@ -4839,6 +4842,9 @@ init_GraphAsTaskRunner();
 import { uuid4 as uuid46 } from "@workglow/util";
 
 class IteratorTaskRunner extends GraphAsTaskRunner {
+  aggregatingParentMapProgress = false;
+  mapPartialProgress = [];
+  mapPartialIterationCount = 0;
   async executeTask(input) {
     const analysis = this.task.analyzeIterationInput(input);
     if (analysis.iterationCount === 0) {
@@ -4860,30 +4866,43 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
     const concurrency = Math.max(1, Math.min(requestedConcurrency, iterationCount));
     const orderedResults = preserveOrder ? new Array(iterationCount) : [];
     const completionOrderResults = [];
-    let completedCount = 0;
-    for (let batchStart = 0;batchStart < iterationCount; batchStart += batchSize) {
-      if (this.abortController?.signal.aborted) {
-        break;
-      }
-      const batchEnd = Math.min(batchStart + batchSize, iterationCount);
-      const batchIndices = Array.from({ length: batchEnd - batchStart }, (_, i) => batchStart + i);
-      const batchResults = await this.executeBatch(batchIndices, analysis, iterationCount, concurrency, async () => {
-        completedCount++;
-        const progress = Math.round(completedCount / iterationCount * 100);
-        await this.handleProgress(progress, `Completed ${completedCount}/${iterationCount} iterations`);
-      });
-      for (const { index, result } of batchResults) {
-        if (result === undefined)
-          continue;
-        if (preserveOrder) {
-          orderedResults[index] = result;
-        } else {
-          completionOrderResults.push(result);
+    this.aggregatingParentMapProgress = true;
+    this.mapPartialIterationCount = iterationCount;
+    this.mapPartialProgress = new Array(iterationCount).fill(0);
+    try {
+      for (let batchStart = 0;batchStart < iterationCount; batchStart += batchSize) {
+        if (this.abortController?.signal.aborted) {
+          break;
+        }
+        const batchEnd = Math.min(batchStart + batchSize, iterationCount);
+        const batchIndices = Array.from({ length: batchEnd - batchStart }, (_, i) => batchStart + i);
+        const batchResults = await this.executeBatch(batchIndices, analysis, iterationCount, concurrency, undefined);
+        for (const { index, result } of batchResults) {
+          if (result === undefined)
+            continue;
+          if (preserveOrder) {
+            orderedResults[index] = result;
+          } else {
+            completionOrderResults.push(result);
+          }
         }
       }
+      const collected = preserveOrder ? orderedResults.filter((result) => result !== undefined) : completionOrderResults;
+      return this.task.collectResults(collected);
+    } finally {
+      this.aggregatingParentMapProgress = false;
     }
-    const collected = preserveOrder ? orderedResults.filter((result) => result !== undefined) : completionOrderResults;
-    return this.task.collectResults(collected);
+  }
+  emitMapParentProgressFromPartials(childMessage) {
+    const n = this.mapPartialIterationCount;
+    if (n <= 0)
+      return;
+    const sum = this.mapPartialProgress.reduce((a, b) => a + b, 0);
+    const overall = Math.round(sum / n);
+    const done = this.mapPartialProgress.filter((v) => v >= 100).length;
+    const base = `Map ${done}/${n}`;
+    const msg = childMessage ? `${base} \u2014 ${childMessage}` : `${base} iterations`;
+    this.handleProgress(overall, msg);
   }
   async executeReduceIterations(analysis) {
     const iterationCount = analysis.iterationCount;
@@ -4895,7 +4914,7 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
       const iterationInput = this.task.buildIterationRunInput(analysis, index, iterationCount, {
         accumulator
       });
-      const iterationResult = await this.executeSubgraphIteration(iterationInput);
+      const iterationResult = await this.executeSubgraphIteration(iterationInput, index, iterationCount);
       accumulator = this.task.mergeIterationIntoAccumulator(accumulator, iterationResult, index);
       const progress = Math.round((index + 1) / iterationCount * 100);
       await this.handleProgress(progress, `Completed ${index + 1}/${iterationCount} iterations`);
@@ -4918,7 +4937,7 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
         }
         const index = indices[position];
         const iterationInput = this.task.buildIterationRunInput(analysis, index, iterationCount);
-        const result = await this.executeSubgraphIteration(iterationInput);
+        const result = await this.executeSubgraphIteration(iterationInput, index, iterationCount);
         results.push({ index, result });
         await onItemComplete?.();
       }
@@ -4945,20 +4964,44 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
     }
     return clone;
   }
-  async executeSubgraphIteration(input) {
+  async executeSubgraphIteration(input, index, iterationCount) {
     if (this.abortController?.signal.aborted) {
       return;
     }
     const graphClone = this.cloneGraph(this.task.subGraph);
-    const results = await graphClone.run(input, {
-      parentSignal: this.abortController?.signal,
-      outputCache: this.outputCache,
-      registry: this.registry
-    });
-    if (results.length === 0) {
-      return;
+    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 });
+    }
+    try {
+      const results = await graphClone.run(input, {
+        parentSignal: this.abortController?.signal,
+        outputCache: this.outputCache,
+        registry: this.registry
+      });
+      if (results.length === 0) {
+        return;
+      }
+      return graphClone.mergeExecuteOutputsToRunOutput(results, this.task.compoundMerge);
+    } finally {
+      for (const { task, fn } of taskProgressUnsubs) {
+        task.events.off("progress", fn);
+      }
+      if (this.aggregatingParentMapProgress && this.mapPartialIterationCount > 0) {
+        this.mapPartialProgress[index] = 100;
+        this.emitMapParentProgressFromPartials();
+      }
+      this.task.emit("iteration_complete", index, iterationCount);
     }
-    return graphClone.mergeExecuteOutputsToRunOutput(results, this.task.compoundMerge);
   }
 }
 
@@ -5456,7 +5499,6 @@ class IteratorTask extends GraphAsTask {
 }
 
 // src/task/WhileTask.ts
-init_ConditionUtils();
 init_GraphAsTask();
 init_TaskError();
 
@@ -6464,7 +6506,6 @@ queueMicrotask(() => {
 });
 
 // src/task/index.ts
-init_StreamTypes();
 init_Task();
 init_TaskError();
 
@@ -6669,7 +6710,8 @@ init_TaskOutputRepository();
 
 // src/storage/TaskOutputTabularRepository.ts
 init_TaskOutputRepository();
-import { compress, decompress, makeFingerprint } from "@workglow/util";
+import { compress, decompress } from "@workglow/util/compress";
+import { makeFingerprint } from "@workglow/util";
 var TaskOutputSchema = {
   type: "object",
   properties: {
@@ -6753,6 +6795,7 @@ class TaskOutputTabularRepository extends TaskOutputRepository {
 export {
   wrapSchemaInArray,
   whileTaskConfigSchema,
+  taskPrototypeHasOwnExecute,
   setTaskQueueRegistry,
   setGlobalTaskConstructors,
   serialGraph,
@@ -6874,4 +6917,4 @@ export {
   ConditionalTask
 };
 
-//# debugId=9EEB6F11C7BDA7A964756E2164756E21
+//# debugId=9A71E9C04775D82864756E2164756E21