@workglow/task-graph 0.0.125 → 0.1.0

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;
@@ -157,6 +119,7 @@ class Dataflow {
     this.error = undefined;
     this.value = undefined;
     this.stream = undefined;
+    this._compatibilityCache = undefined;
     this.emit("reset");
     this.emit("status", this.status);
   }
@@ -217,9 +180,19 @@ class Dataflow {
       targetTaskPortId: this.targetTaskPortId
     };
   }
+  _compatibilityCache;
+  invalidateCompatibilityCache() {
+    this._compatibilityCache = undefined;
+  }
   semanticallyCompatible(graph, dataflow) {
-    const targetSchema = graph.getTask(dataflow.targetTaskId).inputSchema();
-    const sourceSchema = graph.getTask(dataflow.sourceTaskId).outputSchema();
+    const sourceTask = graph.getTask(dataflow.sourceTaskId);
+    const targetTask = graph.getTask(dataflow.targetTaskId);
+    const shouldCache = !(sourceTask.constructor.hasDynamicSchemas ?? true) && !(targetTask.constructor.hasDynamicSchemas ?? true);
+    if (shouldCache && this._compatibilityCache !== undefined) {
+      return this._compatibilityCache;
+    }
+    const targetSchema = targetTask.inputSchema();
+    const sourceSchema = sourceTask.outputSchema();
     if (typeof targetSchema === "boolean") {
       if (targetSchema === false) {
         return "incompatible";
@@ -240,8 +213,11 @@ class Dataflow {
     if (sourceSchemaProperty === undefined && sourceSchema.additionalProperties === true) {
       sourceSchemaProperty = true;
     }
-    const semanticallyCompatible = areSemanticallyCompatible(sourceSchemaProperty, targetSchemaProperty);
-    return semanticallyCompatible;
+    const result = areSemanticallyCompatible(sourceSchemaProperty, targetSchemaProperty);
+    if (shouldCache) {
+      this._compatibilityCache = result;
+    }
+    return result;
   }
   get events() {
     if (!this._events) {
@@ -269,22 +245,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 +605,28 @@ 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 { getLogger as getLogger4 } from "@workglow/util";
+import { compileSchema as compileSchema2 } from "@workglow/util/schema";
+
+// src/task-graph/TaskGraphRunner.ts
+import {
+  collectPropertyValues,
+  getLogger as getLogger3,
+  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 +653,173 @@ 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 as getLogger2 } 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";
+  taskType;
+  taskId;
+  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 TaskGraphTimeoutError extends TaskTimeoutError {
+  static type = "TaskGraphTimeoutError";
+  constructor(timeoutMs) {
+    super(timeoutMs);
+    this.message = timeoutMs ? `Graph execution timed out after ${timeoutMs}ms` : "Graph execution 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);
+  }
+}
+
+class TaskSerializationError extends TaskError {
+  static type = "TaskSerializationError";
+  constructor(taskType) {
+    super(`Task "${taskType}" cannot be serialized: config contains non-serializable values. ` + `Use a declarative config alternative or remove function-valued config properties.`);
+  }
+}
+
+// src/task/TaskRunner.ts
+import {
+  getLogger,
+  getTelemetryProvider,
+  globalServiceRegistry,
+  SpanStatusCode
+} from "@workglow/util";
 
 // src/task/InputResolver.ts
 import { getInputResolvers } from "@workglow/util";
@@ -776,6 +865,18 @@ function getFormatPrefix(format) {
   const colonIndex = format.indexOf(":");
   return colonIndex >= 0 ? format.substring(0, colonIndex) : format;
 }
+function schemaHasFormatAnnotations(schema) {
+  if (typeof schema === "boolean")
+    return false;
+  const properties = schema.properties;
+  if (!properties || typeof properties !== "object")
+    return false;
+  for (const propSchema of Object.values(properties)) {
+    if (getSchemaFormat(propSchema) !== undefined)
+      return true;
+  }
+  return false;
+}
 async function resolveSchemaInputs(input, schema, config) {
   if (typeof schema === "boolean")
     return input;
@@ -813,7 +914,6 @@ async function resolveSchemaInputs(input, schema, config) {
   }
   return resolved;
 }
-var init_InputResolver = () => {};
 
 // src/task/StreamTypes.ts
 function getPortStreamMode(schema, portId) {
@@ -917,11 +1017,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;
 }
@@ -947,6 +1042,12 @@ class TaskRunner {
     await this.handleStart(config);
     try {
       this.task.setInput(overrides);
+      const configSchema = this.task.constructor.configSchema();
+      if (schemaHasFormatAnnotations(configSchema)) {
+        const source = this.task.originalConfig ?? this.task.config;
+        const resolved = await resolveSchemaInputs({ ...source }, configSchema, { registry: this.registry });
+        Object.assign(this.task.config, resolved);
+      }
       const schema = this.task.constructor.inputSchema();
       this.task.runInputData = await resolveSchemaInputs(this.task.runInputData, schema, { registry: this.registry });
       const inputs = this.task.runInputData;
@@ -960,6 +1061,12 @@ class TaskRunner {
       }
       let outputs;
       const isStreamable = isTaskStreamable(this.task);
+      if (!isStreamable && typeof this.task.executeStream !== "function") {
+        const streamMode = getOutputStreamMode(this.task.outputSchema());
+        if (streamMode !== "none") {
+          getLogger().warn(`Task "${this.task.type}" declares streaming output (x-stream: "${streamMode}") ` + `but does not implement executeStream(). Falling back to non-streaming execute().`);
+        }
+      }
       if (this.task.cacheable) {
         outputs = await this.outputCache?.getOutput(this.task.type, inputs);
         if (outputs) {
@@ -998,6 +1105,12 @@ class TaskRunner {
       return this.task.runOutputData;
     }
     this.task.setInput(overrides);
+    const configSchema = this.task.constructor.configSchema();
+    if (schemaHasFormatAnnotations(configSchema)) {
+      const source = this.task.originalConfig ?? this.task.config;
+      const resolved = await resolveSchemaInputs({ ...source }, configSchema, { registry: this.registry });
+      Object.assign(this.task.config, resolved);
+    }
     const schema = this.task.constructor.inputSchema();
     this.task.runInputData = await resolveSchemaInputs(this.task.runInputData, schema, { registry: this.registry });
     await this.handleStartReactive();
@@ -1226,6 +1339,11 @@ class TaskRunner {
       this.telemetrySpan.end();
       this.telemetrySpan = undefined;
     }
+    if (typeof this.task.cleanup === "function") {
+      try {
+        await this.task.cleanup();
+      } catch {}
+    }
     this.task.emit("abort", this.task.error);
     this.task.emit("status", this.task.status);
   }
@@ -1278,7 +1396,15 @@ class TaskRunner {
     this.task.completedAt = new Date;
     this.task.progress = 100;
     this.task.status = TaskStatus.FAILED;
-    this.task.error = err instanceof TaskError ? err : new TaskFailedError(err?.message || "Task failed");
+    if (err instanceof TaskError) {
+      this.task.error = err;
+    } else {
+      this.task.error = new TaskFailedError(`Task "${this.task.type}" (${this.task.id}): ${err?.message || "Task failed"}`);
+    }
+    if (this.task.error instanceof TaskError) {
+      this.task.error.taskType ??= this.task.type;
+      this.task.error.taskId ??= this.task.id;
+    }
     this.abortController = undefined;
     if (this.telemetrySpan) {
       this.telemetrySpan.setStatus(SpanStatusCode.ERROR, this.task.error.message);
@@ -1298,18 +1424,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";
@@ -1392,6 +1508,7 @@ class Task {
   runInputData = {};
   runOutputData = {};
   config;
+  originalConfig;
   get id() {
     return this.config.id;
   }
@@ -1422,6 +1539,11 @@ class Task {
       baseConfig.id = uuid42();
     }
     this.config = this.validateAndApplyConfigDefaults(baseConfig);
+    try {
+      this.originalConfig = Object.freeze(structuredClone(this.config));
+    } catch {
+      this.originalConfig = undefined;
+    }
     this.runConfig = runConfig;
   }
   getDefaultInputsFromStaticInputDefinitions() {
@@ -1692,7 +1814,10 @@ class Task {
         const path = e.data.pointer || "";
         return `${e.message}${path ? ` (${path})` : ""}`;
       });
-      throw new TaskInvalidInputError(`Input ${JSON.stringify(Object.keys(input))} does not match schema: ${errorMessages.join(", ")}`);
+      const err = new TaskInvalidInputError(`Task "${this.type}" (${this.id}): Input ${JSON.stringify(Object.keys(input))} does not match schema: ${errorMessages.join(", ")}`);
+      err.taskType = this.type;
+      err.taskId = this.id;
+      throw err;
     }
     return true;
   }
@@ -1717,8 +1842,14 @@ class Task {
     }
     return obj;
   }
+  canSerializeConfig() {
+    return true;
+  }
   toJSON(_options) {
     const ctor = this.constructor;
+    if (!this.canSerializeConfig() || !this.originalConfig) {
+      throw new TaskSerializationError(this.type);
+    }
     const schema = ctor.configSchema();
     const schemaProperties = typeof schema !== "boolean" && schema?.properties ? schema.properties : {};
     const config = {};
@@ -1728,7 +1859,7 @@ class Task {
       if (propSchema?.["x-ui-hidden"] === true && key !== "inputSchema" && key !== "outputSchema" && key !== "extras") {
         continue;
       }
-      const value = this.config[key];
+      const value = this.originalConfig[key];
       if (value === undefined)
         continue;
       if (typeof value === "function" || typeof value === "symbol")
@@ -1789,146 +1920,57 @@ 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;
+  }
+  canSerializeConfig() {
+    if (!this.config.branches)
+      return true;
+    return !this.config.branches.some((b) => typeof b.condition === "function");
+  }
+  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 +1978,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) {
+        getLogger2().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 +2277,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;
@@ -2253,6 +2300,8 @@ class TaskGraphRunner {
   inProgressFunctions = new Map;
   failedTaskErrors = new Map;
   telemetrySpan;
+  graphTimeoutTimer;
+  pendingGraphTimeoutError;
   constructor(graph, outputCache, processScheduler = new DependencyBasedScheduler(graph), reactiveScheduler = new TopologicalScheduler(graph)) {
     this.processScheduler = processScheduler;
     this.reactiveScheduler = reactiveScheduler;
@@ -2303,10 +2352,14 @@ class TaskGraphRunner {
       }
     } catch (err) {
       error = err;
-      getLogger2().error("Error running graph", { error });
+      getLogger3().error("Error running graph", { error });
     }
     await Promise.allSettled(Array.from(this.inProgressTasks.values()));
     await Promise.allSettled(Array.from(this.inProgressFunctions.values()));
+    if (this.pendingGraphTimeoutError) {
+      await this.handleAbort();
+      throw this.pendingGraphTimeoutError;
+    }
     if (this.failedTaskErrors.size > 0) {
       const latestError = this.failedTaskErrors.values().next().value;
       this.handleError(latestError);
@@ -2394,6 +2447,7 @@ class TaskGraphRunner {
   }
   copyInputFromEdgesToNode(task) {
     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());
     }
@@ -2402,7 +2456,7 @@ class TaskGraphRunner {
     const dataflows = this.graph.getTargetDataflows(node.id);
     for (const dataflow of dataflows) {
       const compatibility = dataflow.semanticallyCompatible(this.graph, dataflow);
-      getLogger2().debug("pushOutputFromNodeToEdges", {
+      getLogger3().debug("pushOutputFromNodeToEdges", {
         dataflowId: dataflow.id,
         compatibility,
         resultsKeys: Object.keys(results)
@@ -2416,7 +2470,7 @@ class TaskGraphRunner {
       } else {
         const resultsKeys = Object.keys(results);
         if (resultsKeys.length > 0) {
-          getLogger2().warn("pushOutputFromNodeToEdge not compatible, not setting port data", {
+          getLogger3().warn("pushOutputFromNodeToEdge not compatible, not setting port data", {
             dataflowId: dataflow.id,
             compatibility,
             resultsKeys
@@ -2722,6 +2776,12 @@ class TaskGraphRunner {
       }
       this.graph.outputCache = this.outputCache;
     }
+    if (config?.maxTasks !== undefined && config.maxTasks > 0) {
+      const taskCount = this.graph.getTasks().length;
+      if (taskCount > config.maxTasks) {
+        throw new TaskConfigurationError(`Graph has ${taskCount} tasks, exceeding the limit of ${config.maxTasks}`);
+      }
+    }
     if (this.running || this.reactiveRunning) {
       throw new TaskConfigurationError("Graph is already running");
     }
@@ -2730,6 +2790,13 @@ class TaskGraphRunner {
     this.abortController.signal.addEventListener("abort", () => {
       this.handleAbort();
     });
+    if (config?.timeout !== undefined && config.timeout > 0) {
+      this.pendingGraphTimeoutError = undefined;
+      this.graphTimeoutTimer = setTimeout(() => {
+        this.pendingGraphTimeoutError = new TaskGraphTimeoutError(config.timeout);
+        this.abortController?.abort();
+      }, config.timeout);
+    }
     if (config?.parentSignal?.aborted) {
       this.abortController.abort();
       return;
@@ -2763,10 +2830,23 @@ class TaskGraphRunner {
     if (config?.registry !== undefined) {
       this.registry = config.registry;
     }
+    if (config?.maxTasks !== undefined && config.maxTasks > 0) {
+      const taskCount = this.graph.getTasks().length;
+      if (taskCount > config.maxTasks) {
+        throw new TaskConfigurationError(`Graph has ${taskCount} tasks, exceeding the limit of ${config.maxTasks}`);
+      }
+    }
     this.reactiveScheduler.reset();
     this.reactiveRunning = true;
   }
+  clearGraphTimeout() {
+    if (this.graphTimeoutTimer !== undefined) {
+      clearTimeout(this.graphTimeoutTimer);
+      this.graphTimeoutTimer = undefined;
+    }
+  }
   async handleComplete() {
+    this.clearGraphTimeout();
     this.running = false;
     if (this.telemetrySpan) {
       this.telemetrySpan.setStatus(SpanStatusCode2.OK);
@@ -2779,6 +2859,7 @@ class TaskGraphRunner {
     this.reactiveRunning = false;
   }
   async handleError(error) {
+    this.clearGraphTimeout();
     await Promise.allSettled(this.graph.getTasks().map(async (task) => {
       if (task.status === TaskStatus.PROCESSING || task.status === TaskStatus.STREAMING) {
         return task.abort();
@@ -2797,6 +2878,7 @@ class TaskGraphRunner {
     this.reactiveRunning = false;
   }
   async handleAbort() {
+    this.clearGraphTimeout();
     await Promise.allSettled(this.graph.getTasks().map(async (task) => {
       if (task.status === TaskStatus.PROCESSING || task.status === TaskStatus.STREAMING) {
         return task.abort();
@@ -2839,254 +2921,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) {
+        getLogger4().warn(`GraphAsTask "${this.type}" (${this.id}): Failed to compile input schema, ` + `falling back to permissive validation. Inputs will NOT be validated.`, { error, taskType: this.type, taskId: this.id });
+        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 +3168,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 +3237,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;
@@ -3229,7 +3282,9 @@ class TaskGraph {
       outputCache: config?.outputCache || this.outputCache,
       parentSignal: config?.parentSignal || undefined,
       accumulateLeafOutputs: config?.accumulateLeafOutputs,
-      registry: config?.registry
+      registry: config?.registry,
+      timeout: config?.timeout,
+      maxTasks: config?.maxTasks
     });
   }
   runReactive(input = {}, config = {}) {
@@ -3269,18 +3324,12 @@ class TaskGraph {
     return this._dag.addEdges(addedEdges);
   }
   getDataflow(id) {
-    for (const i in this._dag.adjacency) {
-      for (const j in this._dag.adjacency[i]) {
-        const maybeEdges = this._dag.adjacency[i][j];
-        if (maybeEdges !== null) {
-          for (const edge of maybeEdges) {
-            if (this._dag.edgeIdentity(edge, "", "") == id) {
-              return edge;
-            }
-          }
-        }
+    for (const [, , edge] of this._dag.getEdges()) {
+      if (edge.id === id) {
+        return edge;
       }
     }
+    return;
   }
   getDataflows() {
     return this._dag.getEdges().map((edge) => edge[2]);
@@ -3468,9 +3517,9 @@ class TaskGraph {
   emit(name, ...args) {
     const dagEvent = EventTaskGraphToDagMapping[name];
     if (dagEvent) {
-      return this.emit_dag(name, ...args);
+      return this.emit_dag.call(this, name, ...args);
     } else {
-      return this.emit_local(name, ...args);
+      return this.emit_local.call(this, name, ...args);
     }
   }
   emit_local(name, ...args) {
@@ -3494,41 +3543,10 @@ 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,
+  getLogger as getLogger5,
   uuid4 as uuid45
 } from "@workglow/util";
 function getLastTask(workflow) {
@@ -3676,7 +3694,7 @@ class Workflow {
           const taskSchema = task.inputSchema();
           if (typeof taskSchema !== "boolean" && taskSchema.properties?.[dataflow.targetTaskPortId] === undefined && taskSchema.additionalProperties !== true || taskSchema === true && dataflow.targetTaskPortId !== DATAFLOW_ALL_PORTS) {
             this._error = `Input ${dataflow.targetTaskPortId} not found on task ${task.id}`;
-            getLogger3().error(this._error);
+            getLogger5().error(this._error);
             return;
           }
           dataflow.targetTaskId = task.id;
@@ -3701,10 +3719,10 @@ class Workflow {
         if (result.error) {
           if (this.isLoopBuilder) {
             this._error = result.error;
-            getLogger3().warn(this._error);
+            getLogger5().warn(this._error);
           } else {
             this._error = result.error + " Task not added.";
-            getLogger3().error(this._error);
+            getLogger5().error(this._error);
             this.graph.removeTask(task.id);
           }
         }
@@ -3792,7 +3810,7 @@ class Workflow {
     const nodes = this._graph.getTasks();
     if (nodes.length === 0) {
       this._error = "No tasks to remove";
-      getLogger3().error(this._error);
+      getLogger5().error(this._error);
       return this;
     }
     const lastNode = nodes[nodes.length - 1];
@@ -3823,7 +3841,7 @@ class Workflow {
     if (-index > nodes.length) {
       const errorMsg = `Back index greater than number of tasks`;
       this._error = errorMsg;
-      getLogger3().error(this._error);
+      getLogger5().error(this._error);
       throw new WorkflowError(errorMsg);
     }
     const lastNode = nodes[nodes.length + index];
@@ -3832,13 +3850,13 @@ class Workflow {
       if (outputSchema === false && source !== DATAFLOW_ALL_PORTS) {
         const errorMsg = `Task ${lastNode.id} has schema 'false' and outputs nothing`;
         this._error = errorMsg;
-        getLogger3().error(this._error);
+        getLogger5().error(this._error);
         throw new WorkflowError(errorMsg);
       }
     } else if (!outputSchema.properties?.[source] && source !== DATAFLOW_ALL_PORTS) {
       const errorMsg = `Output ${source} not found on task ${lastNode.id}`;
       this._error = errorMsg;
-      getLogger3().error(this._error);
+      getLogger5().error(this._error);
       throw new WorkflowError(errorMsg);
     }
     this._dataFlows.push(new Dataflow(lastNode.id, source, undefined, target));
@@ -3849,7 +3867,7 @@ class Workflow {
     const parent = getLastTask(this);
     if (!parent) {
       this._error = "onError() requires a preceding task in the workflow";
-      getLogger3().error(this._error);
+      getLogger5().error(this._error);
       throw new WorkflowError(this._error);
     }
     const handlerTask = ensureTask(handler);
@@ -3947,7 +3965,7 @@ class Workflow {
         const taskSchema = task.inputSchema();
         if (typeof taskSchema !== "boolean" && taskSchema.properties?.[dataflow.targetTaskPortId] === undefined && taskSchema.additionalProperties !== true || taskSchema === true && dataflow.targetTaskPortId !== DATAFLOW_ALL_PORTS) {
           this._error = `Input ${dataflow.targetTaskPortId} not found on task ${task.id}`;
-          getLogger3().error(this._error);
+          getLogger5().error(this._error);
           return;
         }
         dataflow.targetTaskId = task.id;
@@ -3977,7 +3995,7 @@ class Workflow {
       });
       if (result.error) {
         this._error = result.error + " Task not added.";
-        getLogger3().error(this._error);
+        getLogger5().error(this._error);
         this.graph.removeTask(iteratorTask.id);
       }
     }
@@ -4617,17 +4635,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,27 +4834,18 @@ 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 = [];
   mapPartialIterationCount = 0;
   async executeTask(input) {
-    const analysis = this.task.analyzeIterationInput(input);
+    let analysis = this.task.analyzeIterationInput(input);
+    const maxIterations = this.task.config.maxIterations;
+    if (maxIterations !== undefined && maxIterations > 0 && analysis.iterationCount > maxIterations) {
+      analysis = { ...analysis, iterationCount: maxIterations };
+    }
     if (analysis.iterationCount === 0) {
       const emptyResult = this.task.getEmptyResult();
       return this.executeTaskReactive(input, emptyResult);
@@ -5006,7 +5005,6 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
 }
 
 // src/task/IteratorTask.ts
-init_TaskError();
 var ITERATOR_CONTEXT_SCHEMA = {
   type: "object",
   properties: {
@@ -5032,6 +5030,7 @@ var iteratorTaskConfigSchema = {
     ...graphAsTaskConfigSchema["properties"],
     concurrencyLimit: { type: "integer", minimum: 1 },
     batchSize: { type: "integer", minimum: 1 },
+    maxIterations: { type: "integer", minimum: 1 },
     iterationInputConfig: { type: "object", additionalProperties: true }
   },
   additionalProperties: false
@@ -5100,22 +5099,29 @@ function extractBaseSchema(schema) {
   }
   const variants = schema.oneOf ?? schema.anyOf;
   if (Array.isArray(variants)) {
+    let hasScalar = false;
+    let hasArray = false;
+    let scalarVariant;
+    let arrayVariant;
     for (const variant of variants) {
       if (typeof variant === "object") {
-        const variantType = variant.type;
-        if (variantType !== "array") {
-          return variant;
+        const v = variant;
+        if (v.type === "array" || "items" in v) {
+          hasArray = true;
+          arrayVariant = variant;
+        } else {
+          hasScalar = true;
+          scalarVariant = variant;
         }
       }
     }
-    for (const variant of variants) {
-      if (typeof variant === "object") {
-        const variantType = variant.type;
-        if (variantType === "array" && variant.items) {
-          return variant.items;
-        }
-      }
+    if (hasScalar && hasArray && variants.length === 2) {
+      return scalarVariant;
+    }
+    if (!hasScalar && hasArray && arrayVariant) {
+      return arrayVariant.items;
     }
+    return schema;
   }
   return schema;
 }
@@ -5498,13 +5504,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, {
@@ -5562,6 +5562,9 @@ class WhileTask extends GraphAsTask {
     return WHILE_CONTEXT_SCHEMA;
   }
   _currentIteration = 0;
+  canSerializeConfig() {
+    return typeof this.config.condition !== "function";
+  }
   constructor(input = {}, config = {}) {
     super(input, config);
   }
@@ -5683,7 +5686,27 @@ class WhileTask extends GraphAsTask {
         parentSignal: context.signal
       });
       currentOutput = this.subGraph.mergeExecuteOutputsToRunOutput(results, this.compoundMerge);
-      if (!condition(currentOutput, this._currentIteration)) {
+      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;
+          }
+        }
+        throw wrappedError;
+      }
+      if (!shouldContinue) {
         break;
       }
       if (this.chainIterations) {
@@ -5727,7 +5750,13 @@ class WhileTask extends GraphAsTask {
         parentSignal: context.signal
       });
       currentOutput = this.subGraph.mergeExecuteOutputsToRunOutput(results, this.compoundMerge);
-      if (!condition(currentOutput, this._currentIteration)) {
+      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) {
@@ -6130,209 +6159,7 @@ function getJobQueueFactory() {
 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;
-
-class TaskQueueRegistry {
-  queues = new Map;
-  registerQueue(queue) {
-    const queueName = queue.server.queueName;
-    if (this.queues.has(queueName)) {
-      throw new Error(`Queue with name ${queueName} already exists`);
-    }
-    this.queues.set(queueName, queue);
-  }
-  getQueue(queueName) {
-    return this.queues.get(queueName);
-  }
-  async startQueues() {
-    for (const queue of this.queues.values()) {
-      await queue.server.start();
-    }
-  }
-  async stopQueues() {
-    for (const queue of this.queues.values()) {
-      await queue.server.stop();
-    }
-  }
-  async clearQueues() {
-    for (const queue of this.queues.values()) {
-      await queue.storage.deleteAll();
-    }
-  }
-}
-function getTaskQueueRegistry() {
-  if (!taskQueueRegistry) {
-    taskQueueRegistry = new TaskQueueRegistry;
-  }
-  return taskQueueRegistry;
-}
-async function setTaskQueueRegistry(registry) {
-  if (taskQueueRegistry) {
-    await taskQueueRegistry.stopQueues();
-    await taskQueueRegistry.clearQueues();
-  }
-  taskQueueRegistry = registry;
-}
-
-// src/task/JobQueueTask.ts
-var jobQueueTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...graphAsTaskConfigSchema["properties"],
-    queue: {
-      oneOf: [{ type: "boolean" }, { type: "string" }],
-      description: "Queue handling: false=run inline, true=use default, string=explicit queue name",
-      "x-ui-hidden": true
-    }
-  },
-  additionalProperties: false
-};
-
-class JobQueueTask extends GraphAsTask {
-  static type = "JobQueueTask";
-  static canRunDirectly = true;
-  static configSchema() {
-    return jobQueueTaskConfigSchema;
-  }
-  currentQueueName;
-  currentJobId;
-  currentRunnerId;
-  jobClass;
-  constructor(input = {}, config = {}) {
-    config.queue ??= true;
-    super(input, config);
-    this.jobClass = Job2;
-  }
-  async execute(input, executeContext) {
-    let cleanup = () => {};
-    try {
-      if (this.config.queue === false && !this.constructor.canRunDirectly) {
-        throw new TaskConfigurationError(`${this.type} cannot run directly without a queue`);
-      }
-      const registeredQueue = await this.resolveQueue(input);
-      if (!registeredQueue) {
-        if (!this.constructor.canRunDirectly) {
-          const queueLabel = typeof this.config.queue === "string" ? this.config.queue : this.currentQueueName ?? this.type;
-          throw new TaskConfigurationError(`Queue ${queueLabel} not found, and ${this.type} cannot run directly`);
-        }
-        this.currentJobId = undefined;
-        const job = await this.createJob(input, this.currentQueueName);
-        cleanup = job.onJobProgress((progress, message, details) => {
-          executeContext.updateProgress(progress, message, details);
-        });
-        const output2 = await job.execute(job.input, {
-          signal: executeContext.signal,
-          updateProgress: executeContext.updateProgress.bind(this)
-        });
-        return output2;
-      }
-      const { client } = registeredQueue;
-      const jobInput = await this.getJobInput(input);
-      const handle = await client.submit(jobInput, {
-        jobRunId: this.currentRunnerId,
-        maxRetries: 10
-      });
-      this.currentJobId = handle.id;
-      this.currentQueueName = client.queueName;
-      cleanup = handle.onProgress((progress, message, details) => {
-        executeContext.updateProgress(progress, message, details);
-      });
-      const output = await handle.waitFor();
-      if (output === undefined) {
-        throw new TaskConfigurationError("Job disabled, should not happen");
-      }
-      return output;
-    } catch (err) {
-      throw new JobTaskFailedError(err);
-    } finally {
-      cleanup();
-    }
-  }
-  async getJobInput(input) {
-    return input;
-  }
-  async createJob(input, queueName) {
-    return new this.jobClass({
-      queueName: queueName ?? this.currentQueueName,
-      jobRunId: this.currentRunnerId,
-      input
-    });
-  }
-  async resolveQueue(input) {
-    const preference = this.config.queue ?? true;
-    if (preference === false) {
-      this.currentQueueName = undefined;
-      return;
-    }
-    if (typeof preference === "string") {
-      const registeredQueue2 = getTaskQueueRegistry().getQueue(preference);
-      if (registeredQueue2) {
-        this.currentQueueName = registeredQueue2.server.queueName;
-        return registeredQueue2;
-      }
-      this.currentQueueName = preference;
-      return;
-    }
-    const queueName = await this.getDefaultQueueName(input);
-    if (!queueName) {
-      this.currentQueueName = undefined;
-      return;
-    }
-    this.currentQueueName = queueName;
-    let registeredQueue = getTaskQueueRegistry().getQueue(queueName);
-    if (!registeredQueue) {
-      registeredQueue = await this.createAndRegisterQueue(queueName, input);
-      await registeredQueue.server.start();
-    }
-    return registeredQueue;
-  }
-  async getDefaultQueueName(_input) {
-    return this.type;
-  }
-  async createAndRegisterQueue(queueName, input) {
-    const factory = getJobQueueFactory();
-    let registeredQueue = await factory({
-      queueName,
-      jobClass: this.jobClass,
-      input,
-      config: this.config,
-      task: this
-    });
-    const registry = getTaskQueueRegistry();
-    try {
-      registry.registerQueue(registeredQueue);
-    } catch (err) {
-      if (err instanceof Error && err.message.includes("already exists")) {
-        const existing = registry.getQueue(queueName);
-        if (existing) {
-          registeredQueue = existing;
-        }
-      } else {
-        throw err;
-      }
-    }
-    return registeredQueue;
-  }
-  abort() {
-    if (this.currentQueueName && this.currentJobId) {
-      const registeredQueue = getTaskQueueRegistry().getQueue(this.currentQueueName);
-      if (registeredQueue) {
-        registeredQueue.client.abort(this.currentJobId).catch((err) => {
-          console.warn(`Failed to abort remote job ${this.currentJobId}`, err);
-        });
-      }
-    }
-    super.abort();
-  }
-}
 // src/task/MapTask.ts
-init_TaskGraphRunner();
 var mapTaskConfigSchema = {
   type: "object",
   properties: {
@@ -6504,16 +6331,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,14 +6379,19 @@ function resolveTaskFromRegistry(id, _format, registry) {
 registerInputResolver("tasks", resolveTaskFromRegistry);
 
 // src/task/TaskJSON.ts
-init_GraphAsTask();
-var createSingleTaskFromJSON = (item, registry) => {
+var createSingleTaskFromJSON = (item, registry, options) => {
   if (!item.id)
     throw new TaskJSONError("Task id required");
   if (!item.type)
     throw new TaskJSONError("Task type required");
   if (item.defaults && Array.isArray(item.defaults))
     throw new TaskJSONError("Task defaults must be an object");
+  if (options?.allowedTypes) {
+    const allowed = options.allowedTypes instanceof Set ? options.allowedTypes : new Set(options.allowedTypes);
+    if (!allowed.has(item.type)) {
+      throw new TaskJSONError(`Task type "${item.type}" is not in the allowed types list`);
+    }
+  }
   const constructors = getTaskConstructors(registry);
   const taskClass = constructors.get(item.type);
   if (!taskClass)
@@ -6581,62 +6403,105 @@ var createSingleTaskFromJSON = (item, registry) => {
   const task = new taskClass(item.defaults ?? {}, taskConfig, registry ? { registry } : {});
   return task;
 };
-var createTaskFromDependencyJSON = (item, registry) => {
-  const task = createSingleTaskFromJSON(item, registry);
+var createTaskFromDependencyJSON = (item, registry, options) => {
+  const task = createSingleTaskFromJSON(item, registry, options);
   if (item.subtasks && item.subtasks.length > 0) {
     if (!(task instanceof GraphAsTask)) {
       throw new TaskConfigurationError("Subgraph is only supported for CompoundTasks");
     }
-    task.subGraph = createGraphFromDependencyJSON(item.subtasks, registry);
+    task.subGraph = createGraphFromDependencyJSON(item.subtasks, registry, options);
   }
   return task;
 };
-var createGraphFromDependencyJSON = (jsonItems, registry) => {
+var createGraphFromDependencyJSON = (jsonItems, registry, options) => {
   const subGraph = new TaskGraph;
   for (const subitem of jsonItems) {
-    subGraph.addTask(createTaskFromDependencyJSON(subitem, registry));
+    subGraph.addTask(createTaskFromDependencyJSON(subitem, registry, options));
   }
   return subGraph;
 };
-var createTaskFromGraphJSON = (item, registry) => {
-  const task = createSingleTaskFromJSON(item, registry);
+var createTaskFromGraphJSON = (item, registry, options) => {
+  const task = createSingleTaskFromJSON(item, registry, options);
   if (item.subgraph) {
     if (!(task instanceof GraphAsTask)) {
       throw new TaskConfigurationError("Subgraph is only supported for GraphAsTask");
     }
-    task.subGraph = createGraphFromGraphJSON(item.subgraph, registry);
+    task.subGraph = createGraphFromGraphJSON(item.subgraph, registry, options);
   }
   return task;
 };
-var createGraphFromGraphJSON = (graphJsonObj, registry) => {
+var createGraphFromGraphJSON = (graphJsonObj, registry, options) => {
   const subGraph = new TaskGraph;
   for (const subitem of graphJsonObj.tasks) {
-    subGraph.addTask(createTaskFromGraphJSON(subitem, registry));
+    subGraph.addTask(createTaskFromGraphJSON(subitem, registry, options));
   }
   for (const subitem of graphJsonObj.dataflows) {
     subGraph.addDataflow(new Dataflow(subitem.sourceTaskId, subitem.sourceTaskPortId, subitem.targetTaskId, subitem.targetTaskPortId));
   }
   return subGraph;
 };
+// src/task/TaskQueueRegistry.ts
+import { EventEmitter as EventEmitter6 } from "@workglow/util";
+var taskQueueRegistry = null;
 
+class TaskQueueRegistry {
+  emitter = new EventEmitter6;
+  queues = new Map;
+  registerQueue(queue) {
+    const queueName = queue.server.queueName;
+    if (this.queues.has(queueName)) {
+      throw new Error(`Queue with name ${queueName} already exists`);
+    }
+    this.queues.set(queueName, queue);
+    this.emitter.emit("queue_registered", queueName);
+  }
+  getQueue(queueName) {
+    return this.queues.get(queueName);
+  }
+  async startQueues() {
+    for (const queue of this.queues.values()) {
+      await queue.server.start();
+    }
+  }
+  async stopQueues() {
+    for (const queue of this.queues.values()) {
+      await queue.server.stop();
+    }
+  }
+  async clearQueues() {
+    for (const queue of this.queues.values()) {
+      await queue.storage.deleteAll();
+    }
+  }
+}
+function getTaskQueueRegistry() {
+  if (!taskQueueRegistry) {
+    taskQueueRegistry = new TaskQueueRegistry;
+  }
+  return taskQueueRegistry;
+}
+async function setTaskQueueRegistry(registry) {
+  if (taskQueueRegistry) {
+    await taskQueueRegistry.stopQueues();
+    await taskQueueRegistry.clearQueues();
+  }
+  taskQueueRegistry = registry;
+}
 // src/task/index.ts
-init_ConditionalTask();
-init_TaskTypes();
-init_GraphAsTask();
 var registerBaseTasks = () => {
   const tasks = [GraphAsTask, ConditionalTask, FallbackTask, MapTask, WhileTask, ReduceTask];
   tasks.map(TaskRegistry.registerTask);
   return tasks;
 };
 // src/storage/TaskGraphRepository.ts
-import { createServiceToken as createServiceToken4, EventEmitter as EventEmitter6 } from "@workglow/util";
+import { createServiceToken as createServiceToken4, EventEmitter as EventEmitter7 } from "@workglow/util";
 var TASK_GRAPH_REPOSITORY = createServiceToken4("taskgraph.taskGraphRepository");
 
 class TaskGraphRepository {
   type = "TaskGraphRepository";
   get events() {
     if (!this._events) {
-      this._events = new EventEmitter6;
+      this._events = new EventEmitter7;
     }
     return this._events;
   }
@@ -6704,12 +6569,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 = {
@@ -6799,6 +6659,7 @@ export {
   setTaskQueueRegistry,
   setGlobalTaskConstructors,
   serialGraph,
+  schemaHasFormatAnnotations,
   schemaAcceptsArray,
   resolveSchemaInputs,
   resetMethodNameCache,
@@ -6810,7 +6671,6 @@ export {
   parallel,
   mergeChainedOutputToInput,
   mapTaskConfigSchema,
-  jobQueueTaskConfigSchema,
   iteratorTaskConfigSchema,
   isTaskStreamable,
   isStrictArraySchema,
@@ -6867,6 +6727,7 @@ export {
   WHILE_CONTEXT_SCHEMA,
   TaskTimeoutError,
   TaskStatus,
+  TaskSerializationError,
   TaskRegistry,
   TaskQueueRegistry,
   TaskOutputTabularRepository,
@@ -6875,6 +6736,7 @@ export {
   TaskOutputPrimaryKeyNames,
   TaskJSONError,
   TaskInvalidInputError,
+  TaskGraphTimeoutError,
   TaskGraphTabularRepository,
   TaskGraphSchema,
   TaskGraphRunner,
@@ -6894,7 +6756,6 @@ export {
   PROPERTY_ARRAY,
   MapTask,
   JobTaskFailedError,
-  JobQueueTask,
   JOB_QUEUE_FACTORY,
   IteratorTaskRunner,
   IteratorTask,
@@ -6917,4 +6778,4 @@ export {
   ConditionalTask
 };
 
-//# debugId=F7E8A2EB122F7E0864756E2164756E21
+//# debugId=8BC5BADB1209138664756E2164756E21