@workglow/task-graph 0.2.19 → 0.2.21

package/dist/bun.js

@@ -181,7 +181,14 @@ class Dataflow {
   status = TaskStatus.PENDING;
   error;
   stream = undefined;
+  latestSnapshot = undefined;
+  getCurrentValue() {
+    if (this.value !== undefined)
+      return this.value;
+    return this.latestSnapshot;
+  }
   setStream(stream) {
+    this.latestSnapshot = undefined;
     this.stream = stream;
   }
   getStream() {
@@ -227,6 +234,7 @@ class Dataflow {
     }
   }
   reset() {
+    this.latestSnapshot = undefined;
     this.status = TaskStatus.PENDING;
     this.error = undefined;
     this.value = undefined;
@@ -272,6 +280,7 @@ class Dataflow {
     } else {
       this.value = entireDataBlock[this.sourceTaskPortId];
     }
+    this.latestSnapshot = undefined;
   }
   getPortData() {
     let result;
@@ -1143,31 +1152,7 @@ import {
   SpanStatusCode as SpanStatusCode2,
   uuid4 as uuid43
 } from "@workglow/util";
-
-// src/refcountable.ts
-var GLOBAL_KEY = Symbol.for("@workglow/task-graph/refcountable.predicates");
-var _g = globalThis;
-if (!Array.isArray(_g[GLOBAL_KEY])) {
-  _g[GLOBAL_KEY] = [];
-}
-var predicates = _g[GLOBAL_KEY];
-function registerRefcountablePredicate(p) {
-  predicates.push(p);
-}
-function asRefcountable(v) {
-  if (v === null || v === undefined)
-    return null;
-  if (typeof v !== "object")
-    return null;
-  for (const p of predicates) {
-    if (p(v))
-      return v;
-  }
-  return null;
-}
-function _resetRefcountablePredicatesForTests() {
-  predicates.length = 0;
-}
+import { previewSource } from "@workglow/util/media";
 
 // src/storage/TaskOutputRepository.ts
 import { createServiceToken as createServiceToken2, EventEmitter as EventEmitter2 } from "@workglow/util";
@@ -1436,7 +1421,6 @@ class TaskRunner {
   timeoutTimer;
   pendingTimeoutError;
   shouldAccumulate = true;
-  runWithPreviews = false;
   telemetrySpan;
   constructor(task) {
     this.task = task;
@@ -1545,6 +1529,100 @@ class TaskRunner {
       return this.task.runOutputData;
     }
   }
+  async* runPreviewStream(overrides = {}) {
+    const graph = this.task.parentGraph;
+    const dataflowInfos = [];
+    if (graph) {
+      for (const df of graph.getSourceDataflows(this.task.id)) {
+        const upstream = graph.getTask(df.sourceTaskId);
+        if (upstream) {
+          dataflowInfos.push({
+            upstream,
+            sourcePort: df.sourceTaskPortId,
+            targetPort: df.targetTaskPortId
+          });
+        }
+      }
+    }
+    const upstreamTasks = new Set(dataflowInfos.map((d) => d.upstream));
+    const pendingUpstreams = new Set([...upstreamTasks].filter((u) => u.status === TaskStatus.STREAMING || u.status === TaskStatus.PENDING || u.status === TaskStatus.PROCESSING));
+    let dirty = true;
+    let wakeResolve;
+    const wakeNext = () => new Promise((resolve) => {
+      wakeResolve = resolve;
+    });
+    const wake = () => {
+      const r = wakeResolve;
+      wakeResolve = undefined;
+      if (r)
+        r();
+    };
+    const cleanupFns = [];
+    for (const upstream of pendingUpstreams) {
+      const myDataflows = dataflowInfos.filter((d) => d.upstream === upstream);
+      const onChunk = (event) => {
+        if (event.type !== "snapshot")
+          return;
+        const snapshotData = event.data;
+        if (snapshotData) {
+          for (const { sourcePort, targetPort } of myDataflows) {
+            const value = sourcePort === "*" ? snapshotData : snapshotData[sourcePort];
+            if (value !== undefined) {
+              this.task.runInputData[targetPort] = value;
+            }
+          }
+        }
+        dirty = true;
+        wake();
+      };
+      const onEnd = () => {
+        pendingUpstreams.delete(upstream);
+        wake();
+      };
+      const onStatus = (status) => {
+        if (status === TaskStatus.COMPLETED || status === TaskStatus.FAILED || status === TaskStatus.DISABLED) {
+          pendingUpstreams.delete(upstream);
+          wake();
+        }
+      };
+      upstream.on("stream_chunk", onChunk);
+      upstream.on("stream_end", onEnd);
+      upstream.on("status", onStatus);
+      cleanupFns.push(() => {
+        upstream.off("stream_chunk", onChunk);
+        upstream.off("stream_end", onEnd);
+        upstream.off("status", onStatus);
+      });
+    }
+    for (const upstream of [...pendingUpstreams]) {
+      if (upstream.status === TaskStatus.COMPLETED || upstream.status === TaskStatus.FAILED || upstream.status === TaskStatus.DISABLED) {
+        pendingUpstreams.delete(upstream);
+      }
+    }
+    try {
+      while (true) {
+        if (dirty) {
+          dirty = false;
+          try {
+            const out = await this.runPreview(overrides);
+            yield out;
+          } catch (err) {
+            getLogger().debug("runPreviewStream iteration failed", {
+              taskId: this.task.config?.id,
+              error: err
+            });
+          }
+          continue;
+        }
+        if (pendingUpstreams.size === 0)
+          return;
+        await wakeNext();
+      }
+    } finally {
+      for (const off of cleanupFns)
+        off();
+    }
+  }
   abort() {
     if (this.task.hasChildren()) {
       this.task.subGraph.abort();
@@ -1595,7 +1673,7 @@ class TaskRunner {
     }
     const accumulated = this.shouldAccumulate ? new Map : undefined;
     const accumulatedObjects = this.shouldAccumulate ? new Map : undefined;
-    let chunkCount = 0;
+    let streamingStarted = false;
     let finalOutput;
     this.task.emit("stream_start");
     const stream = this.task.executeStream(input, {
@@ -1607,25 +1685,33 @@ class TaskRunner {
       inputStreams: this.inputStreams
     });
     for await (const event of stream) {
-      chunkCount++;
-      if (chunkCount === 1) {
-        this.task.status = TaskStatus.STREAMING;
-        this.task.emit("status", this.task.status);
-      }
       if (event.type === "snapshot") {
         this.task.runOutputData = event.data;
       }
       switch (event.type) {
+        case "phase": {
+          this.task.emit("stream_chunk", event);
+          await this.handleProgress(event.progress, event.message);
+          break;
+        }
         case "text-delta": {
+          if (!streamingStarted) {
+            streamingStarted = true;
+            this.task.status = TaskStatus.STREAMING;
+            this.task.emit("status", this.task.status);
+          }
           if (accumulated) {
             accumulated.set(event.port, (accumulated.get(event.port) ?? "") + event.textDelta);
           }
           this.task.emit("stream_chunk", event);
-          const progress = Math.min(99, Math.round(100 * (1 - Math.exp(-0.05 * chunkCount))));
-          await this.handleProgress(progress);
           break;
         }
         case "object-delta": {
+          if (!streamingStarted) {
+            streamingStarted = true;
+            this.task.status = TaskStatus.STREAMING;
+            this.task.emit("status", this.task.status);
+          }
           if (accumulatedObjects) {
             const existing = accumulatedObjects.get(event.port);
             if (Array.isArray(event.objectDelta)) {
@@ -1652,14 +1738,15 @@ class TaskRunner {
             [event.port]: accumulatedObjects?.get(event.port) ?? event.objectDelta
           };
           this.task.emit("stream_chunk", event);
-          const progress = Math.min(99, Math.round(100 * (1 - Math.exp(-0.05 * chunkCount))));
-          await this.handleProgress(progress);
           break;
         }
         case "snapshot": {
+          if (!streamingStarted) {
+            streamingStarted = true;
+            this.task.status = TaskStatus.STREAMING;
+            this.task.emit("status", this.task.status);
+          }
           this.task.emit("stream_chunk", event);
-          const progress = Math.min(99, Math.round(100 * (1 - Math.exp(-0.05 * chunkCount))));
-          await this.handleProgress(progress);
           break;
         }
         case "finish": {
@@ -1676,9 +1763,32 @@ class TaskRunner {
                 merged[port] = obj;
               }
             }
+            if (streamMode === "replace" && Object.keys(merged).length === 0) {
+              const lastSnapshot = this.task.runOutputData;
+              if (lastSnapshot && Object.keys(lastSnapshot).length > 0) {
+                finalOutput = lastSnapshot;
+                this.task.emit("stream_chunk", {
+                  type: "finish",
+                  data: lastSnapshot
+                });
+                break;
+              }
+            }
             finalOutput = merged;
             this.task.emit("stream_chunk", { type: "finish", data: merged });
           } else {
+            const finishData = event.data ?? {};
+            if (streamMode === "replace" && Object.keys(finishData).length === 0) {
+              const lastSnapshot = this.task.runOutputData;
+              if (lastSnapshot && Object.keys(lastSnapshot).length > 0) {
+                finalOutput = lastSnapshot;
+                this.task.emit("stream_chunk", {
+                  type: "finish",
+                  data: lastSnapshot
+                });
+                break;
+              }
+            }
             finalOutput = event.data;
             this.task.emit("stream_chunk", event);
           }
@@ -1719,7 +1829,6 @@ class TaskRunner {
       this.outputCache = cache;
     }
     this.shouldAccumulate = config.shouldAccumulate !== false;
-    this.runWithPreviews = config.runWithPreviews === true;
     if (config.updateProgress) {
       this.updateProgress = config.updateProgress;
     }
@@ -1774,7 +1883,7 @@ class TaskRunner {
       return;
     this.clearTimeoutTimer();
     this.task.status = TaskStatus.ABORTING;
-    this.task.progress = 100;
+    await this.handleProgress(100);
     this.task.error = this.pendingTimeoutError ?? new TaskAbortedError;
     this.pendingTimeoutError = undefined;
     if (this.telemetrySpan) {
@@ -1802,9 +1911,9 @@ class TaskRunner {
     this.clearTimeoutTimer();
     this.pendingTimeoutError = undefined;
     this.task.completedAt = new Date;
-    this.task.progress = 100;
     this.task.status = TaskStatus.COMPLETED;
     this.abortController = undefined;
+    await this.handleProgress(100);
     if (this.telemetrySpan) {
       this.telemetrySpan.setStatus(SpanStatusCode.OK);
       this.telemetrySpan.end();
@@ -1820,7 +1929,7 @@ class TaskRunner {
     if (this.task.status === TaskStatus.DISABLED)
       return;
     this.task.status = TaskStatus.DISABLED;
-    this.task.progress = 100;
+    await this.handleProgress(100);
     this.task.completedAt = new Date;
     this.abortController = undefined;
     this.task.emit("disabled");
@@ -1840,8 +1949,6 @@ class TaskRunner {
       this.task.subGraph.abort();
     }
     this.task.completedAt = new Date;
-    this.task.progress = 100;
-    this.task.status = TaskStatus.FAILED;
     if (err instanceof TaskError) {
       this.task.error = err;
     } else {
@@ -1851,7 +1958,9 @@ class TaskRunner {
       this.task.error.taskType ??= this.task.type;
       this.task.error.taskId ??= this.task.id;
     }
+    this.task.status = TaskStatus.FAILED;
     this.abortController = undefined;
+    await this.handleProgress(100);
     if (this.telemetrySpan) {
       this.telemetrySpan.setStatus(SpanStatusCode.ERROR, this.task.error.message);
       this.telemetrySpan.setAttributes({ "workglow.task.error": this.task.error.message });
@@ -1913,6 +2022,7 @@ class Task {
   async executePreview(_input, _context) {
     return;
   }
+  parentGraph;
   _runner;
   get runner() {
     if (!this._runner) {
@@ -2292,6 +2402,10 @@ class Task {
       return obj.map((item) => this.stripSymbols(item));
     }
     if (typeof obj === "object") {
+      const proto = Object.getPrototypeOf(obj);
+      if (proto !== Object.prototype && proto !== null) {
+        return obj;
+      }
       const result = {};
       for (const key in obj) {
         if (Object.prototype.hasOwnProperty.call(obj, key)) {
@@ -2882,6 +2996,12 @@ function taskPrototypeHasOwnExecute(task) {
 }
 var PROPERTY_ARRAY = "PROPERTY_ARRAY";
 var GRAPH_RESULT_ARRAY = "GRAPH_RESULT_ARRAY";
+function isImageValueShape(v) {
+  if (v === null || typeof v !== "object")
+    return false;
+  const o = v;
+  return typeof o.width === "number" && typeof o.height === "number" && typeof o.previewScale === "number";
+}
 
 class TaskGraphRunner {
   processScheduler;
@@ -2891,7 +3011,6 @@ class TaskGraphRunner {
   graph;
   outputCache;
   accumulateLeafOutputs = true;
-  runWithPreviews = false;
   registry = globalServiceRegistry3;
   resourceScope;
   abortController;
@@ -3121,27 +3240,27 @@ class TaskGraphRunner {
     const dataflows = this.graph.getSourceDataflows(task.id);
     dataflows.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
     for (const dataflow of dataflows) {
-      this.addInputData(task, dataflow.getPortData());
+      const live = dataflow.getCurrentValue();
+      const port = dataflow.targetTaskPortId;
+      let portData;
+      if (port === DATAFLOW_ALL_PORTS) {
+        portData = live;
+      } else if (port === DATAFLOW_ERROR_PORT) {
+        portData = { [DATAFLOW_ERROR_PORT]: dataflow.error };
+      } else {
+        portData = { [port]: live };
+      }
+      this.addInputData(task, portData);
     }
   }
   async pushOutputFromNodeToEdges(node, results) {
     const dataflows = this.graph.getTargetDataflows(node.id);
-    if (Object.keys(results).length > 0) {
-      const consumerCounts = new Map;
-      for (const dataflow of dataflows) {
-        if (dataflow.stream !== undefined)
-          continue;
-        const port = dataflow.sourceTaskPortId;
-        consumerCounts.set(port, (consumerCounts.get(port) ?? 0) + 1);
-      }
-      for (const [port, count] of consumerCounts) {
-        const extra = this.runWithPreviews ? count : count - 1;
-        if (extra <= 0)
-          continue;
+    if (this.previewRunning && Object.keys(results).length > 0) {
+      for (const port of Object.keys(results)) {
         const value = results[port];
-        const ref = asRefcountable(value);
-        if (ref)
-          ref.retain(extra);
+        if (isImageValueShape(value)) {
+          results[port] = await previewSource(value);
+        }
       }
     }
     for (const dataflow of dataflows) {
@@ -3313,8 +3432,7 @@ class TaskGraphRunner {
       outputCache: this.outputCache ?? false,
       updateProgress: async (task2, progress, message, ...args) => await this.handleProgress(task2, progress, message, ...args),
       registry: this.registry,
-      resourceScope: this.resourceScope,
-      runWithPreviews: this.runWithPreviews
+      resourceScope: this.resourceScope
     });
     await this.pushOutputFromNodeToEdges(task, results);
     return {
@@ -3364,8 +3482,7 @@ class TaskGraphRunner {
         shouldAccumulate,
         updateProgress: async (task2, progress, message, ...args) => await this.handleProgress(task2, progress, message, ...args),
         registry: this.registry,
-        resourceScope: this.resourceScope,
-        runWithPreviews: this.runWithPreviews
+        resourceScope: this.resourceScope
       });
       await this.pushOutputFromNodeToEdges(task, results);
       return {
@@ -3383,7 +3500,7 @@ class TaskGraphRunner {
   static isPortDelta(event) {
     return event.type === "text-delta" || event.type === "object-delta";
   }
-  createStreamFromTaskEvents(task, portId) {
+  createStreamFromTaskEvents(task, portId, edgesForGroup) {
     return new ReadableStream({
       start: (controller) => {
         const onChunk = (event) => {
@@ -3391,6 +3508,15 @@ class TaskGraphRunner {
             if (portId !== undefined && TaskGraphRunner.isPortDelta(event) && event.port !== portId) {
               return;
             }
+            if (event.type === "snapshot") {
+              const data = event.data;
+              if (data) {
+                for (const edge of edgesForGroup) {
+                  const portValue = edge.sourceTaskPortId === DATAFLOW_ALL_PORTS ? data : data[edge.sourceTaskPortId];
+                  edge.latestSnapshot = portValue;
+                }
+              }
+            }
             controller.enqueue(event);
           } catch {}
         };
@@ -3422,7 +3548,7 @@ class TaskGraphRunner {
     }
     for (const [portKey, edges] of groups) {
       const filterPort = portKey === DATAFLOW_ALL_PORTS ? undefined : portKey;
-      const stream = this.createStreamFromTaskEvents(task, filterPort);
+      const stream = this.createStreamFromTaskEvents(task, filterPort, edges);
       if (edges.length === 1) {
         edges[0].setStream(stream);
       } else {
@@ -3440,17 +3566,6 @@ class TaskGraphRunner {
     }
   }
   resetTask(graph, task, runId) {
-    const previous = task.runOutputData;
-    if (previous) {
-      for (const port of Object.keys(previous)) {
-        const ref = asRefcountable(previous[port]);
-        if (!ref)
-          continue;
-        try {
-          ref.release();
-        } catch {}
-      }
-    }
     task.status = TaskStatus.PENDING;
     task.resetInputData();
     task.runOutputData = {};
@@ -3484,7 +3599,6 @@ class TaskGraphRunner {
       this.resourceScope = config.resourceScope;
     }
     this.accumulateLeafOutputs = config?.accumulateLeafOutputs !== false;
-    this.runWithPreviews = config?.runWithPreviews === true;
     if (config?.outputCache !== undefined) {
       if (typeof config.outputCache === "boolean") {
         if (config.outputCache === true) {
@@ -3584,7 +3698,6 @@ class TaskGraphRunner {
         throw new TaskConfigurationError(`Graph has ${taskCount} tasks, exceeding the limit of ${config.maxTasks}`);
       }
     }
-    this.runWithPreviews = false;
     this.previewScheduler.reset();
     this.previewRunning = true;
   }
@@ -3660,15 +3773,21 @@ class TaskGraphRunner {
   async handleProgress(task, progress, message, ...args) {
     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);
+      const determinate = contributors.filter((t) => t.progress !== undefined);
+      if (determinate.length === 0) {
+        progress = undefined;
+      } else {
+        const sum = determinate.reduce((acc, t) => acc + t.progress, 0);
+        progress = Math.round(sum / determinate.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) {
+    const isActive = task.status === TaskStatus.PROCESSING || task.status === TaskStatus.STREAMING;
+    if (isActive && task.runOutputData && Object.keys(task.runOutputData).length > 0) {
       await this.pushOutputFromNodeToEdges(task, task.runOutputData);
     }
   }
@@ -3684,8 +3803,7 @@ class GraphAsTaskRunner extends TaskRunner {
       parentSignal: this.abortController?.signal,
       outputCache: this.outputCache,
       registry: this.registry,
-      resourceScope: this.resourceScope,
-      runWithPreviews: this.runWithPreviews
+      resourceScope: this.resourceScope
     });
     unsubscribe();
     return results;
@@ -4148,8 +4266,7 @@ class TaskGraph {
       registry: config?.registry,
       timeout: config?.timeout,
       maxTasks: config?.maxTasks,
-      resourceScope: config?.resourceScope,
-      runWithPreviews: config?.runWithPreviews
+      resourceScope: config?.resourceScope
     });
   }
   runPreview(input = {}, config = {}) {
@@ -4177,10 +4294,16 @@ class TaskGraph {
     return this._dag.isAcyclic();
   }
   addTask(task, config) {
-    return this._dag.addNode(ensureTask(task, config));
+    const t = ensureTask(task, config);
+    t.parentGraph = this;
+    return this._dag.addNode(t);
   }
   addTasks(tasks) {
-    return this._dag.addNodes(tasks.map(ensureTask));
+    const resolved = tasks.map(ensureTask);
+    for (const t of resolved) {
+      t.parentGraph = this;
+    }
+    return this._dag.addNodes(resolved);
   }
   addDataflow(dataflow) {
     return this._dag.addEdge(dataflow.sourceTaskId, dataflow.targetTaskId, dataflow);
@@ -5002,8 +5125,7 @@ class Workflow {
         parentSignal: this._abortController.signal,
         outputCache: this._outputCache,
         registry: config?.registry ?? this._registry,
-        resourceScope: config?.resourceScope,
-        runWithPreviews: config?.runWithPreviews
+        resourceScope: config?.resourceScope
       });
       const results = this.graph.mergeExecuteOutputsToRunOutput(output, PROPERTY_ARRAY);
       this.events.emit("complete");
@@ -6084,6 +6206,8 @@ class FallbackTaskRunner extends GraphAsTaskRunner {
     const totalAttempts = alternatives.length;
     let currentAttemptIndex = 0;
     const onSubgraphProgress = (innerProgress, message) => {
+      if (innerProgress === undefined)
+        return;
       const blended = Math.round((currentAttemptIndex + innerProgress / 100) / totalAttempts * 100);
       this.handleProgress(blended, message ?? `Data alternative ${currentAttemptIndex + 1}/${totalAttempts}`);
     };
@@ -6457,7 +6581,7 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
     this.task.emit("iteration_start", index, iterationCount);
     const onGraphProgress = (p, message) => {
       this.task.emit("iteration_progress", index, iterationCount, p, message);
-      if (this.aggregatingParentMapProgress && this.mapPartialIterationCount > 0) {
+      if (p !== undefined && this.aggregatingParentMapProgress && this.mapPartialIterationCount > 0) {
         this.mapPartialProgress[index] = Math.max(this.mapPartialProgress[index] ?? 0, p);
         this.emitMapParentProgressFromPartials(message);
       }
@@ -7168,6 +7292,8 @@ class WhileTask extends GraphAsTask {
     let currentOutput = {};
     const effectiveMax = arrayAnalysis ? Math.min(this.maxIterations, arrayAnalysis.iterationCount) : this.maxIterations;
     const onInnerGraphProgress = (innerProgress, innerMessage) => {
+      if (innerProgress === undefined)
+        return;
       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);
@@ -7243,6 +7369,8 @@ ${err.stack}`;
     let currentOutput = {};
     const effectiveMax = arrayAnalysis ? Math.min(this.maxIterations, arrayAnalysis.iterationCount) : this.maxIterations;
     const onInnerGraphProgress = (innerProgress, innerMessage) => {
+      if (innerProgress === undefined)
+        return;
       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);
@@ -8243,8 +8371,6 @@ import {
   getPortCodec as getPortCodec2,
   _resetPortCodecsForTests
 } from "@workglow/util";
-// src/bun.ts
-registerRefcountablePredicate((v) => !!v && typeof v === "object" && ("backend" in v) && ("retain" in v) && ("release" in v) && ("materialize" in v));
 export {
   wrapSchemaInArray,
   whileTaskConfigSchema,
@@ -8267,7 +8393,6 @@ export {
   resolveIterationBound,
   resetMethodNameCache,
   removeIterationProperties,
-  registerRefcountablePredicate,
   registerPortCodec,
   registerJobQueueFactory,
   registerBuiltInTransforms,
@@ -8351,11 +8476,9 @@ export {
   calculateNodeDepths,
   buildIterationInputSchema,
   autoConnect,
-  asRefcountable,
   addIterationContextToSchema,
   addBoundaryNodesToGraphJson,
   addBoundaryNodesToDependencyJson,
-  _resetRefcountablePredicatesForTests,
   _resetPortCodecsForTests,
   WorkflowError,
   Workflow,
@@ -8430,4 +8553,4 @@ export {
   BROWSER_GRANTS
 };
 
-//# debugId=AA782C3ACDE0213064756E2164756E21
+//# debugId=22AE56374368DB4A64756E2164756E21