@workglow/task-graph 0.0.125 → 0.0.126

package/dist/bun.js

@@ -1,90 +1,52 @@
 // @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+// src/task-graph/Dataflow.ts
+import { areSemanticallyCompatible } from "@workglow/util/schema";
+import { EventEmitter } from "@workglow/util";
 
 // src/task/TaskTypes.ts
-var TaskStatus, TaskConfigSchema;
-var init_TaskTypes = __esm(() => {
-  TaskStatus = {
-    PENDING: "PENDING",
-    DISABLED: "DISABLED",
-    PROCESSING: "PROCESSING",
-    STREAMING: "STREAMING",
-    COMPLETED: "COMPLETED",
-    ABORTING: "ABORTING",
-    FAILED: "FAILED"
-  };
-  TaskConfigSchema = {
-    type: "object",
-    properties: {
-      id: {
-        "x-ui-hidden": true
-      },
-      title: { type: "string" },
-      description: { type: "string" },
-      cacheable: { type: "boolean" },
-      timeout: { type: "number", description: "Max execution time in milliseconds" },
-      inputSchema: {
-        type: "object",
-        properties: {},
-        additionalProperties: true,
-        "x-ui-hidden": true
-      },
-      outputSchema: {
-        type: "object",
-        properties: {},
-        additionalProperties: true,
-        "x-ui-hidden": true
-      },
-      extras: {
-        type: "object",
-        additionalProperties: true,
-        "x-ui-hidden": true
-      }
+var TaskStatus = {
+  PENDING: "PENDING",
+  DISABLED: "DISABLED",
+  PROCESSING: "PROCESSING",
+  STREAMING: "STREAMING",
+  COMPLETED: "COMPLETED",
+  ABORTING: "ABORTING",
+  FAILED: "FAILED"
+};
+var TaskConfigSchema = {
+  type: "object",
+  properties: {
+    id: {
+      "x-ui-hidden": true
     },
-    additionalProperties: false
-  };
-});
+    title: { type: "string" },
+    description: { type: "string" },
+    cacheable: { type: "boolean" },
+    timeout: { type: "number", description: "Max execution time in milliseconds" },
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: true,
+      "x-ui-hidden": true
+    },
+    outputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: true,
+      "x-ui-hidden": true
+    },
+    extras: {
+      type: "object",
+      additionalProperties: true,
+      "x-ui-hidden": true
+    }
+  },
+  additionalProperties: false
+};
 
 // src/task-graph/Dataflow.ts
-import { areSemanticallyCompatible } from "@workglow/util/schema";
-import { EventEmitter } from "@workglow/util";
+var DATAFLOW_ALL_PORTS = "*";
+var DATAFLOW_ERROR_PORT = "[error]";
 
 class Dataflow {
   sourceTaskId;
@@ -269,22 +231,18 @@ class Dataflow {
     this._events?.emit(name, ...args);
   }
 }
-var DATAFLOW_ALL_PORTS = "*", DATAFLOW_ERROR_PORT = "[error]", DataflowArrow;
-var init_Dataflow = __esm(() => {
-  init_TaskTypes();
-  DataflowArrow = class DataflowArrow extends Dataflow {
-    constructor(dataflow) {
-      const pattern = /^([a-zA-Z0-9-]+?)\[([a-zA-Z0-9-]+?)\] ==> ([a-zA-Z0-9-]+?)\[([a-zA-Z0-9-]+?)\]$/;
-      const match = dataflow.match(pattern);
-      if (!match) {
-        throw new Error(`Invalid dataflow format: ${dataflow}`);
-      }
-      const [, sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId] = match;
-      super(sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId);
-    }
-  };
-});
 
+class DataflowArrow extends Dataflow {
+  constructor(dataflow) {
+    const pattern = /^([a-zA-Z0-9-]+?)\[([a-zA-Z0-9-]+?)\] ==> ([a-zA-Z0-9-]+?)\[([a-zA-Z0-9-]+?)\]$/;
+    const match = dataflow.match(pattern);
+    if (!match) {
+      throw new Error(`Invalid dataflow format: ${dataflow}`);
+    }
+    const [, sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId] = match;
+    super(sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId);
+  }
+}
 // src/task-graph/GraphSchemaUtils.ts
 import { uuid4 } from "@workglow/util";
 function calculateNodeDepths(graph) {
@@ -633,74 +591,27 @@ function addBoundaryNodesToDependencyJson(items, graph) {
   }
   return [...prependItems, ...items, ...appendItems];
 }
-var init_GraphSchemaUtils = __esm(() => {
-  init_Dataflow();
-});
+// src/task-graph/TaskGraph.ts
+import { DirectedAcyclicGraph } from "@workglow/util/graph";
+import { EventEmitter as EventEmitter4, uuid4 as uuid44 } from "@workglow/util";
 
