@workglow/task-graph 0.0.117 → 0.0.119

package/dist/node.js

@@ -1,82 +1,3495 @@
+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/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
+      }
+    },
+    additionalProperties: false
+  };
+});
+
+// src/task-graph/Dataflow.ts
+import { areSemanticallyCompatible, EventEmitter } from "@workglow/util";
+
+class Dataflow {
+  sourceTaskId;
+  sourceTaskPortId;
+  targetTaskId;
+  targetTaskPortId;
+  constructor(sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId) {
+    this.sourceTaskId = sourceTaskId;
+    this.sourceTaskPortId = sourceTaskPortId;
+    this.targetTaskId = targetTaskId;
+    this.targetTaskPortId = targetTaskPortId;
+  }
+  static createId(sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId) {
+    return `${sourceTaskId}[${sourceTaskPortId}] ==> ${targetTaskId}[${targetTaskPortId}]`;
+  }
+  get id() {
+    return Dataflow.createId(this.sourceTaskId, this.sourceTaskPortId, this.targetTaskId, this.targetTaskPortId);
+  }
+  value = undefined;
+  status = TaskStatus.PENDING;
+  error;
+  stream = undefined;
+  setStream(stream) {
+    this.stream = stream;
+  }
+  getStream() {
+    return this.stream;
+  }
+  async awaitStreamValue() {
+    if (!this.stream)
+      return;
+    const reader = this.stream.getReader();
+    let lastSnapshotData = undefined;
+    let finishData = undefined;
+    let streamError;
+    try {
+      while (true) {
+        const { done, value: event } = await reader.read();
+        if (done)
+          break;
+        switch (event.type) {
+          case "snapshot":
+            lastSnapshotData = event.data;
+            break;
+          case "finish":
+            finishData = event.data;
+            break;
+          case "error":
+            streamError = event.error;
+            break;
+        }
+      }
+    } finally {
+      reader.releaseLock();
+      this.stream = undefined;
+    }
+    if (streamError) {
+      this.error = streamError;
+      this.setStatus(TaskStatus.FAILED);
+      throw streamError;
+    }
+    if (lastSnapshotData !== undefined) {
+      this.setPortData(lastSnapshotData);
+    } else if (finishData !== undefined) {
+      this.setPortData(finishData);
+    }
+  }
+  reset() {
+    this.status = TaskStatus.PENDING;
+    this.error = undefined;
+    this.value = undefined;
+    this.stream = undefined;
+    this.emit("reset");
+    this.emit("status", this.status);
+  }
+  setStatus(status) {
+    if (status === this.status)
+      return;
+    this.status = status;
+    switch (status) {
+      case TaskStatus.PROCESSING:
+        this.emit("start");
+        break;
+      case TaskStatus.STREAMING:
+        this.emit("streaming");
+        break;
+      case TaskStatus.COMPLETED:
+        this.emit("complete");
+        break;
+      case TaskStatus.ABORTING:
+        this.emit("abort");
+        break;
+      case TaskStatus.PENDING:
+        this.emit("reset");
+        break;
+      case TaskStatus.FAILED:
+        this.emit("error", this.error);
+        break;
+      case TaskStatus.DISABLED:
+        this.emit("disabled");
+        break;
+    }
+    this.emit("status", this.status);
+  }
+  setPortData(entireDataBlock) {
+    if (this.sourceTaskPortId === DATAFLOW_ALL_PORTS) {
+      this.value = entireDataBlock;
+    } else if (this.sourceTaskPortId === DATAFLOW_ERROR_PORT) {
+      this.error = entireDataBlock;
+    } else {
+      this.value = entireDataBlock[this.sourceTaskPortId];
+    }
+  }
+  getPortData() {
+    let result;
+    if (this.targetTaskPortId === DATAFLOW_ALL_PORTS) {
+      result = this.value;
+    } else if (this.targetTaskPortId === DATAFLOW_ERROR_PORT) {
+      result = { [DATAFLOW_ERROR_PORT]: this.error };
+    } else {
+      result = { [this.targetTaskPortId]: this.value };
+    }
+    return result;
+  }
+  toJSON() {
+    return {
+      sourceTaskId: this.sourceTaskId,
+      sourceTaskPortId: this.sourceTaskPortId,
+      targetTaskId: this.targetTaskId,
+      targetTaskPortId: this.targetTaskPortId
+    };
+  }
+  semanticallyCompatible(graph, dataflow) {
+    const targetSchema = graph.getTask(dataflow.targetTaskId).inputSchema();
+    const sourceSchema = graph.getTask(dataflow.sourceTaskId).outputSchema();
+    if (typeof targetSchema === "boolean") {
+      if (targetSchema === false) {
+        return "incompatible";
+      }
+      return "static";
+    }
+    if (typeof sourceSchema === "boolean") {
+      if (sourceSchema === false) {
+        return "incompatible";
+      }
+      return "runtime";
+    }
+    let targetSchemaProperty = DATAFLOW_ALL_PORTS === dataflow.targetTaskPortId ? true : targetSchema.properties?.[dataflow.targetTaskPortId];
+    if (targetSchemaProperty === undefined && targetSchema.additionalProperties === true) {
+      targetSchemaProperty = true;
+    }
+    let sourceSchemaProperty = DATAFLOW_ALL_PORTS === dataflow.sourceTaskPortId ? true : sourceSchema.properties?.[dataflow.sourceTaskPortId];
+    if (sourceSchemaProperty === undefined && sourceSchema.additionalProperties === true) {
+      sourceSchemaProperty = true;
+    }
+    const semanticallyCompatible = areSemanticallyCompatible(sourceSchemaProperty, targetSchemaProperty);
+    return semanticallyCompatible;
+  }
+  get events() {
+    if (!this._events) {
+      this._events = new EventEmitter;
+    }
+    return this._events;
+  }
+  _events;
+  subscribe(name, fn) {
+    return this.events.subscribe(name, fn);
+  }
+  on(name, fn) {
+    this.events.on(name, fn);
+  }
+  off(name, fn) {
+    this.events.off(name, fn);
+  }
+  once(name, fn) {
+    this.events.once(name, fn);
+  }
+  waitOn(name) {
+    return this.events.waitOn(name);
+  }
+  emit(name, ...args) {
+    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);
+    }
+  };
+});
+
+// src/task-graph/GraphSchemaUtils.ts
+import { uuid4 } from "@workglow/util";
+function calculateNodeDepths(graph) {
+  const depths = new Map;
+  const tasks = graph.getTasks();
+  for (const task of tasks) {
+    depths.set(task.id, 0);
+  }
+  const sortedTasks = graph.topologicallySortedNodes();
+  for (const task of sortedTasks) {
+    const currentDepth = depths.get(task.id) || 0;
+    const targetTasks = graph.getTargetTasks(task.id);
+    for (const targetTask of targetTasks) {
+      const targetDepth = depths.get(targetTask.id) || 0;
+      depths.set(targetTask.id, Math.max(targetDepth, currentDepth + 1));
+    }
+  }
+  return depths;
+}
+function computeGraphInputSchema(graph, options) {
+  const trackOrigins = options?.trackOrigins ?? false;
+  const properties = {};
+  const required = [];
+  const propertyOrigins = {};
+  const tasks = graph.getTasks();
+  const startingNodes = tasks.filter((task) => graph.getSourceDataflows(task.id).length === 0);
+  for (const task of startingNodes) {
+    const taskInputSchema = task.inputSchema();
+    if (typeof taskInputSchema === "boolean") {
+      if (taskInputSchema === false) {
+        continue;
+      }
+      if (taskInputSchema === true) {
+        properties[DATAFLOW_ALL_PORTS] = {};
+        continue;
+      }
+    }
+    const taskProperties = taskInputSchema.properties || {};
+    for (const [inputName, inputProp] of Object.entries(taskProperties)) {
+      if (!properties[inputName]) {
+        properties[inputName] = inputProp;
+        if (taskInputSchema.required && taskInputSchema.required.includes(inputName)) {
+          required.push(inputName);
+        }
+        if (trackOrigins) {
+          propertyOrigins[inputName] = [task.id];
+        }
+      } else if (trackOrigins) {
+        propertyOrigins[inputName].push(task.id);
+      }
+    }
+  }
+  const sourceIds = new Set(startingNodes.map((t) => t.id));
+  for (const task of tasks) {
+    if (sourceIds.has(task.id))
+      continue;
+    const taskInputSchema = task.inputSchema();
+    if (typeof taskInputSchema === "boolean")
+      continue;
+    const requiredKeys = new Set(taskInputSchema.required || []);
+    if (requiredKeys.size === 0)
+      continue;
+    const connectedPorts = new Set(graph.getSourceDataflows(task.id).map((df) => df.targetTaskPortId));
+    for (const key of requiredKeys) {
+      if (connectedPorts.has(key))
+        continue;
+      if (properties[key]) {
+        if (trackOrigins) {
+          propertyOrigins[key].push(task.id);
+        }
+        continue;
+      }
+      if (task.defaults && task.defaults[key] !== undefined)
+        continue;
+      const prop = (taskInputSchema.properties || {})[key];
+      if (!prop || typeof prop === "boolean")
+        continue;
+      properties[key] = prop;
+      if (!required.includes(key)) {
+        required.push(key);
+      }
+      if (trackOrigins) {
+        propertyOrigins[key] = [task.id];
+      }
+    }
+  }
+  if (trackOrigins) {
+    for (const [propName, origins] of Object.entries(propertyOrigins)) {
+      const prop = properties[propName];
+      if (!prop || typeof prop === "boolean")
+        continue;
+      if (origins.length === 1) {
+        properties[propName] = { ...prop, "x-source-task-id": origins[0] };
+      } else {
+        properties[propName] = { ...prop, "x-source-task-ids": origins };
+      }
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {},
+    additionalProperties: false
+  };
+}
+function computeGraphOutputSchema(graph, options) {
+  const trackOrigins = options?.trackOrigins ?? false;
+  const properties = {};
+  const required = [];
+  const propertyOrigins = {};
+  const tasks = graph.getTasks();
+  const endingNodes = tasks.filter((task) => graph.getTargetDataflows(task.id).length === 0);
+  const depths = calculateNodeDepths(graph);
+  const maxDepth = Math.max(...endingNodes.map((task) => depths.get(task.id) || 0));
+  const lastLevelNodes = endingNodes.filter((task) => depths.get(task.id) === maxDepth);
+  const propertyCount = {};
+  const propertySchema = {};
+  for (const task of lastLevelNodes) {
+    const taskOutputSchema = task.outputSchema();
+    if (typeof taskOutputSchema === "boolean") {
+      if (taskOutputSchema === false) {
+        continue;
+      }
+      if (taskOutputSchema === true) {
+        properties[DATAFLOW_ALL_PORTS] = {};
+        continue;
+      }
+    }
+    const taskProperties = taskOutputSchema.properties || {};
+    for (const [outputName, outputProp] of Object.entries(taskProperties)) {
+      propertyCount[outputName] = (propertyCount[outputName] || 0) + 1;
+      if (!propertySchema[outputName]) {
+        propertySchema[outputName] = outputProp;
+      }
+      if (trackOrigins) {
+        if (!propertyOrigins[outputName]) {
+          propertyOrigins[outputName] = [task.id];
+        } else {
+          propertyOrigins[outputName].push(task.id);
+        }
+      }
+    }
+  }
+  for (const [outputName] of Object.entries(propertyCount)) {
+    const outputProp = propertySchema[outputName];
+    if (lastLevelNodes.length === 1) {
+      properties[outputName] = outputProp;
+    } else {
+      properties[outputName] = {
+        type: "array",
+        items: outputProp
+      };
+    }
+  }
+  if (trackOrigins) {
+    for (const [propName, origins] of Object.entries(propertyOrigins)) {
+      const prop = properties[propName];
+      if (!prop || typeof prop === "boolean")
+        continue;
+      if (origins.length === 1) {
+        properties[propName] = { ...prop, "x-source-task-id": origins[0] };
+      } else {
+        properties[propName] = { ...prop, "x-source-task-ids": origins };
+      }
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {},
+    additionalProperties: false
+  };
+}
+function stripOriginAnnotations(schema) {
+  if (typeof schema === "boolean" || !schema || typeof schema !== "object")
+    return schema;
+  const properties = schema.properties;
+  if (!properties)
+    return schema;
+  const strippedProperties = {};
+  for (const [key, prop] of Object.entries(properties)) {
+    if (!prop || typeof prop !== "object") {
+      strippedProperties[key] = prop;
+      continue;
+    }
+    const {
+      "x-source-task-id": _id,
+      "x-source-task-ids": _ids,
+      ...rest
+    } = prop;
+    strippedProperties[key] = rest;
+  }
+  return { ...schema, properties: strippedProperties };
+}
+function getOriginTaskIds(prop) {
+  if (prop["x-source-task-ids"]) {
+    return prop["x-source-task-ids"];
+  }
+  if (prop["x-source-task-id"] !== undefined) {
+    return [prop["x-source-task-id"]];
+  }
+  return [];
+}
+function addBoundaryNodesToGraphJson(json, graph) {
+  const hasInputTask = json.tasks.some((t) => t.type === "InputTask");
+  const hasOutputTask = json.tasks.some((t) => t.type === "OutputTask");
+  if (hasInputTask && hasOutputTask) {
+    return json;
+  }
+  const inputSchema = !hasInputTask ? computeGraphInputSchema(graph, { trackOrigins: true }) : undefined;
+  const outputSchema = !hasOutputTask ? computeGraphOutputSchema(graph, { trackOrigins: true }) : undefined;
+  const prependTasks = [];
+  const appendTasks = [];
+  const inputDataflows = [];
+  const outputDataflows = [];
+  if (!hasInputTask && inputSchema) {
+    const inputTaskId = uuid4();
+    const strippedInputSchema = stripOriginAnnotations(inputSchema);
+    prependTasks.push({
+      id: inputTaskId,
+      type: "InputTask",
+      config: {
+        inputSchema: strippedInputSchema,
+        outputSchema: strippedInputSchema
+      }
+    });
+    if (typeof inputSchema !== "boolean" && inputSchema.properties) {
+      for (const [propName, prop] of Object.entries(inputSchema.properties)) {
+        if (!prop || typeof prop === "boolean")
+          continue;
+        const origins = getOriginTaskIds(prop);
+        for (const originId of origins) {
+          inputDataflows.push({
+            sourceTaskId: inputTaskId,
+            sourceTaskPortId: propName,
+            targetTaskId: originId,
+            targetTaskPortId: propName
+          });
+        }
+      }
+    }
+  }
+  if (!hasOutputTask && outputSchema) {
+    const outputTaskId = uuid4();
+    const strippedOutputSchema = stripOriginAnnotations(outputSchema);
+    appendTasks.push({
+      id: outputTaskId,
+      type: "OutputTask",
+      config: {
+        inputSchema: strippedOutputSchema,
+        outputSchema: strippedOutputSchema
+      }
+    });
+    if (typeof outputSchema !== "boolean" && outputSchema.properties) {
+      for (const [propName, prop] of Object.entries(outputSchema.properties)) {
+        if (!prop || typeof prop === "boolean")
+          continue;
+        const origins = getOriginTaskIds(prop);
+        for (const originId of origins) {
+          outputDataflows.push({
+            sourceTaskId: originId,
+            sourceTaskPortId: propName,
+            targetTaskId: outputTaskId,
+            targetTaskPortId: propName
+          });
+        }
+      }
+    }
+  }
+  return {
+    tasks: [...prependTasks, ...json.tasks, ...appendTasks],
+    dataflows: [...inputDataflows, ...json.dataflows, ...outputDataflows]
+  };
+}
+function addBoundaryNodesToDependencyJson(items, graph) {
+  const hasInputTask = items.some((t) => t.type === "InputTask");
+  const hasOutputTask = items.some((t) => t.type === "OutputTask");
+  if (hasInputTask && hasOutputTask) {
+    return items;
+  }
+  const prependItems = [];
+  const appendItems = [];
+  if (!hasInputTask) {
+    const inputSchema = computeGraphInputSchema(graph, { trackOrigins: true });
+    const inputTaskId = uuid4();
+    const strippedInputSchema = stripOriginAnnotations(inputSchema);
+    prependItems.push({
+      id: inputTaskId,
+      type: "InputTask",
+      config: {
+        inputSchema: strippedInputSchema,
+        outputSchema: strippedInputSchema
+      }
+    });
+    if (typeof inputSchema !== "boolean" && inputSchema.properties) {
+      for (const [propName, prop] of Object.entries(inputSchema.properties)) {
+        if (!prop || typeof prop === "boolean")
+          continue;
+        const origins = getOriginTaskIds(prop);
+        for (const originId of origins) {
+          const targetItem = items.find((item) => item.id === originId);
+          if (!targetItem)
+            continue;
+          if (!targetItem.dependencies) {
+            targetItem.dependencies = {};
+          }
+          const existing = targetItem.dependencies[propName];
+          const dep = { id: inputTaskId, output: propName };
+          if (!existing) {
+            targetItem.dependencies[propName] = dep;
+          } else if (Array.isArray(existing)) {
+            existing.push(dep);
+          } else {
+            targetItem.dependencies[propName] = [existing, dep];
+          }
+        }
+      }
+    }
+  }
+  if (!hasOutputTask) {
+    const outputSchema = computeGraphOutputSchema(graph, { trackOrigins: true });
+    const outputTaskId = uuid4();
+    const strippedOutputSchema = stripOriginAnnotations(outputSchema);
+    const outputDependencies = {};
+    if (typeof outputSchema !== "boolean" && outputSchema.properties) {
+      for (const [propName, prop] of Object.entries(outputSchema.properties)) {
+        if (!prop || typeof prop === "boolean")
+          continue;
+        const origins = getOriginTaskIds(prop);
+        if (origins.length === 1) {
+          outputDependencies[propName] = { id: origins[0], output: propName };
+        } else if (origins.length > 1) {
+          outputDependencies[propName] = origins.map((id) => ({ id, output: propName }));
+        }
+      }
+    }
+    appendItems.push({
+      id: outputTaskId,
+      type: "OutputTask",
+      config: {
+        inputSchema: strippedOutputSchema,
+        outputSchema: strippedOutputSchema
+      },
+      ...Object.keys(outputDependencies).length > 0 ? { dependencies: outputDependencies } : {}
+    });
+  }
+  return [...prependItems, ...items, ...appendItems];
+}
+var init_GraphSchemaUtils = __esm(() => {
+  init_Dataflow();
+});
+
+// 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/storage/TaskOutputRepository.ts
+import { createServiceToken, EventEmitter as EventEmitter2 } from "@workglow/util";
+
+class TaskOutputRepository {
+  outputCompression;
+  constructor({ outputCompression = true }) {
+    this.outputCompression = outputCompression;
+  }
+  get events() {
+    if (!this._events) {
+      this._events = new EventEmitter2;
+    }
+    return this._events;
+  }
+  _events;
+  on(name, fn) {
+    this.events.on(name, fn);
+  }
+  off(name, fn) {
+    this.events.off(name, fn);
+  }
+  waitOn(name) {
+    return this.events.waitOn(name);
+  }
+  emit(name, ...args) {
+    this._events?.emit(name, ...args);
+  }
+}
+var TASK_OUTPUT_REPOSITORY;
+var init_TaskOutputRepository = __esm(() => {
+  TASK_OUTPUT_REPOSITORY = createServiceToken("taskgraph.taskOutputRepository");
+});
+
+// src/task/InputResolver.ts
+import { getInputResolvers } from "@workglow/util";
+function getSchemaFormat(schema) {
+  if (typeof schema !== "object" || schema === null)
+    return;
+  const s = schema;
+  if (typeof s.format === "string")
+    return s.format;
+  const variants = s.oneOf ?? s.anyOf;
+  if (Array.isArray(variants)) {
+    for (const variant of variants) {
+      if (typeof variant === "object" && variant !== null) {
+        const v = variant;
+        if (typeof v.format === "string")
+          return v.format;
+      }
+    }
+  }
+  return;
+}
+function getObjectSchema(schema) {
+  if (typeof schema !== "object" || schema === null)
+    return;
+  const s = schema;
+  if (s.type === "object" && s.properties && typeof s.properties === "object") {
+    return s;
+  }
+  const variants = s.oneOf ?? s.anyOf;
+  if (Array.isArray(variants)) {
+    for (const variant of variants) {
+      if (typeof variant === "object" && variant !== null) {
+        const v = variant;
+        if (v.type === "object" && v.properties && typeof v.properties === "object") {
+          return v;
+        }
+      }
+    }
+  }
+  return;
+}
+function getFormatPrefix(format) {
+  const colonIndex = format.indexOf(":");
+  return colonIndex >= 0 ? format.substring(0, colonIndex) : format;
+}
+async function resolveSchemaInputs(input, schema, config) {
+  if (typeof schema === "boolean")
+    return input;
+  const properties = schema.properties;
+  if (!properties || typeof properties !== "object")
+    return input;
+  const resolvers = getInputResolvers();
+  const resolved = { ...input };
+  for (const [key, propSchema] of Object.entries(properties)) {
+    let value = resolved[key];
+    const format = getSchemaFormat(propSchema);
+    if (format) {
+      let resolver = resolvers.get(format);
+      if (!resolver) {
+        const prefix = getFormatPrefix(format);
+        resolver = resolvers.get(prefix);
+      }
+      if (resolver) {
+        if (typeof value === "string") {
+          value = await resolver(value, format, config.registry);
+          resolved[key] = value;
+        } else if (Array.isArray(value) && value.some((item) => typeof item === "string")) {
+          const results = await Promise.all(value.map((item) => typeof item === "string" ? resolver(item, format, config.registry) : item));
+          value = results.filter((result) => result !== undefined);
+          resolved[key] = value;
+        }
+      }
+    }
+    if (value !== null && value !== undefined && typeof value === "object" && !Array.isArray(value)) {
+      const objectSchema = getObjectSchema(propSchema);
+      if (objectSchema) {
+        resolved[key] = await resolveSchemaInputs(value, objectSchema, config);
+      }
+    }
+  }
+  return resolved;
+}
+var init_InputResolver = () => {};
+
+// src/task/StreamTypes.ts
+function getPortStreamMode(schema, portId) {
+  if (typeof schema === "boolean")
+    return "none";
+  const prop = schema.properties?.[portId];
+  if (!prop || typeof prop === "boolean")
+    return "none";
+  const xStream = prop["x-stream"];
+  if (xStream === "append" || xStream === "replace" || xStream === "object")
+    return xStream;
+  return "none";
+}
+function getStreamingPorts(schema) {
+  if (typeof schema === "boolean")
+    return [];
+  const props = schema.properties;
+  if (!props)
+    return [];
+  const result = [];
+  for (const [name, prop] of Object.entries(props)) {
+    if (!prop || typeof prop === "boolean")
+      continue;
+    const xStream = prop["x-stream"];
+    if (xStream === "append" || xStream === "replace" || xStream === "object") {
+      result.push({ port: name, mode: xStream });
+    }
+  }
+  return result;
+}
+function getOutputStreamMode(outputSchema) {
+  const ports = getStreamingPorts(outputSchema);
+  if (ports.length === 0)
+    return "none";
+  const mode = ports[0].mode;
+  for (let i = 1;i < ports.length; i++) {
+    if (ports[i].mode !== mode) {
+      return "mixed";
+    }
+  }
+  return mode;
+}
+function isTaskStreamable(task) {
+  if (typeof task.executeStream !== "function")
+    return false;
+  return getOutputStreamMode(task.outputSchema()) !== "none";
+}
+function getAppendPortId(schema) {
+  if (typeof schema === "boolean")
+    return;
+  const props = schema.properties;
+  if (!props)
+    return;
+  for (const [name, prop] of Object.entries(props)) {
+    if (!prop || typeof prop === "boolean")
+      continue;
+    if (prop["x-stream"] === "append")
+      return name;
+  }
+  return;
+}
+function edgeNeedsAccumulation(sourceSchema, sourcePort, targetSchema, targetPort) {
+  const sourceMode = getPortStreamMode(sourceSchema, sourcePort);
+  if (sourceMode === "none")
+    return false;
+  const targetMode = getPortStreamMode(targetSchema, targetPort);
+  return sourceMode !== targetMode;
+}
+function getObjectPortId(schema) {
+  if (typeof schema === "boolean")
+    return;
+  const props = schema.properties;
+  if (!props)
+    return;
+  for (const [name, prop] of Object.entries(props)) {
+    if (!prop || typeof prop === "boolean")
+      continue;
+    if (prop["x-stream"] === "object")
+      return name;
+  }
+  return;
+}
+function getStructuredOutputSchemas(schema) {
+  const result = new Map;
+  if (typeof schema === "boolean")
+    return result;
+  const props = schema.properties;
+  if (!props)
+    return result;
+  for (const [name, prop] of Object.entries(props)) {
+    if (!prop || typeof prop === "boolean")
+      continue;
+    if (prop["x-structured-output"] === true) {
+      result.set(name, prop);
+    }
+  }
+  return result;
+}
+function hasStructuredOutput(schema) {
+  return getStructuredOutputSchemas(schema).size > 0;
+}
+var init_StreamTypes = () => {};
+
+// src/task/TaskRunner.ts
+import {
+  getTelemetryProvider,
+  globalServiceRegistry,
+  SpanStatusCode
+} from "@workglow/util";
+function hasRunConfig(i) {
+  return i !== null && typeof i === "object" && "runConfig" in i;
+}
+
+class TaskRunner {
+  running = false;
+  reactiveRunning = false;
+  task;
+  abortController;
+  outputCache;
+  registry = globalServiceRegistry;
+  inputStreams;
+  timeoutTimer;
+  pendingTimeoutError;
+  shouldAccumulate = true;
+  telemetrySpan;
+  constructor(task) {
+    this.task = task;
+    this.own = this.own.bind(this);
+    this.handleProgress = this.handleProgress.bind(this);
+  }
+  async run(overrides = {}, config = {}) {
+    await this.handleStart(config);
+    try {
+      this.task.setInput(overrides);
+      const schema = this.task.constructor.inputSchema();
+      this.task.runInputData = await resolveSchemaInputs(this.task.runInputData, schema, { registry: this.registry });
+      const isValid = await this.task.validateInput(this.task.runInputData);
+      if (!isValid) {
+        throw new TaskInvalidInputError("Invalid input data");
+      }
+      if (this.abortController?.signal.aborted) {
+        await this.handleAbort();
+        throw new TaskAbortedError("Promise for task created and aborted before run");
+      }
+      const inputs = this.task.runInputData;
+      let outputs;
+      const isStreamable = isTaskStreamable(this.task);
+      if (this.task.cacheable) {
+        outputs = await this.outputCache?.getOutput(this.task.type, inputs);
+        if (outputs) {
+          this.telemetrySpan?.addEvent("workglow.task.cache_hit");
+          if (isStreamable) {
+            this.task.runOutputData = outputs;
+            this.task.emit("stream_start");
+            this.task.emit("stream_chunk", { type: "finish", data: outputs });
+            this.task.emit("stream_end", outputs);
+            this.task.runOutputData = await this.executeTaskReactive(inputs, outputs);
+          } else {
+            this.task.runOutputData = await this.executeTaskReactive(inputs, outputs);
+          }
+        }
+      }
+      if (!outputs) {
+        if (isStreamable) {
+          outputs = await this.executeStreamingTask(inputs);
+        } else {
+          outputs = await this.executeTask(inputs);
+        }
+        if (this.task.cacheable && outputs !== undefined) {
+          await this.outputCache?.saveOutput(this.task.type, inputs, outputs);
+        }
+        this.task.runOutputData = outputs ?? {};
+      }
+      await this.handleComplete();
+      return this.task.runOutputData;
+    } catch (err) {
+      await this.handleError(err);
+      throw this.task.error instanceof TaskTimeoutError ? this.task.error : err;
+    }
+  }
+  async runReactive(overrides = {}) {
+    if (this.task.status === TaskStatus.PROCESSING) {
+      return this.task.runOutputData;
+    }
+    this.task.setInput(overrides);
+    const schema = this.task.constructor.inputSchema();
+    this.task.runInputData = await resolveSchemaInputs(this.task.runInputData, schema, { registry: this.registry });
+    await this.handleStartReactive();
+    try {
+      const isValid = await this.task.validateInput(this.task.runInputData);
+      if (!isValid) {
+        throw new TaskInvalidInputError("Invalid input data");
+      }
+      const resultReactive = await this.executeTaskReactive(this.task.runInputData, this.task.runOutputData);
+      this.task.runOutputData = resultReactive;
+      await this.handleCompleteReactive();
+    } catch (err) {
+      await this.handleErrorReactive();
+    } finally {
+      return this.task.runOutputData;
+    }
+  }
+  abort() {
+    if (this.task.hasChildren()) {
+      this.task.subGraph.abort();
+    }
+    this.abortController?.abort();
+  }
+  own(i) {
+    const task = ensureTask(i, { isOwned: true });
+    this.task.subGraph.addTask(task);
+    if (hasRunConfig(i)) {
+      Object.assign(i.runConfig, {
+        registry: this.registry,
+        signal: this.abortController?.signal
+      });
+    }
+    return i;
+  }
+  async executeTask(input) {
+    const result = await this.task.execute(input, {
+      signal: this.abortController.signal,
+      updateProgress: this.handleProgress.bind(this),
+      own: this.own,
+      registry: this.registry
+    });
+    return await this.executeTaskReactive(input, result || {});
+  }
+  async executeTaskReactive(input, output) {
+    const reactiveResult = await this.task.executeReactive(input, output, { own: this.own });
+    return Object.assign({}, output, reactiveResult ?? {});
+  }
+  async executeStreamingTask(input) {
+    const streamMode = getOutputStreamMode(this.task.outputSchema());
+    if (streamMode === "append") {
+      const ports = getStreamingPorts(this.task.outputSchema());
+      if (ports.length === 0) {
+        throw new TaskError(`Task ${this.task.type} declares append streaming but no output port has x-stream: "append"`);
+      }
+    }
+    if (streamMode === "object") {
+      const ports = getStreamingPorts(this.task.outputSchema());
+      if (ports.length === 0) {
+        throw new TaskError(`Task ${this.task.type} declares object streaming but no output port has x-stream: "object"`);
+      }
+    }
+    const accumulated = this.shouldAccumulate ? new Map : undefined;
+    const accumulatedObjects = this.shouldAccumulate ? new Map : undefined;
+    let chunkCount = 0;
+    let finalOutput;
+    this.task.emit("stream_start");
+    const stream = this.task.executeStream(input, {
+      signal: this.abortController.signal,
+      updateProgress: this.handleProgress.bind(this),
+      own: this.own,
+      registry: this.registry,
+      inputStreams: this.inputStreams
+    });
+    for await (const event of stream) {
+      chunkCount++;
+      if (chunkCount === 1) {
+        this.task.status = TaskStatus.STREAMING;
+        this.task.emit("status", this.task.status);
+      }
+      if (event.type === "snapshot") {
+        this.task.runOutputData = event.data;
+      }
+      switch (event.type) {
+        case "text-delta": {
+          if (accumulated) {
+            accumulated.set(event.port, (accumulated.get(event.port) ?? "") + event.textDelta);
+          }
+          this.task.emit("stream_chunk", event);
+          const progress = Math.min(99, Math.round(100 * (1 - Math.exp(-0.05 * chunkCount))));
+          await this.handleProgress(progress);
+          break;
+        }
+        case "object-delta": {
+          if (accumulatedObjects) {
+            accumulatedObjects.set(event.port, event.objectDelta);
+          }
+          this.task.runOutputData = {
+            ...this.task.runOutputData,
+            [event.port]: event.objectDelta
+          };
+          this.task.emit("stream_chunk", event);
+          const progress = Math.min(99, Math.round(100 * (1 - Math.exp(-0.05 * chunkCount))));
+          await this.handleProgress(progress);
+          break;
+        }
+        case "snapshot": {
+          this.task.emit("stream_chunk", event);
+          const progress = Math.min(99, Math.round(100 * (1 - Math.exp(-0.05 * chunkCount))));
+          await this.handleProgress(progress);
+          break;
+        }
+        case "finish": {
+          if (accumulated || accumulatedObjects) {
+            const merged = { ...event.data || {} };
+            if (accumulated) {
+              for (const [port, text] of accumulated) {
+                if (text.length > 0)
+                  merged[port] = text;
+              }
+            }
+            if (accumulatedObjects) {
+              for (const [port, obj] of accumulatedObjects) {
+                merged[port] = obj;
+              }
+            }
+            finalOutput = merged;
+            this.task.emit("stream_chunk", { type: "finish", data: merged });
+          } else {
+            finalOutput = event.data;
+            this.task.emit("stream_chunk", event);
+          }
+          break;
+        }
+        case "error": {
+          throw event.error;
+        }
+      }
+    }
+    if (this.abortController?.signal.aborted) {
+      throw new TaskAbortedError("Task aborted during streaming");
+    }
+    if (finalOutput !== undefined) {
+      this.task.runOutputData = finalOutput;
+    }
+    this.task.emit("stream_end", this.task.runOutputData);
+    const reactiveResult = await this.executeTaskReactive(input, this.task.runOutputData || {});
+    return reactiveResult;
+  }
+  async handleStart(config = {}) {
+    if (this.task.status === TaskStatus.PROCESSING)
+      return;
+    this.running = true;
+    this.task.startedAt = new Date;
+    this.task.progress = 0;
+    this.task.status = TaskStatus.PROCESSING;
+    this.abortController = new AbortController;
+    this.abortController.signal.addEventListener("abort", () => {
+      this.handleAbort();
+    });
+    if (config.signal?.aborted) {
+      this.abortController.abort();
+    } else if (config.signal) {
+      config.signal.addEventListener("abort", () => this.abortController.abort(), { once: true });
+    }
+    const cache = config.outputCache ?? this.task.runConfig?.outputCache;
+    if (cache === true) {
+      let instance = globalServiceRegistry.get(TASK_OUTPUT_REPOSITORY);
+      this.outputCache = instance;
+    } else if (cache === false) {
+      this.outputCache = undefined;
+    } else if (cache instanceof TaskOutputRepository) {
+      this.outputCache = cache;
+    }
+    this.shouldAccumulate = config.shouldAccumulate !== false;
+    const timeout = this.task.config.timeout;
+    if (timeout !== undefined && timeout > 0) {
+      this.pendingTimeoutError = new TaskTimeoutError(timeout);
+      this.timeoutTimer = setTimeout(() => {
+        this.abort();
+      }, timeout);
+    }
+    if (config.updateProgress) {
+      this.updateProgress = config.updateProgress;
+    }
+    if (config.registry) {
+      this.registry = config.registry;
+    }
+    const telemetry = getTelemetryProvider();
+    if (telemetry.isEnabled) {
+      this.telemetrySpan = telemetry.startSpan("workglow.task.run", {
+        attributes: {
+          "workglow.task.type": this.task.type,
+          "workglow.task.id": String(this.task.config.id),
+          "workglow.task.cacheable": this.task.cacheable,
+          "workglow.task.title": this.task.title || undefined
+        }
+      });
+    }
+    this.task.emit("start");
+    this.task.emit("status", this.task.status);
+  }
+  updateProgress = async (task, progress, message, ...args) => {};
+  async handleStartReactive() {
+    this.reactiveRunning = true;
+  }
+  clearTimeoutTimer() {
+    if (this.timeoutTimer !== undefined) {
+      clearTimeout(this.timeoutTimer);
+      this.timeoutTimer = undefined;
+    }
+  }
+  async handleAbort() {
+    if (this.task.status === TaskStatus.ABORTING)
+      return;
+    this.clearTimeoutTimer();
+    this.task.status = TaskStatus.ABORTING;
+    this.task.progress = 100;
+    this.task.error = this.pendingTimeoutError ?? new TaskAbortedError;
+    this.pendingTimeoutError = undefined;
+    if (this.telemetrySpan) {
+      this.telemetrySpan.setStatus(SpanStatusCode.ERROR, "aborted");
+      this.telemetrySpan.addEvent("workglow.task.aborted", {
+        "workglow.task.error": this.task.error.message
+      });
+      this.telemetrySpan.end();
+      this.telemetrySpan = undefined;
+    }
+    this.task.emit("abort", this.task.error);
+    this.task.emit("status", this.task.status);
+  }
+  async handleAbortReactive() {
+    this.reactiveRunning = false;
+  }
+  async handleComplete() {
+    if (this.task.status === TaskStatus.COMPLETED)
+      return;
+    this.clearTimeoutTimer();
+    this.pendingTimeoutError = undefined;
+    this.task.completedAt = new Date;
+    this.task.progress = 100;
+    this.task.status = TaskStatus.COMPLETED;
+    this.abortController = undefined;
+    if (this.telemetrySpan) {
+      this.telemetrySpan.setStatus(SpanStatusCode.OK);
+      this.telemetrySpan.end();
+      this.telemetrySpan = undefined;
+    }
+    this.task.emit("complete");
+    this.task.emit("status", this.task.status);
+  }
+  async handleCompleteReactive() {
+    this.reactiveRunning = false;
+  }
+  async handleDisable() {
+    if (this.task.status === TaskStatus.DISABLED)
+      return;
+    this.task.status = TaskStatus.DISABLED;
+    this.task.progress = 100;
+    this.task.completedAt = new Date;
+    this.abortController = undefined;
+    this.task.emit("disabled");
+    this.task.emit("status", this.task.status);
+  }
+  async disable() {
+    await this.handleDisable();
+  }
+  async handleError(err) {
+    if (err instanceof TaskAbortedError)
+      return this.handleAbort();
+    if (this.task.status === TaskStatus.FAILED)
+      return;
+    this.clearTimeoutTimer();
+    this.pendingTimeoutError = undefined;
+    if (this.task.hasChildren()) {
+      this.task.subGraph.abort();
+    }
+    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");
+    this.abortController = undefined;
+    if (this.telemetrySpan) {
+      this.telemetrySpan.setStatus(SpanStatusCode.ERROR, this.task.error.message);
+      this.telemetrySpan.setAttributes({ "workglow.task.error": this.task.error.message });
+      this.telemetrySpan.end();
+      this.telemetrySpan = undefined;
+    }
+    this.task.emit("error", this.task.error);
+    this.task.emit("status", this.task.status);
+  }
+  async handleErrorReactive() {
+    this.reactiveRunning = false;
+  }
+  async handleProgress(progress, message, ...args) {
+    this.task.progress = progress;
+    await this.updateProgress(this.task, progress, message, ...args);
+    this.task.emit("progress", progress, message, ...args);
+  }
+}
+var init_TaskRunner = __esm(() => {
+  init_TaskOutputRepository();
+  init_Conversions();
+  init_InputResolver();
+  init_StreamTypes();
+  init_TaskError();
+  init_TaskTypes();
+});
+
+// src/task/Task.ts
+import {
+  compileSchema,
+  deepEqual,
+  EventEmitter as EventEmitter3,
+  uuid4 as uuid42
+} from "@workglow/util";
+
+class Task {
+  static type = "Task";
+  static category = "Hidden";
+  static title = "";
+  static description = "";
+  static cacheable = true;
+  static hasDynamicSchemas = false;
+  static passthroughInputsToOutputs = false;
+  static customizable = false;
+  static inputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    };
+  }
+  static outputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    };
+  }
+  static configSchema() {
+    return TaskConfigSchema;
+  }
+  async execute(_input, context) {
+    if (context.signal?.aborted) {
+      throw new TaskAbortedError("Task aborted");
+    }
+    return;
+  }
+  async executeReactive(_input, output, _context) {
+    return output;
+  }
+  _runner;
+  get runner() {
+    if (!this._runner) {
+      this._runner = new TaskRunner(this);
+    }
+    return this._runner;
+  }
+  async run(overrides = {}, runConfig = {}) {
+    return this.runner.run(overrides, { ...this.runConfig, ...runConfig });
+  }
+  async runReactive(overrides = {}) {
+    return this.runner.runReactive(overrides);
+  }
+  abort() {
+    this.runner.abort();
+  }
+  async disable() {
+    await this.runner.disable();
+  }
+  inputSchema() {
+    return this.constructor.inputSchema();
+  }
+  outputSchema() {
+    return this.constructor.outputSchema();
+  }
+  configSchema() {
+    return this.constructor.configSchema();
+  }
+  get type() {
+    return this.constructor.type;
+  }
+  get category() {
+    return this.constructor.category;
+  }
+  get title() {
+    return this.config?.title ?? this.constructor.title;
+  }
+  get description() {
+    return this.config?.description ?? this.constructor.description;
+  }
+  get cacheable() {
+    return this.runConfig?.cacheable ?? this.config?.cacheable ?? this.constructor.cacheable;
+  }
+  defaults;
+  runInputData = {};
+  runOutputData = {};
+  config;
+  get id() {
+    return this.config.id;
+  }
+  runConfig = {};
+  status = TaskStatus.PENDING;
+  progress = 0;
+  createdAt = new Date;
+  startedAt;
+  completedAt;
+  error;
+  get events() {
+    if (!this._events) {
+      this._events = new EventEmitter3;
+    }
+    return this._events;
+  }
+  _events;
+  constructor(callerDefaultInputs = {}, config = {}, runConfig = {}) {
+    const inputDefaults = this.getDefaultInputsFromStaticInputDefinitions();
+    const mergedDefaults = Object.assign(inputDefaults, callerDefaultInputs);
+    this.defaults = this.stripSymbols(mergedDefaults);
+    this.resetInputData();
+    const title = this.constructor.title || undefined;
+    const baseConfig = Object.assign({
+      ...title ? { title } : {}
+    }, config);
+    if (baseConfig.id === undefined) {
+      baseConfig.id = uuid42();
+    }
+    this.config = this.validateAndApplyConfigDefaults(baseConfig);
+    this.runConfig = runConfig;
+  }
+  getDefaultInputsFromStaticInputDefinitions() {
+    const schema = this.inputSchema();
+    if (typeof schema === "boolean") {
+      return {};
+    }
+    try {
+      const compiledSchema = this.getInputSchemaNode();
+      const defaultData = compiledSchema.getData(undefined, {
+        addOptionalProps: true,
+        removeInvalidData: false,
+        useTypeDefaults: false
+      });
+      return defaultData || {};
+    } catch (error) {
+      console.warn(`Failed to compile input schema for ${this.type}, falling back to manual extraction:`, error);
+      return Object.entries(schema.properties || {}).reduce((acc, [id, prop]) => {
+        const defaultValue = prop.default;
+        if (defaultValue !== undefined) {
+          acc[id] = defaultValue;
+        }
+        return acc;
+      }, {});
+    }
+  }
+  resetInputData() {
+    this.runInputData = this.smartClone(this.defaults);
+  }
+  smartClone(obj, visited = new WeakSet) {
+    if (obj === null || obj === undefined) {
+      return obj;
+    }
+    if (typeof obj !== "object") {
+      return obj;
+    }
+    if (visited.has(obj)) {
+      throw new TaskConfigurationError("Circular reference detected in input data. " + "Cannot clone objects with circular references.");
+    }
+    if (ArrayBuffer.isView(obj)) {
+      if (typeof DataView !== "undefined" && obj instanceof DataView) {
+        return obj;
+      }
+      const typedArray = obj;
+      return new typedArray.constructor(typedArray);
+    }
+    if (!Array.isArray(obj)) {
+      const proto = Object.getPrototypeOf(obj);
+      if (proto !== Object.prototype && proto !== null) {
+        return obj;
+      }
+    }
+    visited.add(obj);
+    try {
+      if (Array.isArray(obj)) {
+        return obj.map((item) => this.smartClone(item, visited));
+      }
+      const result = {};
+      for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          result[key] = this.smartClone(obj[key], visited);
+        }
+      }
+      return result;
+    } finally {
+      visited.delete(obj);
+    }
+  }
+  setDefaults(defaults) {
+    this.defaults = this.stripSymbols(defaults);
+  }
+  setInput(input) {
+    const schema = this.inputSchema();
+    if (typeof schema === "boolean") {
+      if (schema === true) {
+        for (const [inputId, value] of Object.entries(input)) {
+          if (value !== undefined) {
+            this.runInputData[inputId] = value;
+          }
+        }
+      }
+      return;
+    }
+    const properties = schema.properties || {};
+    for (const [inputId, prop] of Object.entries(properties)) {
+      if (input[inputId] !== undefined) {
+        this.runInputData[inputId] = input[inputId];
+      } else if (this.runInputData[inputId] === undefined && prop.default !== undefined) {
+        this.runInputData[inputId] = prop.default;
+      }
+    }
+    if (schema.additionalProperties) {
+      for (const [inputId, value] of Object.entries(input)) {
+        if (!(inputId in properties)) {
+          this.runInputData[inputId] = value;
+        }
+      }
+    }
+  }
+  addInput(overrides) {
+    if (!overrides)
+      return false;
+    let changed = false;
+    const inputSchema = this.inputSchema();
+    if (typeof inputSchema === "boolean") {
+      if (inputSchema === false) {
+        return false;
+      }
+      for (const [key, value] of Object.entries(overrides)) {
+        if (!deepEqual(this.runInputData[key], value)) {
+          this.runInputData[key] = value;
+          changed = true;
+        }
+      }
+      return changed;
+    }
+    const properties = inputSchema.properties || {};
+    for (const [inputId, prop] of Object.entries(properties)) {
+      if (inputId === DATAFLOW_ALL_PORTS) {
+        this.runInputData = { ...this.runInputData, ...overrides };
+        changed = true;
+      } else {
+        if (overrides[inputId] === undefined)
+          continue;
+        const isArray = prop?.type === "array" || prop?.type === "any" && (Array.isArray(overrides[inputId]) || Array.isArray(this.runInputData[inputId]));
+        if (isArray) {
+          const existingItems = Array.isArray(this.runInputData[inputId]) ? this.runInputData[inputId] : this.runInputData[inputId] !== undefined ? [this.runInputData[inputId]] : [];
+          const newitems = [...existingItems];
+          const overrideItem = overrides[inputId];
+          if (Array.isArray(overrideItem)) {
+            newitems.push(...overrideItem);
+          } else {
+            newitems.push(overrideItem);
+          }
+          this.runInputData[inputId] = newitems;
+          changed = true;
+        } else {
+          if (!deepEqual(this.runInputData[inputId], overrides[inputId])) {
+            this.runInputData[inputId] = overrides[inputId];
+            changed = true;
+          }
+        }
+      }
+    }
+    if (inputSchema.additionalProperties) {
+      for (const [inputId, value] of Object.entries(overrides)) {
+        if (!(inputId in properties)) {
+          if (!deepEqual(this.runInputData[inputId], value)) {
+            this.runInputData[inputId] = value;
+            changed = true;
+          }
+        }
+      }
+    }
+    return changed;
+  }
+  async narrowInput(input, _registry) {
+    return input;
+  }
+  subscribe(name, fn) {
+    return this.events.subscribe(name, fn);
+  }
+  on(name, fn) {
+    this.events.on(name, fn);
+  }
+  off(name, fn) {
+    this.events.off(name, fn);
+  }
+  once(name, fn) {
+    this.events.once(name, fn);
+  }
+  waitOn(name) {
+    return this.events.waitOn(name);
+  }
+  emit(name, ...args) {
+    this._events?.emit(name, ...args);
+  }
+  emitSchemaChange(inputSchema, outputSchema) {
+    const finalInputSchema = inputSchema ?? this.inputSchema();
+    const finalOutputSchema = outputSchema ?? this.outputSchema();
+    this.emit("schemaChange", finalInputSchema, finalOutputSchema);
+  }
+  static getConfigSchemaNode() {
+    const schema = this.configSchema();
+    if (!schema)
+      return;
+    if (!Object.hasOwn(this, "__compiledConfigSchema")) {
+      try {
+        const schemaNode = typeof schema === "boolean" ? compileSchema(schema ? {} : { not: {} }) : compileSchema(schema);
+        Object.defineProperty(this, "__compiledConfigSchema", {
+          value: schemaNode,
+          writable: true,
+          configurable: true,
+          enumerable: false
+        });
+      } catch (error) {
+        console.warn(`Failed to compile config schema for ${this.type}:`, error);
+        return;
+      }
+    }
+    return this.__compiledConfigSchema;
+  }
+  validateAndApplyConfigDefaults(config) {
+    const ctor = this.constructor;
+    const schemaNode = ctor.getConfigSchemaNode();
+    if (!schemaNode)
+      return config;
+    const result = schemaNode.validate(config);
+    if (!result.valid) {
+      const errorMessages = result.errors.map((e) => {
+        const path = e.data?.pointer || "";
+        return `${e.message}${path ? ` (${path})` : ""}`;
+      });
+      throw new TaskConfigurationError(`[${ctor.name}] Configuration Error: ${errorMessages.join(", ")}`);
+    }
+    return config;
+  }
+  static generateInputSchemaNode(schema) {
+    if (typeof schema === "boolean") {
+      if (schema === false) {
+        return compileSchema({ not: {} });
+      }
+      return compileSchema({});
+    }
+    return compileSchema(schema);
+  }
+  static getInputSchemaNode() {
+    if (!Object.hasOwn(this, "__compiledInputSchema")) {
+      const dataPortSchema = this.inputSchema();
+      const schemaNode = this.generateInputSchemaNode(dataPortSchema);
+      try {
+        Object.defineProperty(this, "__compiledInputSchema", {
+          value: schemaNode,
+          writable: true,
+          configurable: true,
+          enumerable: false
+        });
+      } catch (error) {
+        console.warn(`Failed to compile input schema for ${this.type}, falling back to permissive validation:`, error);
+        Object.defineProperty(this, "__compiledInputSchema", {
+          value: compileSchema({}),
+          writable: true,
+          configurable: true,
+          enumerable: false
+        });
+      }
+    }
+    return this.__compiledInputSchema;
+  }
+  getInputSchemaNode() {
+    return this.constructor.getInputSchemaNode();
+  }
+  async validateInput(input) {
+    const ctor = this.constructor;
+    let schemaNode;
+    if (ctor.hasDynamicSchemas) {
+      const instanceSchema = this.inputSchema();
+      schemaNode = ctor.generateInputSchemaNode(instanceSchema);
+    } else {
+      schemaNode = this.getInputSchemaNode();
+    }
+    const result = schemaNode.validate(input);
+    if (!result.valid) {
+      const errorMessages = result.errors.map((e) => {
+        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(", ")}`);
+    }
+    return true;
+  }
+  stripSymbols(obj) {
+    if (obj === null || obj === undefined) {
+      return obj;
+    }
+    if (ArrayBuffer.isView(obj)) {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this.stripSymbols(item));
+    }
+    if (typeof obj === "object") {
+      const result = {};
+      for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          result[key] = this.stripSymbols(obj[key]);
+        }
+      }
+      return result;
+    }
+    return obj;
+  }
+  toJSON(_options) {
+    const ctor = this.constructor;
+    const { id: _id, ...config } = this.config;
+    if (config.title === ctor.title)
+      delete config.title;
+    if (config.description === ctor.description)
+      delete config.description;
+    const extras = config.extras;
+    if (!extras || Object.keys(extras).length === 0)
+      delete config.extras;
+    for (const key of Object.keys(config)) {
+      if (config[key] === undefined)
+        delete config[key];
+    }
+    const json = this.stripSymbols({
+      id: this.id,
+      type: this.type,
+      defaults: this.defaults,
+      config
+    });
+    return json;
+  }
+  toDependencyJSON(options) {
+    const json = this.toJSON(options);
+    return json;
+  }
+  hasChildren() {
+    return this._subGraph !== undefined && this._subGraph !== null && this._subGraph.getTasks().length > 0;
+  }
+  _taskAddedListener = () => {
+    this.emit("regenerate");
+  };
+  _subGraph = undefined;
+  set subGraph(subGraph) {
+    if (this._subGraph) {
+      this._subGraph.off("task_added", this._taskAddedListener);
+    }
+    this._subGraph = subGraph;
+    this._subGraph.on("task_added", this._taskAddedListener);
+  }
+  get subGraph() {
+    if (!this._subGraph) {
+      this._subGraph = new TaskGraph;
+      this._subGraph.on("task_added", this._taskAddedListener);
+    }
+    return this._subGraph;
+  }
+  regenerateGraph() {
+    if (this.hasChildren()) {
+      for (const dataflow of this.subGraph.getDataflows()) {
+        this.subGraph.removeDataflow(dataflow);
+      }
+      for (const child of this.subGraph.getTasks()) {
+        this.subGraph.removeTask(child.id);
+      }
+    }
+    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;
+}
+var init_ConditionUtils = () => {};
+
+// src/task/ConditionalTask.ts
+import { getLogger } from "@workglow/util";
+var conditionalTaskConfigSchema, ConditionalTask;
+var init_ConditionalTask = __esm(() => {
+  init_ConditionUtils();
+  init_Task();
+  init_TaskTypes();
+  conditionalTaskConfigSchema = {
+    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);
+        }
+      }));
+    }
+    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 {
+        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);
+        }
+      }
+      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];
+          }
+        }
+      } 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;
+    }
+    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 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 status;
+    }
+    static outputSchema() {
+      return {
+        type: "object",
+        properties: {
+          _activeBranches: {
+            type: "array",
+            items: { type: "string" },
+            description: "List of active branch IDs after condition evaluation"
+          }
+        },
+        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"
+        }
+      };
+      for (const branch of branches) {
+        properties[branch.outputPort] = {
+          type: "object",
+          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 {
+  dag;
+  sortedNodes;
+  currentIndex;
+  constructor(dag) {
+    this.dag = dag;
+    this.sortedNodes = [];
+    this.currentIndex = 0;
+    this.reset();
+  }
+  async* tasks() {
+    while (this.currentIndex < this.sortedNodes.length) {
+      yield this.sortedNodes[this.currentIndex++];
+    }
+  }
+  onTaskCompleted(taskId) {}
+  onTaskStreaming(taskId) {}
+  reset() {
+    this.sortedNodes = this.dag.topologicallySortedNodes();
+    this.currentIndex = 0;
+  }
+}
+
+class DependencyBasedScheduler {
+  dag;
+  completedTasks;
+  streamingTasks;
+  pendingTasks;
+  nextResolver = null;
+  constructor(dag) {
+    this.dag = dag;
+    this.completedTasks = new Set;
+    this.streamingTasks = new Set;
+    this.pendingTasks = new Set;
+    this.reset();
+  }
+  isTaskReady(task) {
+    if (task.status === TaskStatus.DISABLED) {
+      return false;
+    }
+    const sourceDataflows = this.dag.getSourceDataflows(task.id);
+    if (sourceDataflows.length > 0) {
+      const allIncomingDisabled = sourceDataflows.every((df) => df.status === TaskStatus.DISABLED);
+      if (allIncomingDisabled) {
+        return false;
+      }
+    }
+    const activeDataflows = sourceDataflows.filter((df) => df.status !== TaskStatus.DISABLED);
+    return activeDataflows.every((df) => {
+      const depId = df.sourceTaskId;
+      if (this.completedTasks.has(depId))
+        return true;
+      if (this.streamingTasks.has(depId)) {
+        const sourceTask = this.dag.getTask(depId);
+        if (sourceTask) {
+          const sourceMode = getPortStreamMode(sourceTask.outputSchema(), df.sourceTaskPortId);
+          const targetMode = getPortStreamMode(task.inputSchema(), df.targetTaskPortId);
+          if (sourceMode !== "none" && sourceMode === targetMode) {
+            return true;
+          }
+        }
+      }
+      return false;
+    });
+  }
+  async waitForNextTask() {
+    if (this.pendingTasks.size === 0)
+      return null;
+    for (const task of Array.from(this.pendingTasks)) {
+      if (task.status === TaskStatus.DISABLED) {
+        this.pendingTasks.delete(task);
+      }
+    }
+    if (this.pendingTasks.size === 0)
+      return null;
+    const readyTask = Array.from(this.pendingTasks).find((task) => this.isTaskReady(task));
+    if (readyTask) {
+      this.pendingTasks.delete(readyTask);
+      return readyTask;
+    }
+    if (this.pendingTasks.size > 0) {
+      return new Promise((resolve) => {
+        this.nextResolver = resolve;
+      });
+    }
+    return null;
+  }
+  async* tasks() {
+    while (this.pendingTasks.size > 0) {
+      const task = await this.waitForNextTask();
+      if (task) {
+        yield task;
+      } else {
+        break;
+      }
+    }
+  }
+  onTaskCompleted(taskId) {
+    this.completedTasks.add(taskId);
+    for (const task of Array.from(this.pendingTasks)) {
+      if (task.status === TaskStatus.DISABLED) {
+        this.pendingTasks.delete(task);
+      }
+    }
+    if (this.nextResolver) {
+      const readyTask = Array.from(this.pendingTasks).find((task) => this.isTaskReady(task));
+      if (readyTask) {
+        this.pendingTasks.delete(readyTask);
+        const resolver = this.nextResolver;
+        this.nextResolver = null;
+        resolver(readyTask);
+      } else if (this.pendingTasks.size === 0) {
+        const resolver = this.nextResolver;
+        this.nextResolver = null;
+        resolver(null);
+      }
+    }
+  }
+  onTaskStreaming(taskId) {
+    this.streamingTasks.add(taskId);
+    for (const task of Array.from(this.pendingTasks)) {
+      if (task.status === TaskStatus.DISABLED) {
+        this.pendingTasks.delete(task);
+      }
+    }
+    if (this.nextResolver) {
+      const readyTask = Array.from(this.pendingTasks).find((task) => this.isTaskReady(task));
+      if (readyTask) {
+        this.pendingTasks.delete(readyTask);
+        const resolver = this.nextResolver;
+        this.nextResolver = null;
+        resolver(readyTask);
+      }
+    }
+  }
+  reset() {
+    this.completedTasks.clear();
+    this.streamingTasks.clear();
+    this.pendingTasks = new Set(this.dag.topologicallySortedNodes());
+    this.nextResolver = null;
+  }
+}
+var init_TaskGraphScheduler = __esm(() => {
+  init_StreamTypes();
+  init_TaskTypes();
+});
+
+// src/task-graph/TaskGraphRunner.ts
 import {
-  ConditionalTask,
-  CreateAdaptiveWorkflow,
-  CreateEndLoopWorkflow,
-  CreateLoopWorkflow,
-  CreateWorkflow,
-  DATAFLOW_ALL_PORTS,
-  DATAFLOW_ERROR_PORT,
-  Dataflow,
-  DataflowArrow,
-  EventDagToTaskGraphMapping,
-  EventTaskGraphToDagMapping,
-  GRAPH_RESULT_ARRAY,
-  GraphAsTask,
-  GraphAsTaskRunner,
-  JobTaskFailedError,
-  PROPERTY_ARRAY,
-  TASK_OUTPUT_REPOSITORY,
-  Task,
-  TaskAbortedError,
-  TaskConfigSchema,
-  TaskConfigurationError,
-  TaskError,
-  TaskFailedError,
-  TaskGraph,
-  TaskGraphRunner,
-  TaskInvalidInputError,
-  TaskJSONError,
-  TaskOutputRepository,
-  TaskStatus,
-  TaskTimeoutError,
-  Workflow,
-  WorkflowError,
-  __require,
-  addBoundaryNodesToDependencyJson,
-  addBoundaryNodesToGraphJson,
-  calculateNodeDepths,
-  computeGraphInputSchema,
-  computeGraphOutputSchema,
-  conditionalTaskConfigSchema,
-  connect,
-  edgeNeedsAccumulation,
-  ensureTask,
-  evaluateCondition,
-  getAppendPortId,
-  getLastTask,
-  getNestedValue,
-  getObjectPortId,
-  getOutputStreamMode,
-  getPortStreamMode,
-  getStreamingPorts,
-  getStructuredOutputSchemas,
-  graphAsTaskConfigSchema,
-  hasStructuredOutput,
-  hasVectorLikeInput,
-  hasVectorOutput,
-  init_ConditionUtils,
-  init_ConditionalTask,
-  init_Conversions,
-  init_Dataflow,
-  init_GraphAsTask,
-  init_GraphAsTaskRunner,
-  init_GraphSchemaUtils,
-  init_InputResolver,
-  init_StreamTypes,
-  init_Task,
-  init_TaskError,
-  init_TaskGraph,
-  init_TaskGraphEvents,
-  init_TaskGraphRunner,
-  init_TaskOutputRepository,
-  init_TaskTypes,
-  init_Workflow,
-  isTaskStreamable,
-  parallel,
-  pipe,
-  resolveSchemaInputs,
-  serialGraph
-} from "./node-en60nycg.js";
+  collectPropertyValues,
+  getLogger as getLogger2,
+  getTelemetryProvider as getTelemetryProvider2,
+  globalServiceRegistry as globalServiceRegistry2,
+  ServiceRegistry as ServiceRegistry2,
+  SpanStatusCode as SpanStatusCode2,
+  uuid4 as uuid43
+} from "@workglow/util";
+
+class TaskGraphRunner {
+  processScheduler;
+  reactiveScheduler;
+  running = false;
+  reactiveRunning = false;
+  graph;
+  outputCache;
+  accumulateLeafOutputs = true;
+  registry = globalServiceRegistry2;
+  abortController;
+  inProgressTasks = new Map;
+  inProgressFunctions = new Map;
+  failedTaskErrors = new Map;
+  telemetrySpan;
+  constructor(graph, outputCache, processScheduler = new DependencyBasedScheduler(graph), reactiveScheduler = new TopologicalScheduler(graph)) {
+    this.processScheduler = processScheduler;
+    this.reactiveScheduler = reactiveScheduler;
+    this.graph = graph;
+    graph.outputCache = outputCache;
+    this.handleProgress = this.handleProgress.bind(this);
+  }
+  runId = "";
+  async runGraph(input = {}, config) {
+    await this.handleStart(config);
+    const results = [];
+    let error;
+    try {
+      for await (const task of this.processScheduler.tasks()) {
+        if (this.abortController?.signal.aborted) {
+          break;
+        }
+        if (this.failedTaskErrors.size > 0) {
+          break;
+        }
+        const isRootTask = this.graph.getSourceDataflows(task.id).length === 0;
+        const runAsync = async () => {
+          let errorRouted = false;
+          try {
+            const taskInput = isRootTask ? input : this.filterInputForTask(task, input);
+            const taskPromise = this.runTask(task, taskInput);
+            this.inProgressTasks.set(task.id, taskPromise);
+            const taskResult = await taskPromise;
+            if (this.graph.getTargetDataflows(task.id).length === 0) {
+              results.push(taskResult);
+            }
+          } catch (error2) {
+            if (this.hasErrorOutputEdges(task)) {
+              errorRouted = true;
+              this.pushErrorOutputToEdges(task);
+            } else {
+              this.failedTaskErrors.set(task.id, error2);
+            }
+          } finally {
+            if (!errorRouted) {
+              this.pushStatusFromNodeToEdges(this.graph, task);
+              this.pushErrorFromNodeToEdges(this.graph, task);
+            }
+            this.processScheduler.onTaskCompleted(task.id);
+          }
+        };
+        this.inProgressFunctions.set(Symbol(task.id), runAsync());
+      }
+    } catch (err) {
+      error = err;
+      getLogger2().error("Error running graph", { error });
+    }
+    await Promise.allSettled(Array.from(this.inProgressTasks.values()));
+    await Promise.allSettled(Array.from(this.inProgressFunctions.values()));
+    if (this.failedTaskErrors.size > 0) {
+      const latestError = this.failedTaskErrors.values().next().value;
+      this.handleError(latestError);
+      throw latestError;
+    }
+    if (this.abortController?.signal.aborted) {
+      await this.handleAbort();
+      throw new TaskAbortedError;
+    }
+    await this.handleComplete();
+    return results;
+  }
+  async runGraphReactive(input = {}, config) {
+    await this.handleStartReactive(config);
+    const results = [];
+    try {
+      for await (const task of this.reactiveScheduler.tasks()) {
+        const isRootTask = this.graph.getSourceDataflows(task.id).length === 0;
+        if (task.status === TaskStatus.PENDING) {
+          task.resetInputData();
+          this.copyInputFromEdgesToNode(task);
+        }
+        const taskInput = isRootTask ? input : {};
+        const taskResult = await task.runReactive(taskInput);
+        await this.pushOutputFromNodeToEdges(task, taskResult);
+        if (this.graph.getTargetDataflows(task.id).length === 0) {
+          results.push({
+            id: task.id,
+            type: task.constructor.runtype || task.constructor.type,
+            data: taskResult
+          });
+        }
+      }
+      await this.handleCompleteReactive();
+      return results;
+    } catch (error) {
+      await this.handleErrorReactive();
+      throw error;
+    }
+  }
+  abort() {
+    this.abortController?.abort();
+  }
+  async disable() {
+    await this.handleDisable();
+  }
+  filterInputForTask(task, input) {
+    const sourceDataflows = this.graph.getSourceDataflows(task.id);
+    const connectedInputs = new Set(sourceDataflows.map((df) => df.targetTaskPortId));
+    const allPortsConnected = connectedInputs.has(DATAFLOW_ALL_PORTS);
+    const filteredInput = {};
+    for (const [key, value] of Object.entries(input)) {
+      if (!connectedInputs.has(key) && !allPortsConnected) {
+        filteredInput[key] = value;
+      }
+    }
+    return filteredInput;
+  }
+  addInputData(task, overrides) {
+    if (!overrides)
+      return;
+    const changed = task.addInput(overrides);
+    if (changed && "regenerateGraph" in task && typeof task.regenerateGraph === "function") {
+      task.regenerateGraph();
+    }
+  }
+  mergeExecuteOutputsToRunOutput(results, compoundMerge) {
+    if (compoundMerge === GRAPH_RESULT_ARRAY) {
+      return results;
+    }
+    if (compoundMerge === PROPERTY_ARRAY) {
+      let fixedOutput = {};
+      const outputs = results.map((result) => result.data);
+      if (outputs.length === 1) {
+        fixedOutput = outputs[0];
+      } else if (outputs.length > 1) {
+        const collected = collectPropertyValues(outputs);
+        if (Object.keys(collected).length > 0) {
+          fixedOutput = collected;
+        }
+      }
+      return fixedOutput;
+    }
+    throw new TaskConfigurationError(`Unknown compound merge strategy: ${compoundMerge}`);
+  }
+  copyInputFromEdgesToNode(task) {
+    const dataflows = this.graph.getSourceDataflows(task.id);
+    for (const dataflow of dataflows) {
+      this.addInputData(task, dataflow.getPortData());
+    }
+  }
+  async pushOutputFromNodeToEdges(node, results) {
+    const dataflows = this.graph.getTargetDataflows(node.id);
+    for (const dataflow of dataflows) {
+      const compatibility = dataflow.semanticallyCompatible(this.graph, dataflow);
+      getLogger2().debug("pushOutputFromNodeToEdges", {
+        dataflowId: dataflow.id,
+        compatibility,
+        resultsKeys: Object.keys(results)
+      });
+      if (compatibility === "static") {
+        dataflow.setPortData(results);
+      } else if (compatibility === "runtime") {
+        const task = this.graph.getTask(dataflow.targetTaskId);
+        const narrowed = await task.narrowInput({ ...results }, this.registry);
+        dataflow.setPortData(narrowed);
+      } else {
+        const resultsKeys = Object.keys(results);
+        if (resultsKeys.length > 0) {
+          getLogger2().warn("pushOutputFromNodeToEdge not compatible, not setting port data", {
+            dataflowId: dataflow.id,
+            compatibility,
+            resultsKeys
+          });
+        }
+      }
+    }
+  }
+  pushStatusFromNodeToEdges(graph, node, status) {
+    if (!node?.config?.id)
+      return;
+    const dataflows = graph.getTargetDataflows(node.id);
+    const effectiveStatus = status ?? node.status;
+    if (node instanceof ConditionalTask && effectiveStatus === TaskStatus.COMPLETED) {
+      const branches = node.config.branches ?? [];
+      const portToBranch = new Map;
+      for (const branch of branches) {
+        portToBranch.set(branch.outputPort, branch.id);
+      }
+      const activeBranches = node.getActiveBranches();
+      for (const dataflow of dataflows) {
+        const branchId = portToBranch.get(dataflow.sourceTaskPortId);
+        if (branchId !== undefined) {
+          if (activeBranches.has(branchId)) {
+            dataflow.setStatus(TaskStatus.COMPLETED);
+          } else {
+            dataflow.setStatus(TaskStatus.DISABLED);
+          }
+        } else {
+          dataflow.setStatus(effectiveStatus);
+        }
+      }
+      this.propagateDisabledStatus(graph);
+      return;
+    }
+    dataflows.forEach((dataflow) => {
+      dataflow.setStatus(effectiveStatus);
+    });
+  }
+  pushErrorFromNodeToEdges(graph, node) {
+    if (!node?.config?.id)
+      return;
+    graph.getTargetDataflows(node.id).forEach((dataflow) => {
+      dataflow.error = node.error;
+    });
+  }
+  hasErrorOutputEdges(task) {
+    const dataflows = this.graph.getTargetDataflows(task.id);
+    return dataflows.some((df) => df.sourceTaskPortId === DATAFLOW_ERROR_PORT);
+  }
+  pushErrorOutputToEdges(task) {
+    const taskError = task.error;
+    const errorData = {
+      error: taskError?.message ?? "Unknown error",
+      errorType: taskError?.constructor?.type ?? "TaskError"
+    };
+    const dataflows = this.graph.getTargetDataflows(task.id);
+    for (const df of dataflows) {
+      if (df.sourceTaskPortId === DATAFLOW_ERROR_PORT) {
+        df.value = errorData;
+        df.setStatus(TaskStatus.COMPLETED);
+      } else {
+        df.setStatus(TaskStatus.DISABLED);
+      }
+    }
+    this.propagateDisabledStatus(this.graph);
+  }
+  propagateDisabledStatus(graph) {
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const task of graph.getTasks()) {
+        if (task.status !== TaskStatus.PENDING) {
+          continue;
+        }
+        const incomingDataflows = graph.getSourceDataflows(task.id);
+        if (incomingDataflows.length === 0) {
+          continue;
+        }
+        const allDisabled = incomingDataflows.every((df) => df.status === TaskStatus.DISABLED);
+        if (allDisabled) {
+          task.status = TaskStatus.DISABLED;
+          task.progress = 100;
+          task.completedAt = new Date;
+          task.emit("disabled");
+          task.emit("status", task.status);
+          graph.getTargetDataflows(task.id).forEach((dataflow) => {
+            dataflow.setStatus(TaskStatus.DISABLED);
+          });
+          this.processScheduler.onTaskCompleted(task.id);
+          changed = true;
+        }
+      }
+    }
+  }
+  taskNeedsAccumulation(task) {
+    if (this.outputCache)
+      return true;
+    const outEdges = this.graph.getTargetDataflows(task.id);
+    if (outEdges.length === 0)
+      return this.accumulateLeafOutputs;
+    const outSchema = task.outputSchema();
+    for (const df of outEdges) {
+      if (df.sourceTaskPortId === DATAFLOW_ALL_PORTS) {
+        if (getStreamingPorts(outSchema).length > 0)
+          return true;
+        continue;
+      }
+      const targetTask = this.graph.getTask(df.targetTaskId);
+      if (!targetTask)
+        continue;
+      const inSchema = targetTask.inputSchema();
+      if (edgeNeedsAccumulation(outSchema, df.sourceTaskPortId, inSchema, df.targetTaskPortId)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async runTask(task, input) {
+    const isStreamable = isTaskStreamable(task);
+    if (isStreamable) {
+      const dataflows = this.graph.getSourceDataflows(task.id);
+      const streamingEdges = dataflows.filter((df) => df.stream !== undefined);
+      if (streamingEdges.length > 0) {
+        const inputStreams = new Map;
+        for (const df of streamingEdges) {
+          const stream = df.stream;
+          const [forwardCopy, materializeCopy] = stream.tee();
+          inputStreams.set(df.targetTaskPortId, forwardCopy);
+          df.setStream(materializeCopy);
+        }
+        task.runner.inputStreams = inputStreams;
+      }
+    }
+    await this.awaitStreamInputs(task);
+    this.copyInputFromEdgesToNode(task);
+    if (isStreamable) {
+      return this.runStreamingTask(task, input);
+    }
+    const results = await task.runner.run(input, {
+      outputCache: this.outputCache ?? false,
+      updateProgress: async (task2, progress, message, ...args) => await this.handleProgress(task2, progress, message, ...args),
+      registry: this.registry
+    });
+    await this.pushOutputFromNodeToEdges(task, results);
+    return {
+      id: task.id,
+      type: task.constructor.runtype || task.constructor.type,
+      data: results
+    };
+  }
+  async awaitStreamInputs(task) {
+    const dataflows = this.graph.getSourceDataflows(task.id);
+    const streamPromises = dataflows.filter((df) => df.stream !== undefined).map((df) => df.awaitStreamValue());
+    if (streamPromises.length > 0) {
+      await Promise.all(streamPromises);
+    }
+  }
+  async runStreamingTask(task, input) {
+    const streamMode = getOutputStreamMode(task.outputSchema());
+    const shouldAccumulate = this.taskNeedsAccumulation(task);
+    let streamingNotified = false;
+    const onStatus = (status) => {
+      if (status === TaskStatus.STREAMING && !streamingNotified) {
+        streamingNotified = true;
+        this.pushStatusFromNodeToEdges(this.graph, task, TaskStatus.STREAMING);
+        this.pushStreamToEdges(task, streamMode);
+        this.processScheduler.onTaskStreaming(task.id);
+      }
+    };
+    const onStreamStart = () => {
+      this.graph.emit("task_stream_start", task.id);
+    };
+    const onStreamChunk = (event) => {
+      this.graph.emit("task_stream_chunk", task.id, event);
+    };
+    const onStreamEnd = (output) => {
+      this.graph.emit("task_stream_end", task.id, output);
+    };
+    task.on("status", onStatus);
+    task.on("stream_start", onStreamStart);
+    task.on("stream_chunk", onStreamChunk);
+    task.on("stream_end", onStreamEnd);
+    try {
+      const results = await task.runner.run(input, {
+        outputCache: this.outputCache ?? false,
+        shouldAccumulate,
+        updateProgress: async (task2, progress, message, ...args) => await this.handleProgress(task2, progress, message, ...args),
+        registry: this.registry
+      });
+      await this.pushOutputFromNodeToEdges(task, results);
+      return {
+        id: task.id,
+        type: task.constructor.runtype || task.constructor.type,
+        data: results
+      };
+    } finally {
+      task.off("status", onStatus);
+      task.off("stream_start", onStreamStart);
+      task.off("stream_chunk", onStreamChunk);
+      task.off("stream_end", onStreamEnd);
+    }
+  }
+  static isPortDelta(event) {
+    return event.type === "text-delta" || event.type === "object-delta";
+  }
+  createStreamFromTaskEvents(task, portId) {
+    return new ReadableStream({
+      start: (controller) => {
+        const onChunk = (event) => {
+          try {
+            if (portId !== undefined && TaskGraphRunner.isPortDelta(event) && event.port !== portId) {
+              return;
+            }
+            controller.enqueue(event);
+          } catch {}
+        };
+        const onEnd = () => {
+          try {
+            controller.close();
+          } catch {}
+          task.off("stream_chunk", onChunk);
+          task.off("stream_end", onEnd);
+        };
+        task.on("stream_chunk", onChunk);
+        task.on("stream_end", onEnd);
+      }
+    });
+  }
+  pushStreamToEdges(task, streamMode) {
+    const targetDataflows = this.graph.getTargetDataflows(task.id);
+    if (targetDataflows.length === 0)
+      return;
+    const groups = new Map;
+    for (const df of targetDataflows) {
+      const key = df.sourceTaskPortId;
+      let group = groups.get(key);
+      if (!group) {
+        group = [];
+        groups.set(key, group);
+      }
+      group.push(df);
+    }
+    for (const [portKey, edges] of groups) {
+      const filterPort = portKey === DATAFLOW_ALL_PORTS ? undefined : portKey;
+      const stream = this.createStreamFromTaskEvents(task, filterPort);
+      if (edges.length === 1) {
+        edges[0].setStream(stream);
+      } else {
+        let currentStream = stream;
+        for (let i = 0;i < edges.length; i++) {
+          if (i === edges.length - 1) {
+            edges[i].setStream(currentStream);
+          } else {
+            const [s1, s2] = currentStream.tee();
+            edges[i].setStream(s1);
+            currentStream = s2;
+          }
+        }
+      }
+    }
+  }
+  resetTask(graph, task, runId) {
+    task.status = TaskStatus.PENDING;
+    task.resetInputData();
+    task.runOutputData = {};
+    task.error = undefined;
+    task.progress = 0;
+    task.runConfig = { ...task.runConfig, runnerId: runId };
+    this.pushStatusFromNodeToEdges(graph, task);
+    this.pushErrorFromNodeToEdges(graph, task);
+    task.emit("reset");
+    task.emit("status", task.status);
+  }
+  resetGraph(graph, runnerId) {
+    graph.getTasks().forEach((node) => {
+      this.resetTask(graph, node, runnerId);
+      node.regenerateGraph();
+      if (node.hasChildren()) {
+        this.resetGraph(node.subGraph, runnerId);
+      }
+    });
+    graph.getDataflows().forEach((dataflow) => {
+      dataflow.reset();
+    });
+  }
+  async handleStart(config) {
+    if (config?.registry !== undefined) {
+      this.registry = config.registry;
+    } else if (this.registry === undefined) {
+      this.registry = new ServiceRegistry2(globalServiceRegistry2.container.createChildContainer());
+    }
+    this.accumulateLeafOutputs = config?.accumulateLeafOutputs !== false;
+    if (config?.outputCache !== undefined) {
+      if (typeof config.outputCache === "boolean") {
+        if (config.outputCache === true) {
+          this.outputCache = this.registry.get(TASK_OUTPUT_REPOSITORY);
+        } else {
+          this.outputCache = undefined;
+        }
+      } else {
+        this.outputCache = config.outputCache;
+      }
+      this.graph.outputCache = this.outputCache;
+    }
+    if (this.running || this.reactiveRunning) {
+      throw new TaskConfigurationError("Graph is already running");
+    }
+    this.running = true;
+    this.abortController = new AbortController;
+    this.abortController.signal.addEventListener("abort", () => {
+      this.handleAbort();
+    });
+    if (config?.parentSignal?.aborted) {
+      this.abortController.abort();
+      return;
+    } else {
+      config?.parentSignal?.addEventListener("abort", () => {
+        this.abortController?.abort();
+      }, { once: true });
+    }
+    this.runId = uuid43();
+    this.resetGraph(this.graph, this.runId);
+    this.processScheduler.reset();
+    this.inProgressTasks.clear();
+    this.inProgressFunctions.clear();
+    this.failedTaskErrors.clear();
+    const telemetry = getTelemetryProvider2();
+    if (telemetry.isEnabled) {
+      this.telemetrySpan = telemetry.startSpan("workglow.graph.run", {
+        attributes: {
+          "workglow.graph.run_id": this.runId,
+          "workglow.graph.task_count": this.graph.getTasks().length,
+          "workglow.graph.dataflow_count": this.graph.getDataflows().length
+        }
+      });
+    }
+    this.graph.emit("start");
+  }
+  async handleStartReactive(config) {
+    if (this.reactiveRunning) {
+      throw new TaskConfigurationError("Graph is already running reactively");
+    }
+    if (config?.registry !== undefined) {
+      this.registry = config.registry;
+    }
+    this.reactiveScheduler.reset();
+    this.reactiveRunning = true;
+  }
+  async handleComplete() {
+    this.running = false;
+    if (this.telemetrySpan) {
+      this.telemetrySpan.setStatus(SpanStatusCode2.OK);
+      this.telemetrySpan.end();
+      this.telemetrySpan = undefined;
+    }
+    this.graph.emit("complete");
+  }
+  async handleCompleteReactive() {
+    this.reactiveRunning = false;
+  }
+  async handleError(error) {
+    await Promise.allSettled(this.graph.getTasks().map(async (task) => {
+      if (task.status === TaskStatus.PROCESSING || task.status === TaskStatus.STREAMING) {
+        return task.abort();
+      }
+    }));
+    this.running = false;
+    if (this.telemetrySpan) {
+      this.telemetrySpan.setStatus(SpanStatusCode2.ERROR, error.message);
+      this.telemetrySpan.setAttributes({ "workglow.graph.error": error.message });
+      this.telemetrySpan.end();
+      this.telemetrySpan = undefined;
+    }
+    this.graph.emit("error", error);
+  }
+  async handleErrorReactive() {
+    this.reactiveRunning = false;
+  }
+  async handleAbort() {
+    await Promise.allSettled(this.graph.getTasks().map(async (task) => {
+      if (task.status === TaskStatus.PROCESSING || task.status === TaskStatus.STREAMING) {
+        return task.abort();
+      }
+    }));
+    this.running = false;
+    if (this.telemetrySpan) {
+      this.telemetrySpan.setStatus(SpanStatusCode2.ERROR, "aborted");
+      this.telemetrySpan.addEvent("workglow.graph.aborted");
+      this.telemetrySpan.end();
+      this.telemetrySpan = undefined;
+    }
+    this.graph.emit("abort");
+  }
+  async handleAbortReactive() {
+    this.reactiveRunning = false;
+  }
+  async handleDisable() {
+    await Promise.allSettled(this.graph.getTasks().map(async (task) => {
+      if (task.status === TaskStatus.PENDING) {
+        return task.disable();
+      }
+    }));
+    this.running = false;
+    this.graph.emit("disabled");
+  }
+  async handleProgress(task, progress, message, ...args) {
+    const total = this.graph.getTasks().length;
+    if (total > 1) {
+      const completed = this.graph.getTasks().reduce((acc, t) => acc + t.progress, 0);
+      progress = Math.round(completed / total);
+    }
+    this.pushStatusFromNodeToEdges(this.graph, task);
+    if (task.runOutputData && Object.keys(task.runOutputData).length > 0) {
+      await this.pushOutputFromNodeToEdges(task, task.runOutputData);
+    }
+    this.graph.emit("graph_progress", progress, message, args);
+  }
+}
+var PROPERTY_ARRAY = "PROPERTY_ARRAY", GRAPH_RESULT_ARRAY = "GRAPH_RESULT_ARRAY";
+var init_TaskGraphRunner = __esm(() => {
+  init_TaskOutputRepository();
+  init_ConditionalTask();
+  init_StreamTypes();
+  init_TaskError();
+  init_TaskTypes();
+  init_Dataflow();
+  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();
+    }
+    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;
+    }
+    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";
+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();
+    }
+    get runner() {
+      if (!this._runner) {
+        this._runner = new GraphAsTaskRunner(this);
+      }
+      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();
+      }
+      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({});
+        }
+      }
+      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);
+          }
+        }
+        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();
+          }
+        }
+        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)
+        };
+      }
+      return json;
+    }
+    toDependencyJSON(options) {
+      const json = this.toJSON(options);
+      if (this.hasChildren()) {
+        if ("subgraph" in json) {
+          delete json.subgraph;
+        }
+        return { ...json, subtasks: this.subGraph.toDependencyJSON(options) };
+      }
+      return json;
+    }
+  };
+});
+
+// src/task-graph/Conversions.ts
+function getWrapperClasses() {
+  if (!_OwnGraphTask) {
+    const GaT = (init_GraphAsTask(), __toCommonJS(exports_GraphAsTask)).GraphAsTask;
+
+    class ListeningGraphAsTask extends GaT {
+      constructor(input, config) {
+        super(input, config);
+        this.subGraph.on("start", () => {
+          this.emit("start");
+        });
+        this.subGraph.on("complete", () => {
+          this.emit("complete");
+        });
+        this.subGraph.on("error", (e) => {
+          this.emit("error", e);
+        });
+      }
+    }
+
+    class OwnGraphTask extends ListeningGraphAsTask {
+      static type = "Own[Graph]";
+    }
+
+    class OwnWorkflowTask extends ListeningGraphAsTask {
+      static type = "Own[Workflow]";
+    }
+
+    class GraphTask extends GaT {
+      static type = "Graph";
+    }
+
+    class ConvWorkflowTask extends GaT {
+      static type = "Workflow";
+    }
+    _OwnGraphTask = OwnGraphTask;
+    _OwnWorkflowTask = OwnWorkflowTask;
+    _GraphTask = GraphTask;
+    _ConvWorkflowTask = ConvWorkflowTask;
+  }
+}
+function convertPipeFunctionToTask(fn, config) {
+
+  class QuickTask extends Task {
+    static type = fn.name ? `\uD835\uDC53 ${fn.name}` : "\uD835\uDC53";
+    static inputSchema = () => {
+      return {
+        type: "object",
+        properties: {
+          [DATAFLOW_ALL_PORTS]: {}
+        },
+        additionalProperties: false
+      };
+    };
+    static outputSchema = () => {
+      return {
+        type: "object",
+        properties: {
+          [DATAFLOW_ALL_PORTS]: {}
+        },
+        additionalProperties: false
+      };
+    };
+    static cacheable = false;
+    async execute(input, context) {
+      return fn(input, context);
+    }
+  }
+  return new QuickTask({}, config);
+}
+function isWorkflowLike(arg) {
+  return arg != null && typeof arg === "object" && "graph" in arg && arg.graph instanceof TaskGraph && "run" in arg && typeof arg.run === "function";
+}
+function ensureTask(arg, config = {}) {
+  if (arg instanceof Task) {
+    return arg;
+  }
+  if (arg instanceof TaskGraph) {
+    getWrapperClasses();
+    const { isOwned, ...cleanConfig } = config;
+    if (isOwned) {
+      return new _OwnGraphTask({}, { ...cleanConfig, subGraph: arg });
+    } else {
+      return new _GraphTask({}, { ...cleanConfig, subGraph: arg });
+    }
+  }
+  if (isWorkflowLike(arg)) {
+    getWrapperClasses();
+    const { isOwned, ...cleanConfig } = config;
+    if (isOwned) {
+      return new _OwnWorkflowTask({}, { ...cleanConfig, subGraph: arg.graph });
+    } else {
+      return new _ConvWorkflowTask({}, { ...cleanConfig, subGraph: arg.graph });
+    }
+  }
+  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"
+  };
+});
+
+// src/task-graph/TaskGraph.ts
+import { DirectedAcyclicGraph, EventEmitter as EventEmitter4, uuid4 as uuid44 } from "@workglow/util";
+
+class TaskGraph {
+  outputCache;
+  constructor({ outputCache, dag } = {}) {
+    this.outputCache = outputCache;
+    this._dag = dag || new TaskGraphDAG;
+  }
+  _dag;
+  _runner;
+  get runner() {
+    if (!this._runner) {
+      this._runner = new TaskGraphRunner(this, this.outputCache);
+    }
+    return this._runner;
+  }
+  run(input = {}, config = {}) {
+    return this.runner.runGraph(input, {
+      outputCache: config?.outputCache || this.outputCache,
+      parentSignal: config?.parentSignal || undefined,
+      accumulateLeafOutputs: config?.accumulateLeafOutputs,
+      registry: config?.registry
+    });
+  }
+  runReactive(input = {}, config = {}) {
+    return this.runner.runGraphReactive(input, config);
+  }
+  mergeExecuteOutputsToRunOutput(results, compoundMerge) {
+    return this.runner.mergeExecuteOutputsToRunOutput(results, compoundMerge);
+  }
+  abort() {
+    this.runner.abort();
+  }
+  async disable() {
+    await this.runner.disable();
+  }
+  getTask(id) {
+    return this._dag.getNode(id);
+  }
+  getTasks() {
+    return this._dag.getNodes();
+  }
+  topologicallySortedNodes() {
+    return this._dag.topologicallySortedNodes();
+  }
+  addTask(task, config) {
+    return this._dag.addNode(ensureTask(task, config));
+  }
+  addTasks(tasks) {
+    return this._dag.addNodes(tasks.map(ensureTask));
+  }
+  addDataflow(dataflow) {
+    return this._dag.addEdge(dataflow.sourceTaskId, dataflow.targetTaskId, dataflow);
+  }
+  addDataflows(dataflows) {
+    const addedEdges = dataflows.map((edge) => {
+      return [edge.sourceTaskId, edge.targetTaskId, edge];
+    });
+    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;
+            }
+          }
+        }
+      }
+    }
+  }
+  getDataflows() {
+    return this._dag.getEdges().map((edge) => edge[2]);
+  }
+  removeDataflow(dataflow) {
+    return this._dag.removeEdge(dataflow.sourceTaskId, dataflow.targetTaskId, dataflow.id);
+  }
+  getSourceDataflows(taskId) {
+    return this._dag.inEdges(taskId).map(([, , dataflow]) => dataflow);
+  }
+  getTargetDataflows(taskId) {
+    return this._dag.outEdges(taskId).map(([, , dataflow]) => dataflow);
+  }
+  getSourceTasks(taskId) {
+    return this.getSourceDataflows(taskId).map((dataflow) => this.getTask(dataflow.sourceTaskId));
+  }
+  getTargetTasks(taskId) {
+    return this.getTargetDataflows(taskId).map((dataflow) => this.getTask(dataflow.targetTaskId));
+  }
+  removeTask(taskId) {
+    return this._dag.removeNode(taskId);
+  }
+  resetGraph() {
+    this.runner.resetGraph(this, uuid44());
+  }
+  toJSON(options) {
+    const tasks = this.getTasks().map((node) => node.toJSON(options));
+    const dataflows = this.getDataflows().map((df) => df.toJSON());
+    let json = {
+      tasks,
+      dataflows
+    };
+    if (options?.withBoundaryNodes) {
+      json = addBoundaryNodesToGraphJson(json, this);
+    }
+    return json;
+  }
+  toDependencyJSON(options) {
+    const tasks = this.getTasks().flatMap((node) => node.toDependencyJSON(options));
+    this.getDataflows().forEach((df) => {
+      const target = tasks.find((node) => node.id === df.targetTaskId);
+      if (!target.dependencies) {
+        target.dependencies = {};
+      }
+      const targetDeps = target.dependencies[df.targetTaskPortId];
+      if (!targetDeps) {
+        target.dependencies[df.targetTaskPortId] = {
+          id: df.sourceTaskId,
+          output: df.sourceTaskPortId
+        };
+      } else {
+        if (Array.isArray(targetDeps)) {
+          targetDeps.push({
+            id: df.sourceTaskId,
+            output: df.sourceTaskPortId
+          });
+        } else {
+          target.dependencies[df.targetTaskPortId] = [
+            targetDeps,
+            { id: df.sourceTaskId, output: df.sourceTaskPortId }
+          ];
+        }
+      }
+    });
+    if (options?.withBoundaryNodes) {
+      return addBoundaryNodesToDependencyJson(tasks, this);
+    }
+    return tasks;
+  }
+  get events() {
+    if (!this._events) {
+      this._events = new EventEmitter4;
+    }
+    return this._events;
+  }
+  _events;
+  subscribe(name, fn) {
+    this.on(name, fn);
+    return () => this.off(name, fn);
+  }
+  subscribeToTaskStatus(callback) {
+    const unsubscribes = [];
+    const tasks = this.getTasks();
+    tasks.forEach((task) => {
+      const unsub = task.subscribe("status", (status) => {
+        callback(task.id, status);
+      });
+      unsubscribes.push(unsub);
+    });
+    const handleTaskAdded = (taskId) => {
+      const task = this.getTask(taskId);
+      if (!task || typeof task.subscribe !== "function")
+        return;
+      const unsub = task.subscribe("status", (status) => {
+        callback(task.id, status);
+      });
+      unsubscribes.push(unsub);
+    };
+    const graphUnsub = this.subscribe("task_added", handleTaskAdded);
+    unsubscribes.push(graphUnsub);
+    return () => {
+      unsubscribes.forEach((unsub) => unsub());
+    };
+  }
+  subscribeToTaskProgress(callback) {
+    const unsubscribes = [];
+    const tasks = this.getTasks();
+    tasks.forEach((task) => {
+      const unsub = task.subscribe("progress", (progress, message, ...args) => {
+        callback(task.id, progress, message, ...args);
+      });
+      unsubscribes.push(unsub);
+    });
+    const handleTaskAdded = (taskId) => {
+      const task = this.getTask(taskId);
+      if (!task || typeof task.subscribe !== "function")
+        return;
+      const unsub = task.subscribe("progress", (progress, message, ...args) => {
+        callback(task.id, progress, message, ...args);
+      });
+      unsubscribes.push(unsub);
+    };
+    const graphUnsub = this.subscribe("task_added", handleTaskAdded);
+    unsubscribes.push(graphUnsub);
+    return () => {
+      unsubscribes.forEach((unsub) => unsub());
+    };
+  }
+  subscribeToDataflowStatus(callback) {
+    const unsubscribes = [];
+    const dataflows = this.getDataflows();
+    dataflows.forEach((dataflow) => {
+      const unsub = dataflow.subscribe("status", (status) => {
+        callback(dataflow.id, status);
+      });
+      unsubscribes.push(unsub);
+    });
+    const handleDataflowAdded = (dataflowId) => {
+      const dataflow = this.getDataflow(dataflowId);
+      if (!dataflow || typeof dataflow.subscribe !== "function")
+        return;
+      const unsub = dataflow.subscribe("status", (status) => {
+        callback(dataflow.id, status);
+      });
+      unsubscribes.push(unsub);
+    };
+    const graphUnsub = this.subscribe("dataflow_added", handleDataflowAdded);
+    unsubscribes.push(graphUnsub);
+    return () => {
+      unsubscribes.forEach((unsub) => unsub());
+    };
+  }
+  subscribeToTaskStreaming(callbacks) {
+    const unsubscribes = [];
+    if (callbacks.onStreamStart) {
+      const unsub = this.subscribe("task_stream_start", callbacks.onStreamStart);
+      unsubscribes.push(unsub);
+    }
+    if (callbacks.onStreamChunk) {
+      const unsub = this.subscribe("task_stream_chunk", callbacks.onStreamChunk);
+      unsubscribes.push(unsub);
+    }
+    if (callbacks.onStreamEnd) {
+      const unsub = this.subscribe("task_stream_end", callbacks.onStreamEnd);
+      unsubscribes.push(unsub);
+    }
+    return () => {
+      unsubscribes.forEach((unsub) => unsub());
+    };
+  }
+  on(name, fn) {
+    const dagEvent = EventTaskGraphToDagMapping[name];
+    if (dagEvent) {
+      return this._dag.on(dagEvent, fn);
+    }
+    return this.events.on(name, fn);
+  }
+  off(name, fn) {
+    const dagEvent = EventTaskGraphToDagMapping[name];
+    if (dagEvent) {
+      return this._dag.off(dagEvent, fn);
+    }
+    return this.events.off(name, fn);
+  }
+  emit(name, ...args) {
+    const dagEvent = EventTaskGraphToDagMapping[name];
+    if (dagEvent) {
+      return this.emit_dag(name, ...args);
+    } else {
+      return this.emit_local(name, ...args);
+    }
+  }
+  emit_local(name, ...args) {
+    return this.events?.emit(name, ...args);
+  }
+  emit_dag(name, ...args) {
+    const dagEvent = EventTaskGraphToDagMapping[name];
+    return this._dag.emit(dagEvent, ...args);
+  }
+}
+function serialGraphEdges(tasks, inputHandle, outputHandle) {
+  const edges = [];
+  for (let i = 0;i < tasks.length - 1; i++) {
+    edges.push(new Dataflow(tasks[i].id, inputHandle, tasks[i + 1].id, outputHandle));
+  }
+  return edges;
+}
+function serialGraph(tasks, inputHandle, outputHandle) {
+  const graph = new TaskGraph;
+  graph.addTasks(tasks);
+  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();
@@ -88,7 +3501,786 @@ init_Conversions();
 
 // src/task-graph/GraphToWorkflowCode.ts
 init_Dataflow();
-init_Workflow();
+
+// src/task-graph/Workflow.ts
+init_GraphAsTask();
+init_StreamTypes();
+init_TaskError();
+init_Conversions();
+init_Dataflow();
+init_TaskGraph();
+init_TaskGraphRunner();
+import {
+  EventEmitter as EventEmitter5,
+  getLogger as getLogger3,
+  uuid4 as uuid45
+} from "@workglow/util";
+function getLastTask(workflow) {
+  const tasks = workflow.graph.getTasks();
+  return tasks.length > 0 ? tasks[tasks.length - 1] : undefined;
+}
+function connect(source, target, workflow) {
+  workflow.graph.addDataflow(new Dataflow(source.id, "*", target.id, "*"));
+}
+function pipe(args, workflow = new Workflow) {
+  let previousTask = getLastTask(workflow);
+  const tasks = args.map((arg) => ensureTask(arg));
+  tasks.forEach((task) => {
+    workflow.graph.addTask(task);
+    if (previousTask) {
+      connect(previousTask, task, workflow);
+    }
+    previousTask = task;
+  });
+  return workflow;
+}
+function parallel(args, mergeFn = PROPERTY_ARRAY, workflow = new Workflow) {
+  let previousTask = getLastTask(workflow);
+  const tasks = args.map((arg) => ensureTask(arg));
+  const input = {};
+  const config = {
+    compoundMerge: mergeFn
+  };
+  const name = `‖${args.map((arg) => "\uD835\uDC53").join("‖")}‖`;
+
+  class ParallelTask extends GraphAsTask {
+    static type = name;
+  }
+  const mergeTask = new ParallelTask(input, config);
+  mergeTask.subGraph.addTasks(tasks);
+  workflow.graph.addTask(mergeTask);
+  if (previousTask) {
+    connect(previousTask, mergeTask, workflow);
+  }
+  return workflow;
+}
+function CreateWorkflow(taskClass) {
+  return Workflow.createWorkflow(taskClass);
+}
+function CreateLoopWorkflow(taskClass) {
+  return function(config = {}) {
+    return this.addLoopTask(taskClass, config);
+  };
+}
+function CreateEndLoopWorkflow(methodName) {
+  return function() {
+    if (!this.isLoopBuilder) {
+      throw new Error(`${methodName}() can only be called on loop workflows`);
+    }
+    return this.finalizeAndReturn();
+  };
+}
+var TYPED_ARRAY_FORMAT_PREFIX = "TypedArray";
+function schemaHasTypedArrayFormat(schema) {
+  if (typeof schema === "boolean")
+    return false;
+  if (!schema || typeof schema !== "object" || Array.isArray(schema))
+    return false;
+  const s = schema;
+  if (typeof s.format === "string" && s.format.startsWith(TYPED_ARRAY_FORMAT_PREFIX)) {
+    return true;
+  }
+  const checkUnion = (schemas) => {
+    if (!Array.isArray(schemas))
+      return false;
+    return schemas.some((sub) => schemaHasTypedArrayFormat(sub));
+  };
+  if (checkUnion(s.oneOf) || checkUnion(s.anyOf))
+    return true;
+  const items = s.items;
+  if (items && typeof items === "object" && !Array.isArray(items)) {
+    if (schemaHasTypedArrayFormat(items))
+      return true;
+  }
+  return false;
+}
+function hasVectorOutput(task) {
+  const outputSchema = task.outputSchema();
+  if (typeof outputSchema === "boolean" || !outputSchema?.properties)
+    return false;
+  return Object.values(outputSchema.properties).some((prop) => schemaHasTypedArrayFormat(prop));
+}
+function hasVectorLikeInput(input) {
+  if (!input || typeof input !== "object")
+    return false;
+  const v = input.vectors;
+  return Array.isArray(v) && v.length > 0 && typeof v[0] === "object" && v[0] !== null && ArrayBuffer.isView(v[0]);
+}
+function CreateAdaptiveWorkflow(scalarClass, vectorClass) {
+  const scalarHelper = Workflow.createWorkflow(scalarClass);
+  const vectorHelper = Workflow.createWorkflow(vectorClass);
+  return function(input = {}, config = {}) {
+    const parent = getLastTask(this);
+    const useVector = parent !== undefined && hasVectorOutput(parent) || hasVectorLikeInput(input);
+    if (useVector) {
+      return vectorHelper.call(this, input, config);
+    }
+    return scalarHelper.call(this, input, config);
+  };
+}
+
+class WorkflowTask extends GraphAsTask {
+  static type = "Workflow";
+  static compoundMerge = PROPERTY_ARRAY;
+}
+
+class Workflow {
+  constructor(cache, parent, iteratorTask) {
+    this._outputCache = cache;
+    this._parentWorkflow = parent;
+    this._iteratorTask = iteratorTask;
+    this._graph = new TaskGraph({ outputCache: this._outputCache });
+    if (!parent) {
+      this._onChanged = this._onChanged.bind(this);
+      this.setupEvents();
+    }
+  }
+  _graph;
+  _dataFlows = [];
+  _error = "";
+  _outputCache;
+  _abortController;
+  _parentWorkflow;
+  _iteratorTask;
+  _pendingLoopConnect;
+  outputCache() {
+    return this._outputCache;
+  }
+  get isLoopBuilder() {
+    return this._parentWorkflow !== undefined;
+  }
+  events = new EventEmitter5;
+  static createWorkflow(taskClass) {
+    const helper = function(input = {}, config = {}) {
+      this._error = "";
+      const parent = getLastTask(this);
+      const task = this.addTaskToGraph(taskClass, input, { id: uuid45(), ...config });
+      if (this._dataFlows.length > 0) {
+        this._dataFlows.forEach((dataflow) => {
+          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);
+            return;
+          }
+          dataflow.targetTaskId = task.id;
+          this.graph.addDataflow(dataflow);
+        });
+        this._dataFlows = [];
+      }
+      if (parent) {
+        const nodes = this._graph.getTasks();
+        const parentIndex = nodes.findIndex((n) => n.id === parent.id);
+        const earlierTasks = [];
+        for (let i = parentIndex - 1;i >= 0; i--) {
+          earlierTasks.push(nodes[i]);
+        }
+        const providedInputKeys = new Set(Object.keys(input || {}));
+        const connectedInputKeys = new Set(this.graph.getSourceDataflows(task.id).map((df) => df.targetTaskPortId));
+        const result = Workflow.autoConnect(this.graph, parent, task, {
+          providedInputKeys,
+          connectedInputKeys,
+          earlierTasks
+        });
+        if (result.error) {
+          if (this.isLoopBuilder) {
+            this._error = result.error;
+            getLogger3().warn(this._error);
+          } else {
+            this._error = result.error + " Task not added.";
+            getLogger3().error(this._error);
+            this.graph.removeTask(task.id);
+          }
+        }
+      }
+      if (!this._error) {
+        Workflow.updateBoundaryTaskSchemas(this._graph);
+      }
+      return this;
+    };
+    helper.type = taskClass.runtype ?? taskClass.type;
+    helper.category = taskClass.category;
+    helper.inputSchema = taskClass.inputSchema;
+    helper.outputSchema = taskClass.outputSchema;
+    helper.cacheable = taskClass.cacheable;
+    helper.workflowCreate = true;
+    return helper;
+  }
+  get graph() {
+    return this._graph;
+  }
+  set graph(value) {
+    this._dataFlows = [];
+    this._error = "";
+    this.clearEvents();
+    this._graph = value;
+    this.setupEvents();
+    this.events.emit("reset");
+  }
+  get error() {
+    return this._error;
+  }
+  on(name, fn) {
+    this.events.on(name, fn);
+  }
+  off(name, fn) {
+    this.events.off(name, fn);
+  }
+  once(name, fn) {
+    this.events.once(name, fn);
+  }
+  waitOn(name) {
+    return this.events.waitOn(name);
+  }
+  async run(input = {}, config) {
+    if (this.isLoopBuilder) {
+      this.finalizeTemplate();
+      if (this._pendingLoopConnect) {
+        this._parentWorkflow.autoConnectLoopTask(this._pendingLoopConnect);
+        this._pendingLoopConnect = undefined;
+      }
+      return this._parentWorkflow.run(input, config);
+    }
+    this.events.emit("start");
+    this._abortController = new AbortController;
+    const unsubStreaming = this.graph.subscribeToTaskStreaming({
+      onStreamStart: (taskId) => this.events.emit("stream_start", taskId),
+      onStreamChunk: (taskId, event) => this.events.emit("stream_chunk", taskId, event),
+      onStreamEnd: (taskId, output) => this.events.emit("stream_end", taskId, output)
+    });
+    try {
+      const output = await this.graph.run(input, {
+        parentSignal: this._abortController.signal,
+        outputCache: this._outputCache,
+        registry: config?.registry
+      });
+      const results = this.graph.mergeExecuteOutputsToRunOutput(output, PROPERTY_ARRAY);
+      this.events.emit("complete");
+      return results;
+    } catch (error) {
+      this.events.emit("error", String(error));
+      throw error;
+    } finally {
+      unsubStreaming();
+      this._abortController = undefined;
+    }
+  }
+  async abort() {
+    if (this._parentWorkflow) {
+      return this._parentWorkflow.abort();
+    }
+    this._abortController?.abort();
+  }
+  pop() {
+    this._error = "";
+    const nodes = this._graph.getTasks();
+    if (nodes.length === 0) {
+      this._error = "No tasks to remove";
+      getLogger3().error(this._error);
+      return this;
+    }
+    const lastNode = nodes[nodes.length - 1];
+    this._graph.removeTask(lastNode.id);
+    return this;
+  }
+  toJSON(options = { withBoundaryNodes: true }) {
+    return this._graph.toJSON(options);
+  }
+  toDependencyJSON(options = { withBoundaryNodes: true }) {
+    return this._graph.toDependencyJSON(options);
+  }
+  pipe(...args) {
+    return pipe(args, this);
+  }
+  static pipe(...args) {
+    return pipe(args, new Workflow);
+  }
+  parallel(args, mergeFn) {
+    return parallel(args, mergeFn ?? PROPERTY_ARRAY, this);
+  }
+  static parallel(args, mergeFn) {
+    return parallel(args, mergeFn ?? PROPERTY_ARRAY, new Workflow);
+  }
+  rename(source, target, index = -1) {
+    this._error = "";
+    const nodes = this._graph.getTasks();
+    if (-index > nodes.length) {
+      const errorMsg = `Back index greater than number of tasks`;
+      this._error = errorMsg;
+      getLogger3().error(this._error);
+      throw new WorkflowError(errorMsg);
+    }
+    const lastNode = nodes[nodes.length + index];
+    const outputSchema = lastNode.outputSchema();
+    if (typeof outputSchema === "boolean") {
+      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);
+        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);
+      throw new WorkflowError(errorMsg);
+    }
+    this._dataFlows.push(new Dataflow(lastNode.id, source, undefined, target));
+    return this;
+  }
+  onError(handler) {
+    this._error = "";
+    const parent = getLastTask(this);
+    if (!parent) {
+      this._error = "onError() requires a preceding task in the workflow";
+      getLogger3().error(this._error);
+      throw new WorkflowError(this._error);
+    }
+    const handlerTask = ensureTask(handler);
+    this.graph.addTask(handlerTask);
+    const dataflow = new Dataflow(parent.id, DATAFLOW_ERROR_PORT, handlerTask.id, DATAFLOW_ALL_PORTS);
+    this.graph.addDataflow(dataflow);
+    this.events.emit("changed", handlerTask.id);
+    return this;
+  }
+  toTaskGraph() {
+    return this._graph;
+  }
+  toTask() {
+    const task = new WorkflowTask;
+    task.subGraph = this.toTaskGraph();
+    return task;
+  }
+  reset() {
+    if (this._parentWorkflow) {
+      throw new WorkflowError("Cannot reset a loop workflow. Call reset() on the parent workflow.");
+    }
+    this.clearEvents();
+    this._graph = new TaskGraph({
+      outputCache: this._outputCache
+    });
+    this._dataFlows = [];
+    this._error = "";
+    this.setupEvents();
+    this.events.emit("changed", undefined);
+    this.events.emit("reset");
+    return this;
+  }
+  setupEvents() {
+    this._graph.on("task_added", this._onChanged);
+    this._graph.on("task_replaced", this._onChanged);
+    this._graph.on("task_removed", this._onChanged);
+    this._graph.on("dataflow_added", this._onChanged);
+    this._graph.on("dataflow_replaced", this._onChanged);
+    this._graph.on("dataflow_removed", this._onChanged);
+  }
+  clearEvents() {
+    this._graph.off("task_added", this._onChanged);
+    this._graph.off("task_replaced", this._onChanged);
+    this._graph.off("task_removed", this._onChanged);
+    this._graph.off("dataflow_added", this._onChanged);
+    this._graph.off("dataflow_replaced", this._onChanged);
+    this._graph.off("dataflow_removed", this._onChanged);
+  }
+  _onChanged(id) {
+    this.events.emit("changed", id);
+  }
+  connect(sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId) {
+    const sourceTask = this.graph.getTask(sourceTaskId);
+    const targetTask = this.graph.getTask(targetTaskId);
+    if (!sourceTask || !targetTask) {
+      throw new WorkflowError("Source or target task not found");
+    }
+    const sourceSchema = sourceTask.outputSchema();
+    const targetSchema = targetTask.inputSchema();
+    if (typeof sourceSchema === "boolean") {
+      if (sourceSchema === false) {
+        throw new WorkflowError(`Source task has schema 'false' and outputs nothing`);
+      }
+    } else if (!sourceSchema.properties?.[sourceTaskPortId]) {
+      throw new WorkflowError(`Output ${sourceTaskPortId} not found on source task`);
+    }
+    if (typeof targetSchema === "boolean") {
+      if (targetSchema === false) {
+        throw new WorkflowError(`Target task has schema 'false' and accepts no inputs`);
+      }
+      if (targetSchema === true) {}
+    } else if (targetSchema.additionalProperties === true) {} else if (!targetSchema.properties?.[targetTaskPortId]) {
+      throw new WorkflowError(`Input ${targetTaskPortId} not found on target task`);
+    }
+    const dataflow = new Dataflow(sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId);
+    this.graph.addDataflow(dataflow);
+    return this;
+  }
+  addTaskToGraph(taskClass, input, config) {
+    const task = new taskClass(input, config);
+    const id = this.graph.addTask(task);
+    this.events.emit("changed", id);
+    return task;
+  }
+  addTask(taskClass, input, config) {
+    const helper = Workflow.createWorkflow(taskClass);
+    return helper.call(this, input, config);
+  }
+  addLoopTask(taskClass, config = {}) {
+    this._error = "";
+    const parent = getLastTask(this);
+    const task = this.addTaskToGraph(taskClass, {}, { id: uuid45(), ...config });
+    if (this._dataFlows.length > 0) {
+      this._dataFlows.forEach((dataflow) => {
+        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);
+          return;
+        }
+        dataflow.targetTaskId = task.id;
+        this.graph.addDataflow(dataflow);
+      });
+      this._dataFlows = [];
+    }
+    const loopBuilder = new Workflow(this.outputCache(), this, task);
+    if (parent) {
+      loopBuilder._pendingLoopConnect = { parent, iteratorTask: task };
+    }
+    return loopBuilder;
+  }
+  autoConnectLoopTask(pending) {
+    if (!pending)
+      return;
+    const { parent, iteratorTask } = pending;
+    if (this.graph.getTargetDataflows(parent.id).length === 0) {
+      const nodes = this._graph.getTasks();
+      const parentIndex = nodes.findIndex((n) => n.id === parent.id);
+      const earlierTasks = [];
+      for (let i = parentIndex - 1;i >= 0; i--) {
+        earlierTasks.push(nodes[i]);
+      }
+      const result = Workflow.autoConnect(this.graph, parent, iteratorTask, {
+        earlierTasks
+      });
+      if (result.error) {
+        this._error = result.error + " Task not added.";
+        getLogger3().error(this._error);
+        this.graph.removeTask(iteratorTask.id);
+      }
+    }
+  }
+  static updateBoundaryTaskSchemas(graph) {
+    const tasks = graph.getTasks();
+    for (const task of tasks) {
+      if (task.type === "InputTask") {
+        const existingConfig = task.config;
+        const existingSchema = existingConfig?.inputSchema ?? existingConfig?.outputSchema;
+        if (existingSchema && typeof existingSchema === "object" && existingSchema["x-ui-manual"] === true) {
+          continue;
+        }
+        const outgoing = graph.getTargetDataflows(task.id);
+        if (outgoing.length === 0)
+          continue;
+        const properties = {};
+        const required = [];
+        for (const df of outgoing) {
+          const targetTask = graph.getTask(df.targetTaskId);
+          if (!targetTask)
+            continue;
+          const targetSchema = targetTask.inputSchema();
+          if (typeof targetSchema === "boolean")
+            continue;
+          const prop = targetSchema.properties?.[df.targetTaskPortId];
+          if (prop && typeof prop !== "boolean") {
+            properties[df.sourceTaskPortId] = prop;
+            if (targetSchema.required?.includes(df.targetTaskPortId)) {
+              if (!required.includes(df.sourceTaskPortId)) {
+                required.push(df.sourceTaskPortId);
+              }
+            }
+          }
+        }
+        const schema = {
+          type: "object",
+          properties,
+          ...required.length > 0 ? { required } : {},
+          additionalProperties: false
+        };
+        task.config = {
+          ...task.config,
+          inputSchema: schema,
+          outputSchema: schema
+        };
+      }
+      if (task.type === "OutputTask") {
+        const incoming = graph.getSourceDataflows(task.id);
+        if (incoming.length === 0)
+          continue;
+        const properties = {};
+        const required = [];
+        for (const df of incoming) {
+          const sourceTask = graph.getTask(df.sourceTaskId);
+          if (!sourceTask)
+            continue;
+          const sourceSchema = sourceTask.outputSchema();
+          if (typeof sourceSchema === "boolean")
+            continue;
+          const prop = sourceSchema.properties?.[df.sourceTaskPortId];
+          if (prop && typeof prop !== "boolean") {
+            properties[df.targetTaskPortId] = prop;
+            if (sourceSchema.required?.includes(df.sourceTaskPortId) && !required.includes(df.targetTaskPortId)) {
+              required.push(df.targetTaskPortId);
+            }
+          }
+        }
+        const schema = {
+          type: "object",
+          properties,
+          ...required.length > 0 ? { required } : {},
+          additionalProperties: false
+        };
+        task.config = {
+          ...task.config,
+          inputSchema: schema,
+          outputSchema: schema
+        };
+      }
+    }
+  }
+  static AutoConnectOptions = Symbol("AutoConnectOptions");
+  static autoConnect(graph, sourceTask, targetTask, options) {
+    const matches = new Map;
+    const sourceSchema = sourceTask.outputSchema();
+    const targetSchema = targetTask.inputSchema();
+    const providedInputKeys = options?.providedInputKeys ?? new Set;
+    const connectedInputKeys = options?.connectedInputKeys ?? new Set;
+    const earlierTasks = options?.earlierTasks ?? [];
+    const getSpecificTypeIdentifiers = (schema) => {
+      const formats = new Set;
+      const ids = new Set;
+      if (typeof schema === "boolean") {
+        return { formats, ids };
+      }
+      const extractFromSchema = (s) => {
+        if (!s || typeof s !== "object" || Array.isArray(s))
+          return;
+        if (s.format)
+          formats.add(s.format);
+        if (s.$id)
+          ids.add(s.$id);
+      };
+      extractFromSchema(schema);
+      const checkUnion = (schemas) => {
+        if (!schemas)
+          return;
+        for (const s of schemas) {
+          if (typeof s === "boolean")
+            continue;
+          extractFromSchema(s);
+          if (s.items && typeof s.items === "object" && !Array.isArray(s.items)) {
+            extractFromSchema(s.items);
+          }
+        }
+      };
+      checkUnion(schema.oneOf);
+      checkUnion(schema.anyOf);
+      if (schema.items && typeof schema.items === "object" && !Array.isArray(schema.items)) {
+        extractFromSchema(schema.items);
+      }
+      return { formats, ids };
+    };
+    const isTypeCompatible = (fromPortOutputSchema, toPortInputSchema, requireSpecificType = false) => {
+      if (typeof fromPortOutputSchema === "boolean" || typeof toPortInputSchema === "boolean") {
+        return fromPortOutputSchema === true && toPortInputSchema === true;
+      }
+      const outputIds = getSpecificTypeIdentifiers(fromPortOutputSchema);
+      const inputIds = getSpecificTypeIdentifiers(toPortInputSchema);
+      for (const format of outputIds.formats) {
+        if (inputIds.formats.has(format)) {
+          return true;
+        }
+      }
+      for (const id of outputIds.ids) {
+        if (inputIds.ids.has(id)) {
+          return true;
+        }
+      }
+      if (requireSpecificType) {
+        return false;
+      }
+      const idTypeBlank = fromPortOutputSchema.$id === undefined && toPortInputSchema.$id === undefined;
+      if (!idTypeBlank)
+        return false;
+      if (fromPortOutputSchema.type === toPortInputSchema.type)
+        return true;
+      const matchesOneOf = toPortInputSchema.oneOf?.some((schema) => {
+        if (typeof schema === "boolean")
+          return schema;
+        return schema.type === fromPortOutputSchema.type;
+      }) ?? false;
+      const matchesAnyOf = toPortInputSchema.anyOf?.some((schema) => {
+        if (typeof schema === "boolean")
+          return schema;
+        return schema.type === fromPortOutputSchema.type;
+      }) ?? false;
+      return matchesOneOf || matchesAnyOf;
+    };
+    const makeMatch = (fromSchema, toSchema, fromTaskId, toTaskId, comparator) => {
+      if (typeof fromSchema === "object") {
+        if (toSchema === true || typeof toSchema === "object" && toSchema.additionalProperties === true) {
+          for (const fromOutputPortId of Object.keys(fromSchema.properties || {})) {
+            if (matches.has(fromOutputPortId))
+              continue;
+            matches.set(fromOutputPortId, fromOutputPortId);
+            graph.addDataflow(new Dataflow(fromTaskId, fromOutputPortId, toTaskId, fromOutputPortId));
+          }
+          return;
+        }
+      }
+      if (typeof fromSchema === "object" && fromSchema.additionalProperties === true && typeof toSchema === "object" && (sourceTask.type === "InputTask" || sourceTask.type === "OutputTask")) {
+        for (const toInputPortId of Object.keys(toSchema.properties || {})) {
+          if (matches.has(toInputPortId))
+            continue;
+          if (connectedInputKeys.has(toInputPortId))
+            continue;
+          matches.set(toInputPortId, toInputPortId);
+          graph.addDataflow(new Dataflow(fromTaskId, toInputPortId, toTaskId, toInputPortId));
+        }
+        return;
+      }
+      if (typeof fromSchema === "boolean" || typeof toSchema === "boolean") {
+        return;
+      }
+      for (const [toInputPortId, toPortInputSchema] of Object.entries(toSchema.properties || {})) {
+        if (matches.has(toInputPortId))
+          continue;
+        if (connectedInputKeys.has(toInputPortId))
+          continue;
+        const candidates = [];
+        for (const [fromOutputPortId, fromPortOutputSchema] of Object.entries(fromSchema.properties || {})) {
+          if (comparator([fromOutputPortId, fromPortOutputSchema], [toInputPortId, toPortInputSchema])) {
+            candidates.push(fromOutputPortId);
+          }
+        }
+        if (candidates.length === 0)
+          continue;
+        let winner = candidates[0];
+        if (candidates.length > 1) {
+          const targetStreamMode = getPortStreamMode(toSchema, toInputPortId);
+          const streamMatch = candidates.find((portId) => getPortStreamMode(fromSchema, portId) === targetStreamMode);
+          if (streamMatch)
+            winner = streamMatch;
+        }
+        matches.set(toInputPortId, winner);
+        graph.addDataflow(new Dataflow(fromTaskId, winner, toTaskId, toInputPortId));
+      }
+    };
+    makeMatch(sourceSchema, targetSchema, sourceTask.id, targetTask.id, ([fromOutputPortId, fromPortOutputSchema], [toInputPortId, toPortInputSchema]) => {
+      const outputPortIdMatch = fromOutputPortId === toInputPortId;
+      const outputPortIdOutputInput = fromOutputPortId === "output" && toInputPortId === "input";
+      const portIdsCompatible = outputPortIdMatch || outputPortIdOutputInput;
+      return portIdsCompatible && isTypeCompatible(fromPortOutputSchema, toPortInputSchema, false);
+    });
+    makeMatch(sourceSchema, targetSchema, sourceTask.id, targetTask.id, ([_fromOutputPortId, fromPortOutputSchema], [_toInputPortId, toPortInputSchema]) => {
+      return isTypeCompatible(fromPortOutputSchema, toPortInputSchema, true);
+    });
+    const requiredInputs = new Set(typeof targetSchema === "object" ? targetSchema.required || [] : []);
+    const requiredInputsNeedingConnection = [...requiredInputs].filter((r) => !providedInputKeys.has(r) && !connectedInputKeys.has(r));
+    let unmatchedRequired = requiredInputsNeedingConnection.filter((r) => !matches.has(r));
+    if (unmatchedRequired.length > 0 && earlierTasks.length > 0) {
+      for (let i = 0;i < earlierTasks.length && unmatchedRequired.length > 0; i++) {
+        const earlierTask = earlierTasks[i];
+        const earlierOutputSchema = earlierTask.outputSchema();
+        if (earlierTask.type === "InputTask") {
+          const inputConfig = earlierTask.config;
+          const inputSchema = inputConfig?.inputSchema ?? inputConfig?.outputSchema;
+          const isManualSchema = inputSchema && typeof inputSchema === "object" && inputSchema["x-ui-manual"] === true;
+          const inputProperties = isManualSchema && inputSchema && typeof inputSchema === "object" && "properties" in inputSchema && inputSchema.properties && typeof inputSchema.properties === "object" ? new Set(Object.keys(inputSchema.properties)) : undefined;
+          for (const requiredInputId of [...unmatchedRequired]) {
+            if (matches.has(requiredInputId))
+              continue;
+            if (inputProperties && !inputProperties.has(requiredInputId))
+              continue;
+            matches.set(requiredInputId, requiredInputId);
+            graph.addDataflow(new Dataflow(earlierTask.id, requiredInputId, targetTask.id, requiredInputId));
+          }
+          unmatchedRequired = unmatchedRequired.filter((r) => !matches.has(r));
+          continue;
+        }
+        const makeMatchFromEarlier = (comparator) => {
+          if (typeof earlierOutputSchema === "boolean" || typeof targetSchema === "boolean") {
+            return;
+          }
+          for (const [fromOutputPortId, fromPortOutputSchema] of Object.entries(earlierOutputSchema.properties || {})) {
+            for (const requiredInputId of unmatchedRequired) {
+              const toPortInputSchema = targetSchema.properties?.[requiredInputId];
+              if (!matches.has(requiredInputId) && toPortInputSchema && comparator([fromOutputPortId, fromPortOutputSchema], [requiredInputId, toPortInputSchema])) {
+                matches.set(requiredInputId, fromOutputPortId);
+                graph.addDataflow(new Dataflow(earlierTask.id, fromOutputPortId, targetTask.id, requiredInputId));
+              }
+            }
+          }
+        };
+        makeMatchFromEarlier(([fromOutputPortId, fromPortOutputSchema], [toInputPortId, toPortInputSchema]) => {
+          const outputPortIdMatch = fromOutputPortId === toInputPortId;
+          const outputPortIdOutputInput = fromOutputPortId === "output" && toInputPortId === "input";
+          const portIdsCompatible = outputPortIdMatch || outputPortIdOutputInput;
+          return portIdsCompatible && isTypeCompatible(fromPortOutputSchema, toPortInputSchema, false);
+        });
+        makeMatchFromEarlier(([_fromOutputPortId, fromPortOutputSchema], [_toInputPortId, toPortInputSchema]) => {
+          return isTypeCompatible(fromPortOutputSchema, toPortInputSchema, true);
+        });
+        unmatchedRequired = unmatchedRequired.filter((r) => !matches.has(r));
+      }
+    }
+    const stillUnmatchedRequired = requiredInputsNeedingConnection.filter((r) => !matches.has(r));
+    if (stillUnmatchedRequired.length > 0) {
+      return {
+        matches,
+        error: `Could not find matches for required inputs [${stillUnmatchedRequired.join(", ")}] of ${targetTask.type}. ` + `Attempted to match from ${sourceTask.type} and earlier tasks.`,
+        unmatchedRequired: stillUnmatchedRequired
+      };
+    }
+    if (matches.size === 0 && requiredInputsNeedingConnection.length === 0) {
+      const existingTargetConnections = graph.getSourceDataflows(targetTask.id);
+      if (existingTargetConnections.length > 0) {
+        return { matches, unmatchedRequired: [] };
+      }
+      const hasRequiredInputs = requiredInputs.size > 0;
+      const allRequiredInputsProvided = hasRequiredInputs && [...requiredInputs].every((r) => providedInputKeys.has(r));
+      const hasInputsWithDefaults = typeof targetSchema === "object" && targetSchema.properties && Object.values(targetSchema.properties).some((prop) => prop && typeof prop === "object" && ("default" in prop));
+      if (!allRequiredInputsProvided && !hasInputsWithDefaults) {
+        return {
+          matches,
+          error: `Could not find a match between the outputs of ${sourceTask.type} and the inputs of ${targetTask.type}. ` + `You may need to connect the outputs to the inputs via connect() manually.`,
+          unmatchedRequired: []
+        };
+      }
+    }
+    return {
+      matches,
+      unmatchedRequired: []
+    };
+  }
+  finalizeTemplate() {
+    if (!this._iteratorTask || this.graph.getTasks().length === 0) {
+      return;
+    }
+    this._iteratorTask.subGraph = this.graph;
+  }
+  finalizeAndReturn() {
+    if (!this._parentWorkflow) {
+      throw new WorkflowError("finalizeAndReturn() can only be called on loop workflows");
+    }
+    this.finalizeTemplate();
+    if (this._pendingLoopConnect) {
+      this._parentWorkflow.autoConnectLoopTask(this._pendingLoopConnect);
+      this._pendingLoopConnect = undefined;
+    }
+    return this._parentWorkflow;
+  }
+}
+Workflow.prototype.group = CreateLoopWorkflow(GraphAsTask);
+Workflow.prototype.endGroup = CreateEndLoopWorkflow("endGroup");
+
+// src/task-graph/GraphToWorkflowCode.ts
 var methodNameCache;
 function getMethodNameMap() {
   if (methodNameCache)
@@ -409,16 +4601,11 @@ ${baseIndent}}`;
 function resetMethodNameCache() {
   methodNameCache = undefined;
 }
-
-// src/common.ts
-init_Workflow();
-
 // src/task/index.ts
 init_ConditionalTask();
 init_ConditionUtils();
 
 // src/task/FallbackTask.ts
-init_Workflow();
 init_GraphAsTask();
 
 // src/task/FallbackTaskRunner.ts
@@ -484,7 +4671,8 @@ class FallbackTaskRunner extends GraphAsTaskRunner {
         const mergedInput = { ...input, ...alternative };
         const results = await this.task.subGraph.run(mergedInput, {
           parentSignal: this.abortController?.signal,
-          outputCache: this.outputCache
+          outputCache: this.outputCache,
+          registry: this.registry
         });
         const mergedOutput = this.task.subGraph.mergeExecuteOutputsToRunOutput(results, this.task.compoundMerge);
         await this.handleProgress(100, `Data alternative ${attemptNumber}/${totalAttempts} succeeded`);
@@ -636,7 +4824,7 @@ init_GraphAsTask();
 init_Dataflow();
 init_TaskGraph();
 init_GraphAsTaskRunner();
-import { uuid4 } from "@workglow/util";
+import { uuid4 as uuid46 } from "@workglow/util";
 
 class IteratorTaskRunner extends GraphAsTaskRunner {
   async executeTask(input) {
@@ -731,7 +4919,7 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
     const idMap = new Map;
     for (const task of graph.getTasks()) {
       const ctor = task.constructor;
-      const newId = uuid4();
+      const newId = uuid46();
       idMap.set(task.config.id, newId);
       const clonedConfig = { ...task.config, id: newId };
       const newTask = new ctor(task.defaults, clonedConfig, task.runConfig);
@@ -752,7 +4940,8 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
     const graphClone = this.cloneGraph(this.task.subGraph);
     const results = await graphClone.run(input, {
       parentSignal: this.abortController?.signal,
-      outputCache: this.outputCache
+      outputCache: this.outputCache,
+      registry: this.registry
     });
     if (results.length === 0) {
       return;
@@ -1255,7 +5444,6 @@ class IteratorTask extends GraphAsTask {
 }
 
 // src/task/WhileTask.ts
-init_Workflow();
 init_ConditionUtils();
 init_GraphAsTask();
 init_TaskError();
@@ -1818,8 +6006,8 @@ import {
   JobQueueServer
 } from "@workglow/job-queue";
 import { InMemoryQueueStorage } from "@workglow/storage";
-import { createServiceToken, globalServiceRegistry } from "@workglow/util";
-var JOB_QUEUE_FACTORY = createServiceToken("taskgraph.jobQueueFactory");
+import { createServiceToken as createServiceToken2, globalServiceRegistry as globalServiceRegistry3 } from "@workglow/util";
+var JOB_QUEUE_FACTORY = createServiceToken2("taskgraph.jobQueueFactory");
 var defaultJobQueueFactory = async ({
   queueName,
   jobClass,
@@ -1846,7 +6034,7 @@ var defaultJobQueueFactory = async ({
   return { server, client, storage };
 };
 function registerJobQueueFactory(factory) {
-  globalServiceRegistry.registerInstance(JOB_QUEUE_FACTORY, factory);
+  globalServiceRegistry3.registerInstance(JOB_QUEUE_FACTORY, factory);
 }
 function createJobQueueFactoryWithOptions(defaultOptions = {}) {
   return async ({
@@ -1880,12 +6068,12 @@ function createJobQueueFactoryWithOptions(defaultOptions = {}) {
   };
 }
 function getJobQueueFactory() {
-  if (!globalServiceRegistry.has(JOB_QUEUE_FACTORY)) {
+  if (!globalServiceRegistry3.has(JOB_QUEUE_FACTORY)) {
     registerJobQueueFactory(defaultJobQueueFactory);
   }
-  return globalServiceRegistry.get(JOB_QUEUE_FACTORY);
+  return globalServiceRegistry3.get(JOB_QUEUE_FACTORY);
 }
-if (!globalServiceRegistry.has(JOB_QUEUE_FACTORY)) {
+if (!globalServiceRegistry3.has(JOB_QUEUE_FACTORY)) {
   registerJobQueueFactory(defaultJobQueueFactory);
 }
 // src/task/JobQueueTask.ts
@@ -2077,11 +6265,13 @@ class JobQueueTask extends GraphAsTask {
     }
     return registeredQueue;
   }
-  async abort() {
+  abort() {
     if (this.currentQueueName && this.currentJobId) {
       const registeredQueue = getTaskQueueRegistry().getQueue(this.currentQueueName);
       if (registeredQueue) {
-        await registeredQueue.client.abort(this.currentJobId);
+        registeredQueue.client.abort(this.currentJobId).catch((err) => {
+          console.warn(`Failed to abort remote job ${this.currentJobId}`, err);
+        });
       }
     }
     super.abort();
@@ -2164,13 +6354,9 @@ class MapTask extends IteratorTask {
     return flattened;
   }
 }
-queueMicrotask(async () => {
-  const { CreateLoopWorkflow: CreateLoopWorkflow3, CreateEndLoopWorkflow: CreateEndLoopWorkflow2, Workflow: Workflow2 } = await import("./Workflow-9m16vrgd.js");
-  Workflow2.prototype.map = CreateLoopWorkflow3(MapTask);
-  Workflow2.prototype.endMap = CreateEndLoopWorkflow2("endMap");
-});
+Workflow.prototype.map = CreateLoopWorkflow(MapTask);
+Workflow.prototype.endMap = CreateEndLoopWorkflow("endMap");
 // src/task/ReduceTask.ts
-init_Workflow();
 var reduceTaskConfigSchema = {
   type: "object",
   properties: {
@@ -2277,8 +6463,8 @@ init_TaskError();
 
 // src/task/TaskRegistry.ts
 import {
-  createServiceToken as createServiceToken2,
-  globalServiceRegistry as globalServiceRegistry2,
+  createServiceToken as createServiceToken3,
+  globalServiceRegistry as globalServiceRegistry4,
   registerInputResolver
 } from "@workglow/util";
 var taskConstructors = new Map;
@@ -2290,15 +6476,15 @@ var TaskRegistry = {
   all: taskConstructors,
   registerTask
 };
-var TASK_CONSTRUCTORS = createServiceToken2("task.constructors");
-if (!globalServiceRegistry2.has(TASK_CONSTRUCTORS)) {
-  globalServiceRegistry2.register(TASK_CONSTRUCTORS, () => TaskRegistry.all, true);
+var TASK_CONSTRUCTORS = createServiceToken3("task.constructors");
+if (!globalServiceRegistry4.has(TASK_CONSTRUCTORS)) {
+  globalServiceRegistry4.register(TASK_CONSTRUCTORS, () => TaskRegistry.all, true);
 }
 function getGlobalTaskConstructors() {
-  return globalServiceRegistry2.get(TASK_CONSTRUCTORS);
+  return globalServiceRegistry4.get(TASK_CONSTRUCTORS);
 }
 function setGlobalTaskConstructors(map) {
-  globalServiceRegistry2.registerInstance(TASK_CONSTRUCTORS, map);
+  globalServiceRegistry4.registerInstance(TASK_CONSTRUCTORS, map);
 }
 function getTaskConstructors(registry) {
   if (!registry)
@@ -2390,14 +6576,14 @@ var registerBaseTasks = () => {
   return tasks;
 };
 // src/storage/TaskGraphRepository.ts
-import { createServiceToken as createServiceToken3, EventEmitter } from "@workglow/util";
-var TASK_GRAPH_REPOSITORY = createServiceToken3("taskgraph.taskGraphRepository");
+import { createServiceToken as createServiceToken4, EventEmitter as EventEmitter6 } from "@workglow/util";
+var TASK_GRAPH_REPOSITORY = createServiceToken4("taskgraph.taskGraphRepository");
 
 class TaskGraphRepository {
   type = "TaskGraphRepository";
   get events() {
     if (!this._events) {
-      this._events = new EventEmitter;
+      this._events = new EventEmitter6;
     }
     return this._events;
   }
@@ -2676,4 +6862,4 @@ export {
   ConditionalTask
 };
 
-//# debugId=B8AC52FDAD1B8E0E64756E2164756E21
+//# debugId=A9666772B3E73EDB64756E2164756E21