-// src/task/TaskError.ts
-import { BaseError } from "@workglow/util";
-var TaskError, TaskConfigurationError, WorkflowError, TaskAbortedError, TaskTimeoutError, TaskFailedError, JobTaskFailedError, TaskJSONError, TaskInvalidInputError;
-var init_TaskError = __esm(() => {
-  TaskError = class TaskError extends BaseError {
-    static type = "TaskError";
-    constructor(message) {
-      super(message);
-    }
-  };
-  TaskConfigurationError = class TaskConfigurationError extends TaskError {
-    static type = "TaskConfigurationError";
-    constructor(message) {
-      super(message);
-    }
-  };
-  WorkflowError = class WorkflowError extends TaskError {
-    static type = "WorkflowError";
-    constructor(message) {
-      super(message);
-    }
-  };
-  TaskAbortedError = class TaskAbortedError extends TaskError {
-    static type = "TaskAbortedError";
-    constructor(message = "Task aborted") {
-      super(message);
-    }
-  };
-  TaskTimeoutError = class TaskTimeoutError extends TaskAbortedError {
-    static type = "TaskTimeoutError";
-    constructor(timeoutMs) {
-      super(timeoutMs ? `Task timed out after ${timeoutMs}ms` : "Task timed out");
-    }
-  };
-  TaskFailedError = class TaskFailedError extends TaskError {
-    static type = "TaskFailedError";
-    constructor(message = "Task failed") {
-      super(message);
-    }
-  };
-  JobTaskFailedError = class JobTaskFailedError extends TaskFailedError {
-    static type = "JobTaskFailedError";
-    jobError;
-    constructor(err) {
-      super(String(err));
-      this.jobError = err;
-    }
-  };
-  TaskJSONError = class TaskJSONError extends TaskError {
-    static type = "TaskJSONError";
-    constructor(message = "Error converting JSON to a Task") {
-      super(message);
-    }
-  };
-  TaskInvalidInputError = class TaskInvalidInputError extends TaskError {
-    static type = "TaskInvalidInputError";
-    constructor(message = "Invalid input data") {
-      super(message);
-    }
-  };
-});
+// src/task/GraphAsTask.ts
+import { compileSchema as compileSchema2 } from "@workglow/util/schema";
+
+// src/task-graph/TaskGraphRunner.ts
+import {
+  collectPropertyValues,
+  getLogger as getLogger2,
+  getTelemetryProvider as getTelemetryProvider2,
+  globalServiceRegistry as globalServiceRegistry2,
+  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");
 
 class TaskOutputRepository {
   outputCompression;
@@ -727,10 +638,155 @@ class TaskOutputRepository {
     this._events?.emit(name, ...args);
   }
 }
-var TASK_OUTPUT_REPOSITORY;
-var init_TaskOutputRepository = __esm(() => {
-  TASK_OUTPUT_REPOSITORY = createServiceToken("taskgraph.taskOutputRepository");
-});
+
+// src/task/ConditionalTask.ts
+import { getLogger } from "@workglow/util";
+
+// src/task/ConditionUtils.ts
+function evaluateCondition(fieldValue, operator, compareValue) {
+  if (fieldValue === null || fieldValue === undefined) {
+    switch (operator) {
+      case "is_empty":
+        return true;
+      case "is_not_empty":
+        return false;
+      case "is_true":
+        return false;
+      case "is_false":
+        return true;
+      default:
+        return false;
+    }
+  }
+  const strValue = String(fieldValue);
+  const numValue = Number(fieldValue);
+  switch (operator) {
+    case "equals":
+      if (!isNaN(numValue) && !isNaN(Number(compareValue))) {
+        return numValue === Number(compareValue);
+      }
+      return strValue === compareValue;
+    case "not_equals":
+      if (!isNaN(numValue) && !isNaN(Number(compareValue))) {
+        return numValue !== Number(compareValue);
+      }
+      return strValue !== compareValue;
+    case "greater_than":
+      return numValue > Number(compareValue);
+    case "greater_or_equal":
+      return numValue >= Number(compareValue);
+    case "less_than":
+      return numValue < Number(compareValue);
+    case "less_or_equal":
+      return numValue <= Number(compareValue);
+    case "contains":
+      return strValue.toLowerCase().includes(compareValue.toLowerCase());
+    case "starts_with":
+      return strValue.toLowerCase().startsWith(compareValue.toLowerCase());
+    case "ends_with":
+      return strValue.toLowerCase().endsWith(compareValue.toLowerCase());
+    case "is_empty":
+      return strValue === "" || Array.isArray(fieldValue) && fieldValue.length === 0;
+    case "is_not_empty":
+      return strValue !== "" && !(Array.isArray(fieldValue) && fieldValue.length === 0);
+    case "is_true":
+      return Boolean(fieldValue) === true;
+    case "is_false":
+      return Boolean(fieldValue) === false;
+    default:
+      return false;
+  }
+}
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== "object") {
+      return;
+    }
+    current = current[part];
+  }
+  return current;
+}
+
+// src/task/Task.ts
+import { compileSchema } from "@workglow/util/schema";
+import { deepEqual, EventEmitter as EventEmitter3, uuid4 as uuid42 } from "@workglow/util";
+
+// src/task/TaskError.ts
+import { BaseError } from "@workglow/util";
+
+class TaskError extends BaseError {
+  static type = "TaskError";
+  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 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);
+  }
+}
+
+// src/task/TaskRunner.ts
+import {
+  getTelemetryProvider,
+  globalServiceRegistry,
+  SpanStatusCode
+} from "@workglow/util";
 
 // src/task/InputResolver.ts
 import { getInputResolvers } from "@workglow/util";
@@ -813,7 +869,6 @@ async function resolveSchemaInputs(input, schema, config) {
   }
   return resolved;
 }
-var init_InputResolver = () => {};
 
 // src/task/StreamTypes.ts
 function getPortStreamMode(schema, portId) {
@@ -917,11 +972,6 @@ function hasStructuredOutput(schema) {
 }
 
 // src/task/TaskRunner.ts
-import {
-  getTelemetryProvider,
-  globalServiceRegistry,
-  SpanStatusCode
-} from "@workglow/util";
 function hasRunConfig(i) {
   return i !== null && typeof i === "object" && "runConfig" in i;
 }
@@ -1298,18 +1348,8 @@ class TaskRunner {
     await this.updateProgress(this.task, progress, message, ...args);
   }
 }
-var init_TaskRunner = __esm(() => {
-  init_TaskOutputRepository();
-  init_Conversions();
-  init_InputResolver();
-  init_TaskError();
-  init_TaskTypes();
-});
 
 // src/task/Task.ts
-import { compileSchema } from "@workglow/util/schema";
-import { deepEqual, EventEmitter as EventEmitter3, uuid4 as uuid42 } from "@workglow/util";
-
 class Task {
   static type = "Task";
   static category = "Hidden";
@@ -1789,146 +1829,52 @@ class Task {
     this.events.emit("regenerate");
   }
 }
-var init_Task = __esm(() => {
-  init_Dataflow();
-  init_TaskGraph();
-  init_TaskError();
-  init_TaskRunner();
-  init_TaskTypes();
-});
-
-// src/task/ConditionUtils.ts
-function evaluateCondition(fieldValue, operator, compareValue) {
-  if (fieldValue === null || fieldValue === undefined) {
-    switch (operator) {
-      case "is_empty":
-        return true;
-      case "is_not_empty":
-        return false;
-      case "is_true":
-        return false;
-      case "is_false":
-        return true;
-      default:
-        return false;
-    }
-  }
-  const strValue = String(fieldValue);
-  const numValue = Number(fieldValue);
-  switch (operator) {
-    case "equals":
-      if (!isNaN(numValue) && !isNaN(Number(compareValue))) {
-        return numValue === Number(compareValue);
-      }
-      return strValue === compareValue;
-    case "not_equals":
-      if (!isNaN(numValue) && !isNaN(Number(compareValue))) {
-        return numValue !== Number(compareValue);
-      }
-      return strValue !== compareValue;
-    case "greater_than":
-      return numValue > Number(compareValue);
-    case "greater_or_equal":
-      return numValue >= Number(compareValue);
-    case "less_than":
-      return numValue < Number(compareValue);
-    case "less_or_equal":
-      return numValue <= Number(compareValue);
-    case "contains":
-      return strValue.toLowerCase().includes(compareValue.toLowerCase());
-    case "starts_with":
-      return strValue.toLowerCase().startsWith(compareValue.toLowerCase());
-    case "ends_with":
-      return strValue.toLowerCase().endsWith(compareValue.toLowerCase());
-    case "is_empty":
-      return strValue === "" || Array.isArray(fieldValue) && fieldValue.length === 0;
-    case "is_not_empty":
-      return strValue !== "" && !(Array.isArray(fieldValue) && fieldValue.length === 0);
-    case "is_true":
-      return Boolean(fieldValue) === true;
-    case "is_false":
-      return Boolean(fieldValue) === false;
-    default:
-      return false;
-  }
-}
-function getNestedValue(obj, path) {
-  const parts = path.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current === null || current === undefined || typeof current !== "object") {
-      return;
-    }
-    current = current[part];
-  }
-  return current;
-}
 
 // src/task/ConditionalTask.ts
-import { getLogger } from "@workglow/util";
-var conditionalTaskConfigSchema, ConditionalTask;
-var init_ConditionalTask = __esm(() => {
-  init_Task();
-  init_TaskTypes();
-  conditionalTaskConfigSchema = {
-    type: "object",
-    properties: {
-      ...TaskConfigSchema["properties"],
-      branches: { type: "array", items: {} },
-      defaultBranch: { type: "string" },
-      exclusive: { type: "boolean" },
-      conditionConfig: { type: "object", additionalProperties: true }
-    },
-    additionalProperties: false
-  };
-  ConditionalTask = class ConditionalTask extends Task {
-    static type = "ConditionalTask";
-    static category = "Flow Control";
-    static title = "Condition";
-    static description = "Route data based on conditions";
-    static hasDynamicSchemas = true;
-    static configSchema() {
-      return conditionalTaskConfigSchema;
-    }
-    activeBranches = new Set;
-    buildBranchesFromConditionConfig(conditionConfig) {
-      if (!conditionConfig?.branches || conditionConfig.branches.length === 0) {
-        return [
-          {
-            id: "default",
-            condition: () => true,
-            outputPort: "1"
-          }
-        ];
-      }
-      return conditionConfig.branches.map((branch, index) => ({
-        id: branch.id,
-        outputPort: String(index + 1),
-        condition: (inputData) => {
-          const fieldValue = getNestedValue(inputData, branch.field);
-          return evaluateCondition(fieldValue, branch.operator, branch.value);
+var conditionalTaskConfigSchema = {
+  type: "object",
+  properties: {
+    ...TaskConfigSchema["properties"],
+    branches: { type: "array", items: {} },
+    defaultBranch: { type: "string" },
+    exclusive: { type: "boolean" },
+    conditionConfig: { type: "object", additionalProperties: true }
+  },
+  additionalProperties: false
+};
+
+class ConditionalTask extends Task {
+  static type = "ConditionalTask";
+  static category = "Flow Control";
+  static title = "Condition";
+  static description = "Route data based on conditions";
+  static hasDynamicSchemas = true;
+  static configSchema() {
+    return conditionalTaskConfigSchema;
+  }
+  activeBranches = new Set;
+  buildBranchesFromConditionConfig(conditionConfig) {
+    if (!conditionConfig?.branches || conditionConfig.branches.length === 0) {
+      return [
+        {
+          id: "default",
+          condition: () => true,
+          outputPort: "1"
         }
-      }));
+      ];
     }
-    resolveBranches(input) {
-      const configBranches = this.config.branches ?? [];
-      if (configBranches.length > 0 && typeof configBranches[0].condition === "function") {
-        return {
-          branches: configBranches,
-          isExclusive: this.config.exclusive ?? true,
-          defaultBranch: this.config.defaultBranch,
-          fromConditionConfig: false
-        };
-      }
-      const conditionConfig = input.conditionConfig ?? this.config.conditionConfig;
-      if (conditionConfig) {
-        return {
-          branches: this.buildBranchesFromConditionConfig(conditionConfig),
-          isExclusive: conditionConfig.exclusive ?? true,
-          defaultBranch: conditionConfig.defaultBranch,
-          fromConditionConfig: true
-        };
+    return conditionConfig.branches.map((branch, index) => ({
+      id: branch.id,
+      outputPort: String(index + 1),
+      condition: (inputData) => {
+        const fieldValue = getNestedValue(inputData, branch.field);
+        return evaluateCondition(fieldValue, branch.operator, branch.value);
       }
+    }));
+  }
+  resolveBranches(input) {
+    const configBranches = this.config.branches ?? [];
+    if (configBranches.length > 0 && typeof configBranches[0].condition === "function") {
       return {
         branches: configBranches,
         isExclusive: this.config.exclusive ?? true,
@@ -1936,146 +1882,161 @@ var init_ConditionalTask = __esm(() => {
         fromConditionConfig: false
       };
     }
-    async execute(input, context) {
-      if (context.signal?.aborted) {
-        return;
-      }
-      this.activeBranches.clear();
-      const { branches, isExclusive, defaultBranch, fromConditionConfig } = this.resolveBranches(input);
-      for (const branch of branches) {
-        try {
-          const isActive = branch.condition(input);
-          if (isActive) {
-            this.activeBranches.add(branch.id);
-            if (isExclusive) {
-              break;
-            }
+    const conditionConfig = input.conditionConfig ?? this.config.conditionConfig;
+    if (conditionConfig) {
+      return {
+        branches: this.buildBranchesFromConditionConfig(conditionConfig),
+        isExclusive: conditionConfig.exclusive ?? true,
+        defaultBranch: conditionConfig.defaultBranch,
+        fromConditionConfig: true
+      };
+    }
+    return {
+      branches: configBranches,
+      isExclusive: this.config.exclusive ?? true,
+      defaultBranch: this.config.defaultBranch,
+      fromConditionConfig: false
+    };
+  }
+  async execute(input, context) {
+    if (context.signal?.aborted) {
+      return;
+    }
+    this.activeBranches.clear();
+    const { branches, isExclusive, defaultBranch, fromConditionConfig } = this.resolveBranches(input);
+    for (const branch of branches) {
+      try {
+        const isActive = branch.condition(input);
+        if (isActive) {
+          this.activeBranches.add(branch.id);
+          if (isExclusive) {
+            break;
           }
-        } catch (error) {
-          getLogger().warn(`Condition evaluation failed for branch "${branch.id}":`, { error });
-        }
-      }
-      if (this.activeBranches.size === 0 && defaultBranch) {
-        const defaultBranchExists = branches.some((b) => b.id === defaultBranch);
-        if (defaultBranchExists) {
-          this.activeBranches.add(defaultBranch);
         }
+      } catch (error) {
+        getLogger().warn(`Condition evaluation failed for branch "${branch.id}":`, { error });
       }
-      if (fromConditionConfig) {
-        return this.buildConditionConfigOutput(input, branches, isExclusive);
+    }
+    if (this.activeBranches.size === 0 && defaultBranch) {
+      const defaultBranchExists = branches.some((b) => b.id === defaultBranch);
+      if (defaultBranchExists) {
+        this.activeBranches.add(defaultBranch);
       }
-      return this.buildOutput(input);
     }
-    buildConditionConfigOutput(input, branches, isExclusive) {
-      const output = {};
-      const { conditionConfig, ...passThrough } = input;
-      const inputKeys = Object.keys(passThrough);
-      let matchedBranchNumber = null;
-      for (let i = 0;i < branches.length; i++) {
-        if (this.activeBranches.has(branches[i].id)) {
-          if (matchedBranchNumber === null) {
-            matchedBranchNumber = i + 1;
-          }
+    if (fromConditionConfig) {
+      return this.buildConditionConfigOutput(input, branches, isExclusive);
+    }
+    return this.buildOutput(input);
+  }
+  buildConditionConfigOutput(input, branches, isExclusive) {
+    const output = {};
+    const { conditionConfig, ...passThrough } = input;
+    const inputKeys = Object.keys(passThrough);
+    let matchedBranchNumber = null;
+    for (let i = 0;i < branches.length; i++) {
+      if (this.activeBranches.has(branches[i].id)) {
+        if (matchedBranchNumber === null) {
+          matchedBranchNumber = i + 1;
         }
       }
-      if (isExclusive) {
-        if (matchedBranchNumber !== null) {
-          for (const key of inputKeys) {
-            output[`${key}_${matchedBranchNumber}`] = passThrough[key];
-          }
-        } else {
-          for (const key of inputKeys) {
-            output[`${key}_else`] = passThrough[key];
-          }
+    }
+    if (isExclusive) {
+      if (matchedBranchNumber !== null) {
+        for (const key of inputKeys) {
+          output[`${key}_${matchedBranchNumber}`] = passThrough[key];
         }
       } else {
-        for (let i = 0;i < branches.length; i++) {
-          if (this.activeBranches.has(branches[i].id)) {
-            for (const key of inputKeys) {
-              output[`${key}_${i + 1}`] = passThrough[key];
-            }
-          }
+        for (const key of inputKeys) {
+          output[`${key}_else`] = passThrough[key];
         }
       }
-      return output;
-    }
-    buildOutput(input) {
-      const output = {
-        _activeBranches: Array.from(this.activeBranches)
-      };
-      const branches = this.config.branches ?? [];
-      for (const branch of branches) {
-        if (this.activeBranches.has(branch.id)) {
-          output[branch.outputPort] = { ...input };
+    } else {
+      for (let i = 0;i < branches.length; i++) {
+        if (this.activeBranches.has(branches[i].id)) {
+          for (const key of inputKeys) {
+            output[`${key}_${i + 1}`] = passThrough[key];
+          }
         }
       }
-      return output;
-    }
-    isBranchActive(branchId) {
-      return this.activeBranches.has(branchId);
-    }
-    getActiveBranches() {
-      return new Set(this.activeBranches);
     }
-    getPortActiveStatus() {
-      const status = new Map;
-      const branches = this.config.branches ?? [];
-      for (const branch of branches) {
-        status.set(branch.outputPort, this.activeBranches.has(branch.id));
+    return output;
+  }
+  buildOutput(input) {
+    const output = {
+      _activeBranches: Array.from(this.activeBranches)
+    };
+    const branches = this.config.branches ?? [];
+    for (const branch of branches) {
+      if (this.activeBranches.has(branch.id)) {
+        output[branch.outputPort] = { ...input };
       }
-      return status;
     }
-    static outputSchema() {
-      return {
-        type: "object",
-        properties: {
-          _activeBranches: {
-            type: "array",
-            items: { type: "string" },
-            description: "List of active branch IDs after condition evaluation"
-          }
-        },
-        additionalProperties: true
-      };
+    return output;
+  }
+  isBranchActive(branchId) {
+    return this.activeBranches.has(branchId);
+  }
+  getActiveBranches() {
+    return new Set(this.activeBranches);
+  }
+  getPortActiveStatus() {
+    const status = new Map;
+    const branches = this.config.branches ?? [];
+    for (const branch of branches) {
+      status.set(branch.outputPort, this.activeBranches.has(branch.id));
     }
-    outputSchema() {
-      const branches = this.config?.branches ?? [];
-      const properties = {
+    return status;
+  }
+  static outputSchema() {
+    return {
+      type: "object",
+      properties: {
         _activeBranches: {
           type: "array",
           items: { type: "string" },
           description: "List of active branch IDs after condition evaluation"
         }
-      };
-      for (const branch of branches) {
-        properties[branch.outputPort] = {
-          type: "object",
-          description: `Output for branch "${branch.id}" when active`,
-          additionalProperties: true
-        };
+      },
+      additionalProperties: true
+    };
+  }
+  outputSchema() {
+    const branches = this.config?.branches ?? [];
+    const properties = {
+      _activeBranches: {
+        type: "array",
+        items: { type: "string" },
+        description: "List of active branch IDs after condition evaluation"
       }
-      return {
-        type: "object",
-        properties,
-        additionalProperties: false
-      };
-    }
-    static inputSchema() {
-      return {
-        type: "object",
-        properties: {},
-        additionalProperties: true
-      };
-    }
-    inputSchema() {
-      return {
+    };
+    for (const branch of branches) {
+      properties[branch.outputPort] = {
         type: "object",
-        properties: {},
+        description: `Output for branch "${branch.id}" when active`,
         additionalProperties: true
       };
     }
-  };
-});
+    return {
+      type: "object",
+      properties,
+      additionalProperties: false
+    };
+  }
+  static inputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+  }
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+  }
+}
 
 // src/task-graph/TaskGraphScheduler.ts
 class TopologicalScheduler {
@@ -2220,24 +2181,14 @@ class DependencyBasedScheduler {
     this.nextResolver = null;
   }
 }
-var init_TaskGraphScheduler = __esm(() => {
-  init_TaskTypes();
-});
 
 // src/task-graph/TaskGraphRunner.ts
-import {
-  collectPropertyValues,
-  getLogger as getLogger2,
-  getTelemetryProvider as getTelemetryProvider2,
-  globalServiceRegistry as globalServiceRegistry2,
-  ServiceRegistry as ServiceRegistry2,
-  SpanStatusCode as SpanStatusCode2,
-  uuid4 as uuid43
-} from "@workglow/util";
 function taskPrototypeHasOwnExecute(task) {
   const Ctor = task.constructor;
   return Object.hasOwn(Ctor.prototype, "execute");
 }
+var PROPERTY_ARRAY = "PROPERTY_ARRAY";
+var GRAPH_RESULT_ARRAY = "GRAPH_RESULT_ARRAY";
 
 class TaskGraphRunner {
   processScheduler;
@@ -2839,254 +2790,231 @@ class TaskGraphRunner {
     }
   }
 }
-var PROPERTY_ARRAY = "PROPERTY_ARRAY", GRAPH_RESULT_ARRAY = "GRAPH_RESULT_ARRAY";
-var init_TaskGraphRunner = __esm(() => {
-  init_TaskOutputRepository();
-  init_ConditionalTask();
-  init_TaskError();
-  init_TaskTypes();
-  init_Dataflow();
-  init_TaskGraphScheduler();
-});
 
 // src/task/GraphAsTaskRunner.ts
-var GraphAsTaskRunner;
-var init_GraphAsTaskRunner = __esm(() => {
-  init_TaskRunner();
-  GraphAsTaskRunner = 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);
-      });
-      const results = await this.task.subGraph.run(input, {
-        parentSignal: this.abortController?.signal,
-        outputCache: this.outputCache,
-        registry: this.registry
-      });
-      unsubscribe();
-      return results;
-    }
-    async executeTaskChildrenReactive() {
-      return this.task.subGraph.runReactive(this.task.runInputData, {
-        registry: this.registry
-      });
-    }
-    async handleDisable() {
-      if (this.task.hasChildren()) {
-        await this.task.subGraph.disable();
-      }
-      super.handleDisable();
+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);
+    });
+    const results = await this.task.subGraph.run(input, {
+      parentSignal: this.abortController?.signal,
+      outputCache: this.outputCache,
+      registry: this.registry
+    });
+    unsubscribe();
+    return results;
+  }
+  async executeTaskChildrenReactive() {
+    return this.task.subGraph.runReactive(this.task.runInputData, {
+      registry: this.registry
+    });
+  }
+  async handleDisable() {
+    if (this.task.hasChildren()) {
+      await this.task.subGraph.disable();
     }
-    async executeTask(input) {
-      if (this.task.hasChildren()) {
-        const runExecuteOutputData = await this.executeTaskChildren(input);
-        this.task.runOutputData = this.task.subGraph.mergeExecuteOutputsToRunOutput(runExecuteOutputData, this.task.compoundMerge);
-      } else {
-        const result = await super.executeTask(input);
-        this.task.runOutputData = result ?? {};
-      }
-      return this.task.runOutputData;
+    super.handleDisable();
+  }
+  async executeTask(input) {
+    if (this.task.hasChildren()) {
+      const runExecuteOutputData = await this.executeTaskChildren(input);
+      this.task.runOutputData = this.task.subGraph.mergeExecuteOutputsToRunOutput(runExecuteOutputData, this.task.compoundMerge);
+    } else {
+      const result = await super.executeTask(input);
+      this.task.runOutputData = result ?? {};
     }
-    async executeTaskReactive(input, output) {
-      if (this.task.hasChildren()) {
-        const reactiveResults = await this.executeTaskChildrenReactive();
-        this.task.runOutputData = this.task.subGraph.mergeExecuteOutputsToRunOutput(reactiveResults, this.task.compoundMerge);
-      } else {
-        const reactiveResults = await super.executeTaskReactive(input, output);
-        this.task.runOutputData = Object.assign({}, output, reactiveResults ?? {});
-      }
-      return this.task.runOutputData;
+    return this.task.runOutputData;
+  }
+  async executeTaskReactive(input, output) {
+    if (this.task.hasChildren()) {
+      const reactiveResults = await this.executeTaskChildrenReactive();
+      this.task.runOutputData = this.task.subGraph.mergeExecuteOutputsToRunOutput(reactiveResults, this.task.compoundMerge);
+    } else {
+      const reactiveResults = await super.executeTaskReactive(input, output);
+      this.task.runOutputData = Object.assign({}, output, reactiveResults ?? {});
     }
-  };
-});
+    return this.task.runOutputData;
+  }
+}
 
 // src/task/GraphAsTask.ts
-var exports_GraphAsTask = {};
-__export(exports_GraphAsTask, {
-  graphAsTaskConfigSchema: () => graphAsTaskConfigSchema,
-  GraphAsTask: () => GraphAsTask
-});
-import { compileSchema as compileSchema2 } from "@workglow/util/schema";
-var graphAsTaskConfigSchema, GraphAsTask;
-var init_GraphAsTask = __esm(() => {
-  init_GraphSchemaUtils();
-  init_TaskGraphRunner();
-  init_GraphAsTaskRunner();
-  init_Task();
-  init_TaskTypes();
-  graphAsTaskConfigSchema = {
-    type: "object",
-    properties: {
-      ...TaskConfigSchema["properties"],
-      compoundMerge: { type: "string", "x-ui-hidden": true }
-    },
-    additionalProperties: false
-  };
-  GraphAsTask = class GraphAsTask extends Task {
-    static type = "GraphAsTask";
-    static title = "Group";
-    static description = "A group of tasks that are executed together";
-    static category = "Flow Control";
-    static compoundMerge = PROPERTY_ARRAY;
-    static hasDynamicSchemas = true;
-    constructor(input = {}, config = {}) {
-      const { subGraph, ...rest } = config;
-      super(input, rest);
-      if (subGraph) {
-        this.subGraph = subGraph;
-      }
-      this.regenerateGraph();
+var graphAsTaskConfigSchema = {
+  type: "object",
+  properties: {
+    ...TaskConfigSchema["properties"],
+    compoundMerge: { type: "string", "x-ui-hidden": true }
+  },
+  additionalProperties: false
+};
+
+class GraphAsTask extends Task {
+  static type = "GraphAsTask";
+  static title = "Group";
+  static description = "A group of tasks that are executed together";
+  static category = "Flow Control";
+  static compoundMerge = PROPERTY_ARRAY;
+  static hasDynamicSchemas = true;
+  constructor(input = {}, config = {}) {
+    const { subGraph, ...rest } = config;
+    super(input, rest);
+    if (subGraph) {
+      this.subGraph = subGraph;
     }
-    get runner() {
-      if (!this._runner) {
-        this._runner = new GraphAsTaskRunner(this);
-      }
-      return this._runner;
+    this.regenerateGraph();
+  }
+  get runner() {
+    if (!this._runner) {
+      this._runner = new GraphAsTaskRunner(this);
     }
-    static configSchema() {
-      return graphAsTaskConfigSchema;
+    return this._runner;
+  }
+  static configSchema() {
+    return graphAsTaskConfigSchema;
+  }
+  get compoundMerge() {
+    return this.config?.compoundMerge || this.constructor.compoundMerge;
+  }
+  get cacheable() {
+    return this.runConfig?.cacheable ?? this.config?.cacheable ?? (this.constructor.cacheable && !this.hasChildren());
+  }
+  inputSchema() {
+    if (!this.hasChildren()) {
+      return this.constructor.inputSchema();
     }
-    get compoundMerge() {
-      return this.config?.compoundMerge || this.constructor.compoundMerge;
+    return computeGraphInputSchema(this.subGraph);
+  }
+  _inputSchemaNode;
+  getInputSchemaNode() {
+    if (!this._inputSchemaNode) {
+      try {
+        const dataPortSchema = this.inputSchema();
+        const schemaNode = Task.generateInputSchemaNode(dataPortSchema);
+        this._inputSchemaNode = schemaNode;
+      } catch (error) {
+        console.warn(`Failed to compile input schema for ${this.type}, falling back to permissive validation:`, error);
+        this._inputSchemaNode = compileSchema2({});
+      }
     }
-    get cacheable() {
-      return this.runConfig?.cacheable ?? this.config?.cacheable ?? (this.constructor.cacheable && !this.hasChildren());
+    return this._inputSchemaNode;
+  }
+  outputSchema() {
+    if (!this.hasChildren()) {
+      return this.constructor.outputSchema();
     }
-    inputSchema() {
-      if (!this.hasChildren()) {
-        return this.constructor.inputSchema();
-      }
-      return computeGraphInputSchema(this.subGraph);
+    return computeGraphOutputSchema(this.subGraph);
+  }
+  resetInputData() {
+    super.resetInputData();
+    if (this.hasChildren()) {
+      this.subGraph.getTasks().forEach((node) => {
+        node.resetInputData();
+      });
+      this.subGraph.getDataflows().forEach((dataflow) => {
+        dataflow.reset();
+      });
     }
-    _inputSchemaNode;
-    getInputSchemaNode() {
-      if (!this._inputSchemaNode) {
+  }
+  async* executeStream(input, context) {
+    if (context.inputStreams) {
+      for (const [, stream] of context.inputStreams) {
+        const reader = stream.getReader();
         try {
-          const dataPortSchema = this.inputSchema();
-          const schemaNode = Task.generateInputSchemaNode(dataPortSchema);
-          this._inputSchemaNode = schemaNode;
-        } catch (error) {
-          console.warn(`Failed to compile input schema for ${this.type}, falling back to permissive validation:`, error);
-          this._inputSchemaNode = compileSchema2({});
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            if (value.type === "finish")
+              continue;
+            yield value;
+          }
+        } finally {
+          reader.releaseLock();
         }
       }
-      return this._inputSchemaNode;
-    }
-    outputSchema() {
-      if (!this.hasChildren()) {
-        return this.constructor.outputSchema();
-      }
-      return computeGraphOutputSchema(this.subGraph);
-    }
-    resetInputData() {
-      super.resetInputData();
-      if (this.hasChildren()) {
-        this.subGraph.getTasks().forEach((node) => {
-          node.resetInputData();
-        });
-        this.subGraph.getDataflows().forEach((dataflow) => {
-          dataflow.reset();
-        });
-      }
     }
-    async* executeStream(input, context) {
-      if (context.inputStreams) {
-        for (const [, stream] of context.inputStreams) {
-          const reader = stream.getReader();
-          try {
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done)
-                break;
-              if (value.type === "finish")
-                continue;
-              yield value;
-            }
-          } finally {
-            reader.releaseLock();
-          }
+    if (this.hasChildren()) {
+      const endingNodeIds = new Set;
+      const tasks = this.subGraph.getTasks();
+      for (const task of tasks) {
+        if (this.subGraph.getTargetDataflows(task.id).length === 0) {
+          endingNodeIds.add(task.id);
         }
       }
-      if (this.hasChildren()) {
-        const endingNodeIds = new Set;
-        const tasks = this.subGraph.getTasks();
-        for (const task of tasks) {
-          if (this.subGraph.getTargetDataflows(task.id).length === 0) {
-            endingNodeIds.add(task.id);
+      const eventQueue = [];
+      let resolveWaiting;
+      let subgraphDone = false;
+      const unsub = this.subGraph.subscribeToTaskStreaming({
+        onStreamChunk: (taskId, event) => {
+          if (endingNodeIds.has(taskId) && event.type !== "finish") {
+            eventQueue.push(event);
+            resolveWaiting?.();
           }
         }
-        const eventQueue = [];
-        let resolveWaiting;
-        let subgraphDone = false;
-        const unsub = this.subGraph.subscribeToTaskStreaming({
-          onStreamChunk: (taskId, event) => {
-            if (endingNodeIds.has(taskId) && event.type !== "finish") {
-              eventQueue.push(event);
-              resolveWaiting?.();
-            }
-          }
-        });
-        const runPromise = this.subGraph.run(input, { parentSignal: context.signal, accumulateLeafOutputs: false }).then((results2) => {
-          subgraphDone = true;
-          resolveWaiting?.();
-          return results2;
-        });
-        while (!subgraphDone) {
-          if (eventQueue.length === 0) {
-            await new Promise((resolve) => {
-              resolveWaiting = resolve;
-            });
-          }
-          while (eventQueue.length > 0) {
-            yield eventQueue.shift();
-          }
+      });
+      const runPromise = this.subGraph.run(input, { parentSignal: context.signal, accumulateLeafOutputs: false }).then((results2) => {
+        subgraphDone = true;
+        resolveWaiting?.();
+        return results2;
+      });
+      while (!subgraphDone) {
+        if (eventQueue.length === 0) {
+          await new Promise((resolve) => {
+            resolveWaiting = resolve;
+          });
         }
         while (eventQueue.length > 0) {
           yield eventQueue.shift();
         }
-        unsub();
-        const results = await runPromise;
-        const mergedOutput = this.subGraph.mergeExecuteOutputsToRunOutput(results, this.compoundMerge);
-        yield { type: "finish", data: mergedOutput };
-      } else {
-        yield { type: "finish", data: input };
       }
-    }
-    regenerateGraph() {
-      this._inputSchemaNode = undefined;
-      this.events.emit("regenerate");
-    }
-    toJSON(options) {
-      let json = super.toJSON(options);
-      const hasChildren = this.hasChildren();
-      if (hasChildren) {
-        json = {
-          ...json,
-          merge: this.compoundMerge,
-          subgraph: this.subGraph.toJSON(options)
-        };
+      while (eventQueue.length > 0) {
+        yield eventQueue.shift();
       }
-      return json;
+      unsub();
+      const results = await runPromise;
+      const mergedOutput = this.subGraph.mergeExecuteOutputsToRunOutput(results, this.compoundMerge);
+      yield { type: "finish", data: mergedOutput };
+    } else {
+      yield { type: "finish", data: input };
     }
-    toDependencyJSON(options) {
-      const json = this.toJSON(options);
-      if (this.hasChildren()) {
-        if ("subgraph" in json) {
-          delete json.subgraph;
-        }
-        return { ...json, subtasks: this.subGraph.toDependencyJSON(options) };
+  }
+  regenerateGraph() {
+    this._inputSchemaNode = undefined;
+    this.events.emit("regenerate");
+  }
+  toJSON(options) {
+    let json = super.toJSON(options);
+    const hasChildren = this.hasChildren();
+    if (hasChildren) {
+      json = {
+        ...json,
+        merge: this.compoundMerge,
+        subgraph: this.subGraph.toJSON(options)
+      };
+    }
+    return json;
+  }
+  toDependencyJSON(options) {
+    const json = this.toJSON(options);
+    if (this.hasChildren()) {
+      if ("subgraph" in json) {
+        delete json.subgraph;
       }
-      return json;
+      return { ...json, subtasks: this.subGraph.toDependencyJSON(options) };
     }
-  };
-});
+    return json;
+  }
+}
 
 // src/task-graph/Conversions.ts
+var _OwnGraphTask;
+var _OwnWorkflowTask;
+var _GraphTask;
+var _ConvWorkflowTask;
 function getWrapperClasses() {
   if (!_OwnGraphTask) {
-    const GaT = (init_GraphAsTask(), __toCommonJS(exports_GraphAsTask)).GraphAsTask;
 
-    class ListeningGraphAsTask extends GaT {
+    class ListeningGraphAsTask extends GraphAsTask {
       constructor(input, config) {
         super(input, config);
         this.subGraph.on("start", () => {
@@ -3109,11 +3037,11 @@ function getWrapperClasses() {
       static type = "Own[Workflow]";
     }
 
-    class GraphTask extends GaT {
+    class GraphTask extends GraphAsTask {
       static type = "Graph";
     }
 
-    class ConvWorkflowTask extends GaT {
+    class ConvWorkflowTask extends GraphAsTask {
       static type = "Workflow";
     }
     _OwnGraphTask = OwnGraphTask;
@@ -3178,37 +3106,31 @@ function ensureTask(arg, config = {}) {
   }
   return convertPipeFunctionToTask(arg, config);
 }
-var _OwnGraphTask, _OwnWorkflowTask, _GraphTask, _ConvWorkflowTask;
-var init_Conversions = __esm(() => {
-  init_Task();
-  init_Dataflow();
-  init_TaskGraph();
-});
 
 // src/task-graph/TaskGraphEvents.ts
-var EventDagToTaskGraphMapping, EventTaskGraphToDagMapping;
-var init_TaskGraphEvents = __esm(() => {
-  EventDagToTaskGraphMapping = {
-    "node-added": "task_added",
-    "node-removed": "task_removed",
-    "node-replaced": "task_replaced",
-    "edge-added": "dataflow_added",
-    "edge-removed": "dataflow_removed",
-    "edge-replaced": "dataflow_replaced"
-  };
-  EventTaskGraphToDagMapping = {
-    task_added: "node-added",
-    task_removed: "node-removed",
-    task_replaced: "node-replaced",
-    dataflow_added: "edge-added",
-    dataflow_removed: "edge-removed",
-    dataflow_replaced: "edge-replaced"
-  };
-});
+var EventDagToTaskGraphMapping = {
+  "node-added": "task_added",
+  "node-removed": "task_removed",
+  "node-replaced": "task_replaced",
+  "edge-added": "dataflow_added",
+  "edge-removed": "dataflow_removed",
+  "edge-replaced": "dataflow_replaced"
+};
+var EventTaskGraphToDagMapping = {
+  task_added: "node-added",
+  task_removed: "node-removed",
+  task_replaced: "node-replaced",
+  dataflow_added: "edge-added",
+  dataflow_removed: "edge-removed",
+  dataflow_replaced: "edge-replaced"
+};
 
 // src/task-graph/TaskGraph.ts
-import { DirectedAcyclicGraph } from "@workglow/util/graph";
-import { EventEmitter as EventEmitter4, uuid4 as uuid44 } from "@workglow/util";
+class TaskGraphDAG extends DirectedAcyclicGraph {
+  constructor() {
+    super((task) => task.id, (dataflow) => dataflow.id);
+  }
+}
 
 class TaskGraph {
   outputCache;
@@ -3494,38 +3416,7 @@ function serialGraph(tasks, inputHandle, outputHandle) {
   graph.addDataflows(serialGraphEdges(tasks, inputHandle, outputHandle));
   return graph;
 }
-var TaskGraphDAG;
-var init_TaskGraph = __esm(() => {
-  init_Conversions();
-  init_Dataflow();
-  init_GraphSchemaUtils();
-  init_TaskGraphEvents();
-  init_TaskGraphRunner();
-  TaskGraphDAG = class TaskGraphDAG extends DirectedAcyclicGraph {
-    constructor() {
-      super((task) => task.id, (dataflow) => dataflow.id);
-    }
-  };
-});
-
-// src/common.ts
-init_Dataflow();
-init_GraphSchemaUtils();
-init_TaskGraph();
-init_TaskGraphEvents();
-init_TaskGraphRunner();
-init_Conversions();
-
-// src/task-graph/GraphToWorkflowCode.ts
-init_Dataflow();
-
 // src/task-graph/Workflow.ts
-init_GraphAsTask();
-init_TaskError();
-init_Conversions();
-init_Dataflow();
-init_TaskGraph();
-init_TaskGraphRunner();
 import {
   EventEmitter as EventEmitter5,
   getLogger as getLogger3,
@@ -4617,17 +4508,7 @@ ${baseIndent}}`;
 function resetMethodNameCache() {
   methodNameCache = undefined;
 }
-// src/task/index.ts
-init_ConditionalTask();
-
-// src/task/FallbackTask.ts
-init_GraphAsTask();
-
 // src/task/FallbackTaskRunner.ts
-init_GraphAsTaskRunner();
-init_TaskError();
-init_TaskTypes();
-
 class FallbackTaskRunner extends GraphAsTaskRunner {
   async executeTask(input) {
     if (this.task.fallbackMode === "data") {
@@ -4826,21 +4707,8 @@ queueMicrotask(() => {
   };
   Workflow.prototype.endFallbackWith = CreateEndLoopWorkflow("endFallbackWith");
 });
-
-// src/task/index.ts
-init_GraphAsTask();
-init_GraphAsTaskRunner();
-init_InputResolver();
-
-// src/task/IteratorTask.ts
-init_GraphAsTask();
-
 // src/task/IteratorTaskRunner.ts
-init_Dataflow();
-init_TaskGraph();
-init_GraphAsTaskRunner();
 import { uuid4 as uuid46 } from "@workglow/util";
-
 class IteratorTaskRunner extends GraphAsTaskRunner {
   aggregatingParentMapProgress = false;
   mapPartialProgress = [];
@@ -5006,7 +4874,6 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
 }
 
 // src/task/IteratorTask.ts
-init_TaskError();
 var ITERATOR_CONTEXT_SCHEMA = {
   type: "object",
   properties: {
@@ -5498,13 +5365,7 @@ class IteratorTask extends GraphAsTask {
   }
 }
 
-// src/task/WhileTask.ts
-init_GraphAsTask();
-init_TaskError();
-
 // src/task/WhileTaskRunner.ts
-init_GraphAsTaskRunner();
-
 class WhileTaskRunner extends GraphAsTaskRunner {
   async executeTask(input) {
     const result = await this.task.execute(input, {
@@ -6131,9 +5992,7 @@ if (!globalServiceRegistry3.has(JOB_QUEUE_FACTORY)) {
   registerJobQueueFactory(defaultJobQueueFactory);
 }
 // src/task/JobQueueTask.ts
-init_GraphAsTask();
 import { Job as Job2 } from "@workglow/job-queue";
-init_TaskError();
 
 // src/task/TaskQueueRegistry.ts
 var taskQueueRegistry = null;
@@ -6332,7 +6191,6 @@ class JobQueueTask extends GraphAsTask {
   }
 }
 // src/task/MapTask.ts
-init_TaskGraphRunner();
 var mapTaskConfigSchema = {
   type: "object",
   properties: {
@@ -6504,16 +6362,6 @@ queueMicrotask(() => {
   Workflow.prototype.reduce = CreateLoopWorkflow(ReduceTask);
   Workflow.prototype.endReduce = CreateEndLoopWorkflow("endReduce");
 });
-
-// src/task/index.ts
-init_Task();
-init_TaskError();
-
-// src/task/TaskJSON.ts
-init_Dataflow();
-init_TaskGraph();
-init_TaskError();
-
 // src/task/TaskRegistry.ts
 import {
   createServiceToken as createServiceToken3,
@@ -6562,7 +6410,6 @@ function resolveTaskFromRegistry(id, _format, registry) {
 registerInputResolver("tasks", resolveTaskFromRegistry);
 
 // src/task/TaskJSON.ts
-init_GraphAsTask();
 var createSingleTaskFromJSON = (item, registry) => {
   if (!item.id)
     throw new TaskJSONError("Task id required");
@@ -6618,11 +6465,7 @@ var createGraphFromGraphJSON = (graphJsonObj, registry) => {
   }
   return subGraph;
 };
-
 // src/task/index.ts
-init_ConditionalTask();
-init_TaskTypes();
-init_GraphAsTask();
 var registerBaseTasks = () => {
   const tasks = [GraphAsTask, ConditionalTask, FallbackTask, MapTask, WhileTask, ReduceTask];
   tasks.map(TaskRegistry.registerTask);
@@ -6704,12 +6547,7 @@ class TaskGraphTabularRepository extends TaskGraphRepository {
     return await this.tabularRepository.size();
   }
 }
-
-// src/common.ts
-init_TaskOutputRepository();
-
 // src/storage/TaskOutputTabularRepository.ts
-init_TaskOutputRepository();
 import { compress, decompress } from "@workglow/util/compress";
 import { makeFingerprint } from "@workglow/util";
 var TaskOutputSchema = {
@@ -6917,4 +6755,4 @@ export {
   ConditionalTask
 };
 
-//# debugId=F7E8A2EB122F7E0864756E2164756E21
+//# debugId=CAF9D48DE789CA7864756E2164756E21