@workglow/task-graph 0.0.115 → 0.0.116

package/dist/bun.js

@@ -1,4065 +1,432 @@
 // @bun
-// src/task-graph/Dataflow.ts
-import { areSemanticallyCompatible, EventEmitter } from "@workglow/util";
-
-// src/task/TaskTypes.ts
-var TaskStatus = {
-  PENDING: "PENDING",
-  DISABLED: "DISABLED",
-  PROCESSING: "PROCESSING",
-  STREAMING: "STREAMING",
-  COMPLETED: "COMPLETED",
-  ABORTING: "ABORTING",
-  FAILED: "FAILED"
-};
-var TaskConfigSchema = {
-  type: "object",
-  properties: {
-    id: {
-      "x-ui-hidden": true
-    },
-    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
-var DATAFLOW_ALL_PORTS = "*";
-var DATAFLOW_ERROR_PORT = "[error]";
-
-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);
-  }
-}
-
-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];
-}
-// src/task-graph/TaskGraph.ts
-import { DirectedAcyclicGraph, EventEmitter as EventEmitter5, uuid4 as uuid45 } from "@workglow/util";
-
-// src/task/GraphAsTask.ts
-import { compileSchema as compileSchema2 } from "@workglow/util";
-
-// src/task-graph/TaskGraphRunner.ts
-import {
-  collectPropertyValues,
-  getLogger as getLogger3,
-  globalServiceRegistry as globalServiceRegistry2,
-  ServiceRegistry as ServiceRegistry2,
-  uuid4 as uuid43
-} from "@workglow/util";
-
-// src/storage/TaskOutputRepository.ts
-import { createServiceToken, EventEmitter as EventEmitter2 } from "@workglow/util";
-var TASK_OUTPUT_REPOSITORY = createServiceToken("taskgraph.taskOutputRepository");
-
-class TaskOutputRepository {
-  outputCompression;
-  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);
-  }
-}
-
-// src/task/ConditionalTask.ts
-import { getLogger as getLogger2 } from "@workglow/util";
-
-// src/task/ConditionUtils.ts
-function evaluateCondition(fieldValue, operator, compareValue) {
-  if (fieldValue === null || fieldValue === undefined) {
-    switch (operator) {
-      case "is_empty":
-        return true;
-      case "is_not_empty":
-        return false;
-      case "is_true":
-        return false;
-      case "is_false":
-        return true;
-      default:
-        return false;
-    }
-  }
-  const strValue = String(fieldValue);
-  const numValue = Number(fieldValue);
-  switch (operator) {
-    case "equals":
-      if (!isNaN(numValue) && !isNaN(Number(compareValue))) {
-        return numValue === Number(compareValue);
-      }
-      return strValue === compareValue;
-    case "not_equals":
-      if (!isNaN(numValue) && !isNaN(Number(compareValue))) {
-        return numValue !== Number(compareValue);
-      }
-      return strValue !== compareValue;
-    case "greater_than":
-      return numValue > Number(compareValue);
-    case "greater_or_equal":
-      return numValue >= Number(compareValue);
-    case "less_than":
-      return numValue < Number(compareValue);
-    case "less_or_equal":
-      return numValue <= Number(compareValue);
-    case "contains":
-      return strValue.toLowerCase().includes(compareValue.toLowerCase());
-    case "starts_with":
-      return strValue.toLowerCase().startsWith(compareValue.toLowerCase());
-    case "ends_with":
-      return strValue.toLowerCase().endsWith(compareValue.toLowerCase());
-    case "is_empty":
-      return strValue === "" || Array.isArray(fieldValue) && fieldValue.length === 0;
-    case "is_not_empty":
-      return strValue !== "" && !(Array.isArray(fieldValue) && fieldValue.length === 0);
-    case "is_true":
-      return Boolean(fieldValue) === true;
-    case "is_false":
-      return Boolean(fieldValue) === false;
-    default:
-      return false;
-  }
-}
-function getNestedValue(obj, path) {
-  const parts = path.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current === null || current === undefined || typeof current !== "object") {
-      return;
-    }
-    current = current[part];
-  }
-  return current;
-}
-
-// src/task/Task.ts
-import {
-  compileSchema,
-  deepEqual,
-  EventEmitter as EventEmitter3,
-  uuid4 as uuid42
-} from "@workglow/util";
-
-// src/task/TaskError.ts
-import { BaseError } from "@workglow/util";
-
-class TaskError extends BaseError {
-  static type = "TaskError";
-  constructor(message) {
-    super(message);
-  }
-}
-
-class TaskConfigurationError extends TaskError {
-  static type = "TaskConfigurationError";
-  constructor(message) {
-    super(message);
-  }
-}
-
-class WorkflowError extends TaskError {
-  static type = "WorkflowError";
-  constructor(message) {
-    super(message);
-  }
-}
-
-class TaskAbortedError extends TaskError {
-  static type = "TaskAbortedError";
-  constructor(message = "Task aborted") {
-    super(message);
-  }
-}
-
-class TaskTimeoutError extends TaskAbortedError {
-  static type = "TaskTimeoutError";
-  constructor(timeoutMs) {
-    super(timeoutMs ? `Task timed out after ${timeoutMs}ms` : "Task timed out");
-  }
-}
-
-class TaskFailedError extends TaskError {
-  static type = "TaskFailedError";
-  constructor(message = "Task failed") {
-    super(message);
-  }
-}
-
-class JobTaskFailedError extends TaskFailedError {
-  static type = "JobTaskFailedError";
-  jobError;
-  constructor(err) {
-    super(String(err));
-    this.jobError = err;
-  }
-}
-
-class TaskJSONError extends TaskError {
-  static type = "TaskJSONError";
-  constructor(message = "Error converting JSON to a Task") {
-    super(message);
-  }
-}
-
-class TaskInvalidInputError extends TaskError {
-  static type = "TaskInvalidInputError";
-  constructor(message = "Invalid input data") {
-    super(message);
-  }
-}
-
-// src/task/TaskRunner.ts
-import { getLogger, globalServiceRegistry } from "@workglow/util";
-
-// 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;
-}
-
-// 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;
-}
-
-// src/task/TaskRunner.ts
-class TaskRunner {
-  running = false;
-  reactiveRunning = false;
-  task;
-  abortController;
-  outputCache;
-  registry = globalServiceRegistry;
-  inputStreams;
-  timeoutTimer;
-  pendingTimeoutError;
-  shouldAccumulate = true;
-  constructor(task) {
-    this.task = task;
-    this.own = this.own.bind(this);
-    this.handleProgress = this.handleProgress.bind(this);
-  }
-  get timerLabel() {
-    return `task:${this.task.type}:${this.task.config.id}`;
-  }
-  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) {
-          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);
-    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();
-    });
-    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;
-    }
-    getLogger().time(this.timerLabel, { taskType: this.task.type, taskId: this.task.config.id });
-    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();
-    getLogger().timeEnd(this.timerLabel, { taskType: this.task.type, taskId: this.task.config.id });
-    this.task.status = TaskStatus.ABORTING;
-    this.task.progress = 100;
-    this.task.error = this.pendingTimeoutError ?? new TaskAbortedError;
-    this.pendingTimeoutError = 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;
-    getLogger().timeEnd(this.timerLabel, { taskType: this.task.type, taskId: this.task.config.id });
-    this.task.completedAt = new Date;
-    this.task.progress = 100;
-    this.task.status = TaskStatus.COMPLETED;
-    this.abortController = 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;
-    getLogger().timeEnd(this.timerLabel, { taskType: this.task.type, taskId: this.task.config.id });
-    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;
-    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);
-  }
-}
-
-// src/task/Task.ts
-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 extras = this.config.extras;
-    const json = this.stripSymbols({
-      id: this.id,
-      type: this.type,
-      defaults: this.defaults,
-      config: {
-        ...this.config.title ? { title: this.config.title } : {},
-        ...this.config.description ? { description: this.config.description } : {},
-        ...this.config.inputSchema ? { inputSchema: this.config.inputSchema } : {},
-        ...this.config.outputSchema ? { outputSchema: this.config.outputSchema } : {},
-        ...extras && Object.keys(extras).length ? { extras } : {}
-      }
-    });
-    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");
-  }
-}
-
-// src/task/ConditionalTask.ts
-var conditionalTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema["properties"],
-    branches: { type: "array", items: {} },
-    defaultBranch: { type: "string" },
-    exclusive: { type: "boolean" },
-    conditionConfig: { type: "object", additionalProperties: true }
-  },
-  additionalProperties: false
-};
-
-class ConditionalTask extends Task {
-  static type = "ConditionalTask";
-  static category = "Flow Control";
-  static title = "Condition";
-  static description = "Route data based on conditions";
-  static hasDynamicSchemas = true;
-  static configSchema() {
-    return conditionalTaskConfigSchema;
-  }
-  activeBranches = new Set;
-  buildBranchesFromConditionConfig(conditionConfig) {
-    if (!conditionConfig?.branches || conditionConfig.branches.length === 0) {
-      return [
-        {
-          id: "default",
-          condition: () => true,
-          outputPort: "1"
-        }
-      ];
-    }
-    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) {
-        getLogger2().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;
-  }
-}
-
-// src/task-graph/TaskGraphRunner.ts
-var PROPERTY_ARRAY = "PROPERTY_ARRAY";
-var GRAPH_RESULT_ARRAY = "GRAPH_RESULT_ARRAY";
-
-class TaskGraphRunner {
-  processScheduler;
-  reactiveScheduler;
-  running = false;
-  reactiveRunning = false;
-  graph;
-  outputCache;
-  accumulateLeafOutputs = true;
-  registry = globalServiceRegistry2;
-  abortController;
-  inProgressTasks = new Map;
-  inProgressFunctions = new Map;
-  failedTaskErrors = new Map;
-  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 = "";
-  get timerLabel() {
-    return `graph:${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;
-    }
-    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);
-      getLogger3().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 {
-        getLogger3().warn("pushOutputFromNodeToEdges", {
-          dataflowId: dataflow.id,
-          compatibility,
-          resultsKeys: Object.keys(results)
-        });
-      }
-    }
-  }
-  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 logger = getLogger3();
-    logger.group(this.timerLabel, { graph: this.graph });
-    logger.time(this.timerLabel);
-    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;
-    const logger = getLogger3();
-    logger.timeEnd(this.timerLabel);
-    logger.groupEnd();
-    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) {
-        task.abort();
-      }
-    }));
-    this.running = false;
-    const logger = getLogger3();
-    logger.timeEnd(this.timerLabel);
-    logger.groupEnd();
-    this.graph.emit("error", error);
-  }
-  async handleErrorReactive() {
-    this.reactiveRunning = false;
-  }
-  async handleAbort() {
-    this.graph.getTasks().map(async (task) => {
-      if (task.status === TaskStatus.PROCESSING || task.status === TaskStatus.STREAMING) {
-        task.abort();
-      }
-    });
-    this.running = false;
-    const logger = getLogger3();
-    logger.timeEnd(this.timerLabel);
-    logger.groupEnd();
-    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);
-    await this.pushOutputFromNodeToEdges(task, task.runOutputData);
-    this.graph.emit("graph_progress", progress, message, args);
-  }
-}
-
-// src/task/GraphAsTaskRunner.ts
-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
-    });
-    unsubscribe();
-    return results;
-  }
-  async executeTaskChildrenReactive() {
-    return this.task.subGraph.runReactive(this.task.runInputData);
-  }
-  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 graphAsTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema["properties"],
-    compoundMerge: { type: "string", "x-ui-hidden": true }
-  },
-  additionalProperties: false
-};
-
-class GraphAsTask extends Task {
-  static type = "GraphAsTask";
-  static title = "Group";
-  static description = "A group of tasks that are executed together";
-  static category = "Flow Control";
-  static compoundMerge = PROPERTY_ARRAY;
-  static hasDynamicSchemas = true;
-  constructor(input = {}, config = {}) {
-    const { subGraph, ...rest } = config;
-    super(input, rest);
-    if (subGraph) {
-      this.subGraph = subGraph;
-    }
-    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/Workflow.ts
 import {
-  EventEmitter as EventEmitter4,
-  getLogger as getLogger4,
-  uuid4 as uuid44
-} from "@workglow/util";
-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 EventEmitter4;
-  static createWorkflow(taskClass) {
-    const helper = function(input = {}, config = {}) {
-      this._error = "";
-      const parent = getLastTask(this);
-      const task = this.addTaskToGraph(taskClass, input, { id: uuid44(), ...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}`;
-            getLogger4().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;
-            getLogger4().warn(this._error);
-          } else {
-            this._error = result.error + " Task not added.";
-            getLogger4().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 = {}) {
-    if (this.isLoopBuilder) {
-      this.finalizeTemplate();
-      if (this._pendingLoopConnect) {
-        this._parentWorkflow.autoConnectLoopTask(this._pendingLoopConnect);
-        this._pendingLoopConnect = undefined;
-      }
-      return this._parentWorkflow.run(input);
-    }
-    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)
-    });
+  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 "./bun-tgs39x49.js";
+
+// src/common.ts
+init_Dataflow();
+init_GraphSchemaUtils();
+init_TaskGraph();
+init_TaskGraphEvents();
+init_TaskGraphRunner();
+init_Conversions();
+
+// src/task-graph/GraphToWorkflowCode.ts
+init_Dataflow();
+init_Workflow();
+var methodNameCache;
+function getMethodNameMap() {
+  if (methodNameCache)
+    return methodNameCache;
+  methodNameCache = new Map;
+  for (const key of Object.getOwnPropertyNames(Workflow.prototype)) {
     try {
-      const output = await this.graph.run(input, {
-        parentSignal: this._abortController.signal,
-        outputCache: this._outputCache
-      });
-      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";
-      getLogger4().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;
-      getLogger4().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;
-        getLogger4().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;
-      getLogger4().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";
-      getLogger4().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`);
+      const val = Workflow.prototype[key];
+      if (val && val.workflowCreate && val.type) {
+        methodNameCache.set(val.type, key);
       }
-    } 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: uuid44(), ...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}`;
-          getLogger4().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 };
+    } catch {}
+  }
+  return methodNameCache;
+}
+var LOOP_TASK_TYPES = {
+  MapTask: { method: "map", endMethod: "endMap" },
+  ReduceTask: { method: "reduce", endMethod: "endReduce" },
+  WhileTask: { method: "while", endMethod: "endWhile" },
+  GraphAsTask: { method: "group", endMethod: "endGroup" }
+};
+function graphToWorkflowCode(graph, options = {}) {
+  const { variableName = "workflow", includeDeclaration = true, indent = "  " } = options;
+  const lines = [];
+  if (includeDeclaration) {
+    lines.push(`const ${variableName} = new Workflow();`);
+  }
+  const tasks = graph.topologicallySortedNodes();
+  const dataflows = graph.getDataflows();
+  const incomingDataflows = new Map;
+  for (const df of dataflows) {
+    const list = incomingDataflows.get(df.targetTaskId) ?? [];
+    list.push(df);
+    incomingDataflows.set(df.targetTaskId, list);
+  }
+  const taskOrder = [];
+  generateTaskChain(tasks, incomingDataflows, taskOrder, variableName, indent, 0, lines);
+  return lines.join(`
+`);
+}
+function generateTaskChain(tasks, incomingDataflows, taskOrder, variableName, indent, depth, lines) {
+  if (tasks.length === 0)
+    return;
+  const prefix = indent.repeat(depth);
+  const chainIndent = indent.repeat(depth + 1);
+  const chainLines = [];
+  for (let i = 0;i < tasks.length; i++) {
+    const task = tasks[i];
+    const loopInfo = LOOP_TASK_TYPES[task.type];
+    const renames = computeRenames(task, incomingDataflows, taskOrder);
+    for (const rename of renames) {
+      chainLines.push(`${chainIndent}.rename(${formatValue(rename.source)}, ${formatValue(rename.target)})`);
+    }
+    if (loopInfo) {
+      generateLoopTask(task, loopInfo, incomingDataflows, taskOrder, indent, depth, chainLines);
+    } else {
+      generateRegularTask(task, chainIndent, chainLines);
     }
-    return loopBuilder;
+    taskOrder.push(task.id);
   }
-  autoConnectLoopTask(pending) {
-    if (!pending)
+  if (chainLines.length === 1 && !chainLines[0].includes(`
+`)) {
+    const call = chainLines[0].trimStart();
+    const oneLine = `${prefix}${variableName}${call}`;
+    if (oneLine.length < 80) {
+      lines.push(`${oneLine};`);
       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.";
-        getLogger4().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 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
-        };
+  lines.push(`${prefix}${variableName}`);
+  for (const line of chainLines) {
+    lines.push(line);
+  }
+  lines[lines.length - 1] += ";";
+}
+function generateRegularTask(task, chainIndent, lines) {
+  const methodMap = getMethodNameMap();
+  const methodName = methodMap.get(task.type);
+  const defaults = task.defaults;
+  const config = extractTaskConfig(task);
+  if (methodName) {
+    const colOffset = chainIndent.length + `.${methodName}(`.length;
+    const args = buildMethodArgs(defaults, config, chainIndent, colOffset);
+    lines.push(`${chainIndent}.${methodName}(${args})`);
+  } else {
+    const colOffset = chainIndent.length + ".addTask(".length;
+    const args = buildAddTaskArgs(task.type, defaults, config, chainIndent, colOffset);
+    lines.push(`${chainIndent}.addTask(${args})`);
+  }
+}
+function generateLoopTask(task, loopInfo, incomingDataflows, taskOrder, indent, depth, lines) {
+  const chainIndent = indent.repeat(depth + 1);
+  const config = extractLoopConfig(task);
+  const loopColOffset = chainIndent.length + `.${loopInfo.method}(`.length;
+  const configStr = Object.keys(config).length > 0 ? formatValue(config, chainIndent, loopColOffset) : "";
+  lines.push(`${chainIndent}.${loopInfo.method}(${configStr})`);
+  if (task.hasChildren()) {
+    const subGraph = task.subGraph;
+    const innerTasks = subGraph.topologicallySortedNodes();
+    const innerDataflows = subGraph.getDataflows();
+    const innerIncoming = new Map;
+    for (const df of innerDataflows) {
+      const list = innerIncoming.get(df.targetTaskId) ?? [];
+      list.push(df);
+      innerIncoming.set(df.targetTaskId, list);
+    }
+    const innerOrder = [];
+    generateChainedInnerTasks(innerTasks, innerIncoming, innerOrder, indent, depth + 1, lines);
+  }
+  lines.push(`${chainIndent}.${loopInfo.endMethod}()`);
+}
+function generateChainedInnerTasks(tasks, incomingDataflows, taskOrder, indent, depth, lines) {
+  const innerPrefix = indent.repeat(depth + 1);
+  for (let i = 0;i < tasks.length; i++) {
+    const task = tasks[i];
+    const loopInfo = LOOP_TASK_TYPES[task.type];
+    const renames = computeRenames(task, incomingDataflows, taskOrder);
+    for (const rename of renames) {
+      lines.push(`${innerPrefix}.rename(${formatValue(rename.source)}, ${formatValue(rename.target)})`);
+    }
+    if (loopInfo) {
+      const config = extractLoopConfig(task);
+      const nestedColOffset = innerPrefix.length + `.${loopInfo.method}(`.length;
+      const configStr = Object.keys(config).length > 0 ? formatValue(config, innerPrefix, nestedColOffset) : "";
+      lines.push(`${innerPrefix}.${loopInfo.method}(${configStr})`);
+      if (task.hasChildren()) {
+        const subGraph = task.subGraph;
+        const innerTasks = subGraph.topologicallySortedNodes();
+        const innerDataflows = subGraph.getDataflows();
+        const innerIncoming = new Map;
+        for (const df of innerDataflows) {
+          const list = innerIncoming.get(df.targetTaskId) ?? [];
+          list.push(df);
+          innerIncoming.set(df.targetTaskId, list);
+        }
+        const innerOrder = [];
+        generateChainedInnerTasks(innerTasks, innerIncoming, innerOrder, indent, depth + 1, lines);
+      }
+      lines.push(`${innerPrefix}.${loopInfo.endMethod}()`);
+    } else {
+      const methodMap = getMethodNameMap();
+      const methodName = methodMap.get(task.type);
+      const defaults = task.defaults;
+      const config = extractTaskConfig(task);
+      if (methodName) {
+        const colOffset = innerPrefix.length + `.${methodName}(`.length;
+        const args = buildMethodArgs(defaults, config, innerPrefix, colOffset);
+        lines.push(`${innerPrefix}.${methodName}(${args})`);
+      } else {
+        const colOffset = innerPrefix.length + ".addTask(".length;
+        const args = buildAddTaskArgs(task.type, defaults, config, innerPrefix, colOffset);
+        lines.push(`${innerPrefix}.addTask(${args})`);
       }
     }
+    taskOrder.push(task.id);
   }
-  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") {
-          for (const requiredInputId of [...unmatchedRequired]) {
-            if (matches.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: []
-        };
-      }
+}
+function computeRenames(task, incomingDataflows, taskOrder) {
+  const incoming = incomingDataflows.get(task.id) ?? [];
+  const renames = [];
+  const prevTaskId = taskOrder.length > 0 ? taskOrder[taskOrder.length - 1] : undefined;
+  for (const df of incoming) {
+    if (df.sourceTaskPortId === DATAFLOW_ALL_PORTS && df.targetTaskPortId === DATAFLOW_ALL_PORTS) {
+      continue;
     }
-    return {
-      matches,
-      unmatchedRequired: []
-    };
-  }
-  finalizeTemplate() {
-    if (!this._iteratorTask || this.graph.getTasks().length === 0) {
-      return;
+    if (df.sourceTaskPortId === DATAFLOW_ERROR_PORT || df.targetTaskPortId === DATAFLOW_ERROR_PORT) {
+      continue;
     }
-    this._iteratorTask.subGraph = this.graph;
-  }
-  finalizeAndReturn() {
-    if (!this._parentWorkflow) {
-      throw new WorkflowError("finalizeAndReturn() can only be called on loop workflows");
+    if (df.sourceTaskId !== prevTaskId) {
+      continue;
     }
-    this.finalizeTemplate();
-    if (this._pendingLoopConnect) {
-      this._parentWorkflow.autoConnectLoopTask(this._pendingLoopConnect);
-      this._pendingLoopConnect = undefined;
+    if (df.sourceTaskPortId === df.targetTaskPortId) {
+      continue;
     }
-    return this._parentWorkflow;
-  }
-}
-
-// src/task-graph/Conversions.ts
-class ListeningGraphAsTask extends GraphAsTask {
-  constructor(input, config) {
-    super(input, config);
-    this.subGraph.on("start", () => {
-      this.emit("start");
-    });
-    this.subGraph.on("complete", () => {
-      this.emit("complete");
+    renames.push({ source: df.sourceTaskPortId, target: df.targetTaskPortId });
+  }
+  return renames;
+}
+function extractTaskConfig(task) {
+  const config = {};
+  const rawConfig = task.config;
+  const staticTitle = task.constructor.title || "";
+  const staticDescription = task.constructor.description || "";
+  if (rawConfig.title && rawConfig.title !== staticTitle)
+    config.title = rawConfig.title;
+  if (rawConfig.description && rawConfig.description !== staticDescription)
+    config.description = rawConfig.description;
+  return config;
+}
+function extractLoopConfig(task) {
+  const config = {};
+  const rawConfig = task.config;
+  switch (task.type) {
+    case "GraphAsTask": {
+      if (rawConfig.compoundMerge !== undefined) {
+        config.compoundMerge = rawConfig.compoundMerge;
+      }
+      break;
+    }
+    case "MapTask": {
+      if (rawConfig.preserveOrder !== undefined && rawConfig.preserveOrder !== true) {
+        config.preserveOrder = rawConfig.preserveOrder;
+      }
+      if (rawConfig.flatten !== undefined && rawConfig.flatten !== false) {
+        config.flatten = rawConfig.flatten;
+      }
+      if (rawConfig.concurrencyLimit !== undefined) {
+        config.concurrencyLimit = rawConfig.concurrencyLimit;
+      }
+      if (rawConfig.batchSize !== undefined) {
+        config.batchSize = rawConfig.batchSize;
+      }
+      break;
+    }
+    case "ReduceTask": {
+      if (rawConfig.initialValue !== undefined) {
+        config.initialValue = rawConfig.initialValue;
+      }
+      break;
+    }
+    case "WhileTask": {
+      if (rawConfig.maxIterations !== undefined && rawConfig.maxIterations !== 100) {
+        config.maxIterations = rawConfig.maxIterations;
+      }
+      if (rawConfig.chainIterations !== undefined && rawConfig.chainIterations !== true) {
+        config.chainIterations = rawConfig.chainIterations;
+      }
+      if (rawConfig.conditionField !== undefined) {
+        config.conditionField = rawConfig.conditionField;
+      }
+      if (rawConfig.conditionOperator !== undefined) {
+        config.conditionOperator = rawConfig.conditionOperator;
+      }
+      if (rawConfig.conditionValue !== undefined) {
+        config.conditionValue = rawConfig.conditionValue;
+      }
+      if (rawConfig.condition && !rawConfig.conditionOperator) {
+        config.condition = null;
+      }
+      break;
+    }
+  }
+  return config;
+}
+function buildMethodArgs(defaults, config, baseIndent = "", columnOffset = 0) {
+  const hasDefaults = defaults && Object.keys(defaults).length > 0;
+  const hasConfig = Object.keys(config).length > 0;
+  if (!hasDefaults && !hasConfig)
+    return "";
+  if (hasDefaults && !hasConfig)
+    return formatValue(defaults, baseIndent, columnOffset);
+  if (!hasDefaults && hasConfig)
+    return `{}, ${formatValue(config, baseIndent, columnOffset + 4)}`;
+  const defaultsStr = formatValue(defaults, baseIndent, columnOffset);
+  return `${defaultsStr}, ${formatValue(config, baseIndent, columnOffset + defaultsStr.length + 2)}`;
+}
+function buildAddTaskArgs(taskType, defaults, config, baseIndent = "", columnOffset = 0) {
+  const hasDefaults = defaults && Object.keys(defaults).length > 0;
+  const hasConfig = Object.keys(config).length > 0;
+  const typeOffset = columnOffset + taskType.length + 2;
+  if (!hasDefaults && !hasConfig)
+    return taskType;
+  if (hasDefaults && !hasConfig)
+    return `${taskType}, ${formatValue(defaults, baseIndent, typeOffset)}`;
+  if (!hasDefaults && hasConfig)
+    return `${taskType}, {}, ${formatValue(config, baseIndent, typeOffset + 4)}`;
+  const defaultsStr = formatValue(defaults, baseIndent, typeOffset);
+  return `${taskType}, ${defaultsStr}, ${formatValue(config, baseIndent, typeOffset + defaultsStr.length + 2)}`;
+}
+function formatValue(value, baseIndent = "", columnOffset = 0) {
+  if (value === undefined)
+    return "undefined";
+  if (value === null)
+    return "null";
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (value instanceof Float32Array) {
+    return `new Float32Array([${Array.from(value).join(", ")}])`;
+  }
+  if (value instanceof Float64Array) {
+    return `new Float64Array([${Array.from(value).join(", ")}])`;
+  }
+  const entryIndent = baseIndent + "  ";
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return "[]";
+    const items = value.map((v) => formatValue(v, entryIndent));
+    const oneLine = `[${items.join(", ")}]`;
+    if (columnOffset + oneLine.length < 80)
+      return oneLine;
+    return `[
+${items.map((item) => `${entryIndent}${item}`).join(`,
+`)}
+${baseIndent}]`;
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj);
+    if (keys.length === 0)
+      return "{}";
+    const entries = keys.map((k) => {
+      const formattedKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(k) ? k : JSON.stringify(k);
+      return `${formattedKey}: ${formatValue(obj[k], entryIndent)}`;
     });
-    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 GraphAsTask {
-  static type = "Graph";
-}
-
-class WorkflowTask2 extends GraphAsTask {
-  static type = "Workflow";
-}
-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 ensureTask(arg, config = {}) {
-  if (arg instanceof Task) {
-    return arg;
-  }
-  if (arg instanceof TaskGraph) {
-    const { isOwned, ...cleanConfig } = config;
-    if (isOwned) {
-      return new OwnGraphTask({}, { ...cleanConfig, subGraph: arg });
-    } else {
-      return new GraphTask({}, { ...cleanConfig, subGraph: arg });
-    }
-  }
-  if (arg instanceof Workflow) {
-    const { isOwned, ...cleanConfig } = config;
-    if (isOwned) {
-      return new OwnWorkflowTask({}, { ...cleanConfig, subGraph: arg.graph });
-    } else {
-      return new WorkflowTask2({}, { ...cleanConfig, subGraph: arg.graph });
-    }
+    const oneLine = `{ ${entries.join(", ")} }`;
+    if (columnOffset + oneLine.length < 80)
+      return oneLine;
+    return `{
+${entries.map((e) => `${entryIndent}${e}`).join(`,
+`)}
+${baseIndent}}`;
   }
-  return convertPipeFunctionToTask(arg, config);
-}
-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, "*"));
+  return String(value);
 }
-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 resetMethodNameCache() {
+  methodNameCache = undefined;
 }
-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 = `\u2016${args.map((arg) => "\uD835\uDC53").join("\u2016")}\u2016`;
 
-  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;
-}
+// src/common.ts
+init_Workflow();
 
-// src/task-graph/TaskGraphEvents.ts
-var EventDagToTaskGraphMapping = {
-  "node-added": "task_added",
-  "node-removed": "task_removed",
-  "node-replaced": "task_replaced",
-  "edge-added": "dataflow_added",
-  "edge-removed": "dataflow_removed",
-  "edge-replaced": "dataflow_replaced"
-};
-var EventTaskGraphToDagMapping = {
-  task_added: "node-added",
-  task_removed: "node-removed",
-  task_replaced: "node-replaced",
-  dataflow_added: "edge-added",
-  dataflow_removed: "edge-removed",
-  dataflow_replaced: "edge-replaced"
-};
+// src/task/index.ts
+init_ConditionalTask();
+init_ConditionUtils();
 
-// src/task-graph/TaskGraph.ts
-class TaskGraphDAG extends DirectedAcyclicGraph {
-  constructor() {
-    super((task) => task.id, (dataflow) => dataflow.id);
-  }
-}
+// src/task/FallbackTask.ts
+init_Workflow();
+init_GraphAsTask();
 
-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, uuid45());
-  }
-  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 EventEmitter5;
-    }
-    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;
-}
 // src/task/FallbackTaskRunner.ts
+init_GraphAsTaskRunner();
+init_TaskError();
+init_TaskTypes();
+
 class FallbackTaskRunner extends GraphAsTaskRunner {
   async executeTask(input) {
     if (this.task.fallbackMode === "data") {
@@ -4257,7 +624,21 @@ queueMicrotask(() => {
   };
   Workflow.prototype.endFallbackWith = CreateEndLoopWorkflow("endFallbackWith");
 });
+
+// src/task/index.ts
+init_GraphAsTask();
+init_GraphAsTaskRunner();
+init_InputResolver();
+
+// src/task/IteratorTask.ts
+init_GraphAsTask();
+
 // src/task/IteratorTaskRunner.ts
+init_Dataflow();
+init_TaskGraph();
+init_GraphAsTaskRunner();
+import { uuid4 } from "@workglow/util";
+
 class IteratorTaskRunner extends GraphAsTaskRunner {
   async executeTask(input) {
     const analysis = this.task.analyzeIterationInput(input);
@@ -4348,16 +729,20 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
   }
   cloneGraph(graph) {
     const clone = new TaskGraph;
+    const idMap = new Map;
     for (const task of graph.getTasks()) {
       const ctor = task.constructor;
-      const newTask = new ctor(task.defaults, task.config, task.runConfig);
+      const newId = uuid4();
+      idMap.set(task.config.id, newId);
+      const clonedConfig = { ...task.config, id: newId };
+      const newTask = new ctor(task.defaults, clonedConfig, task.runConfig);
       if (task.hasChildren()) {
         newTask.subGraph = this.cloneGraph(task.subGraph);
       }
       clone.addTask(newTask);
     }
     for (const df of graph.getDataflows()) {
-      clone.addDataflow(new Dataflow(df.sourceTaskId, df.sourceTaskPortId, df.targetTaskId, df.targetTaskPortId));
+      clone.addDataflow(new Dataflow(idMap.get(df.sourceTaskId) ?? df.sourceTaskId, df.sourceTaskPortId, idMap.get(df.targetTaskId) ?? df.targetTaskId, df.targetTaskPortId));
     }
     return clone;
   }
@@ -4378,6 +763,7 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
 }
 
 // src/task/IteratorTask.ts
+init_TaskError();
 var ITERATOR_CONTEXT_SCHEMA = {
   type: "object",
   properties: {
@@ -4869,7 +1255,15 @@ class IteratorTask extends GraphAsTask {
   }
 }
 
+// src/task/WhileTask.ts
+init_Workflow();
+init_ConditionUtils();
+init_GraphAsTask();
+init_TaskError();
+
 // src/task/WhileTaskRunner.ts
+init_GraphAsTaskRunner();
+
 class WhileTaskRunner extends GraphAsTaskRunner {
   async executeTask(input) {
     const result = await this.task.execute(input, {
@@ -5425,8 +1819,8 @@ import {
   JobQueueServer
 } from "@workglow/job-queue";
 import { InMemoryQueueStorage } from "@workglow/storage";
-import { createServiceToken as createServiceToken2, globalServiceRegistry as globalServiceRegistry3 } from "@workglow/util";
-var JOB_QUEUE_FACTORY = createServiceToken2("taskgraph.jobQueueFactory");
+import { createServiceToken, globalServiceRegistry } from "@workglow/util";
+var JOB_QUEUE_FACTORY = createServiceToken("taskgraph.jobQueueFactory");
 var defaultJobQueueFactory = async ({
   queueName,
   jobClass,
@@ -5453,7 +1847,7 @@ var defaultJobQueueFactory = async ({
   return { server, client, storage };
 };
 function registerJobQueueFactory(factory) {
-  globalServiceRegistry3.registerInstance(JOB_QUEUE_FACTORY, factory);
+  globalServiceRegistry.registerInstance(JOB_QUEUE_FACTORY, factory);
 }
 function createJobQueueFactoryWithOptions(defaultOptions = {}) {
   return async ({
@@ -5487,16 +1881,18 @@ function createJobQueueFactoryWithOptions(defaultOptions = {}) {
   };
 }
 function getJobQueueFactory() {
-  if (!globalServiceRegistry3.has(JOB_QUEUE_FACTORY)) {
+  if (!globalServiceRegistry.has(JOB_QUEUE_FACTORY)) {
     registerJobQueueFactory(defaultJobQueueFactory);
   }
-  return globalServiceRegistry3.get(JOB_QUEUE_FACTORY);
+  return globalServiceRegistry.get(JOB_QUEUE_FACTORY);
 }
-if (!globalServiceRegistry3.has(JOB_QUEUE_FACTORY)) {
+if (!globalServiceRegistry.has(JOB_QUEUE_FACTORY)) {
   registerJobQueueFactory(defaultJobQueueFactory);
 }
 // src/task/JobQueueTask.ts
+init_GraphAsTask();
 import { Job as Job2 } from "@workglow/job-queue";
+init_TaskError();
 
 // src/task/TaskQueueRegistry.ts
 var taskQueueRegistry = null;
@@ -5693,6 +2089,7 @@ class JobQueueTask extends GraphAsTask {
   }
 }
 // src/task/MapTask.ts
+init_TaskGraphRunner();
 var mapTaskConfigSchema = {
   type: "object",
   properties: {
@@ -5768,11 +2165,13 @@ class MapTask extends IteratorTask {
     return flattened;
   }
 }
-queueMicrotask(() => {
-  Workflow.prototype.map = CreateLoopWorkflow(MapTask);
-  Workflow.prototype.endMap = CreateEndLoopWorkflow("endMap");
+queueMicrotask(async () => {
+  const { CreateLoopWorkflow: CreateLoopWorkflow3, CreateEndLoopWorkflow: CreateEndLoopWorkflow2, Workflow: Workflow2 } = await import("./Workflow-wrs2y87g.js");
+  Workflow2.prototype.map = CreateLoopWorkflow3(MapTask);
+  Workflow2.prototype.endMap = CreateEndLoopWorkflow2("endMap");
 });
 // src/task/ReduceTask.ts
+init_Workflow();
 var reduceTaskConfigSchema = {
   type: "object",
   properties: {
@@ -5866,10 +2265,21 @@ queueMicrotask(() => {
   Workflow.prototype.reduce = CreateLoopWorkflow(ReduceTask);
   Workflow.prototype.endReduce = CreateEndLoopWorkflow("endReduce");
 });
+
+// src/task/index.ts
+init_StreamTypes();
+init_Task();
+init_TaskError();
+
+// src/task/TaskJSON.ts
+init_Dataflow();
+init_TaskGraph();
+init_TaskError();
+
 // src/task/TaskRegistry.ts
 import {
-  createServiceToken as createServiceToken3,
-  globalServiceRegistry as globalServiceRegistry4,
+  createServiceToken as createServiceToken2,
+  globalServiceRegistry as globalServiceRegistry2,
   registerInputResolver
 } from "@workglow/util";
 var taskConstructors = new Map;
@@ -5881,15 +2291,15 @@ var TaskRegistry = {
   all: taskConstructors,
   registerTask
 };
-var TASK_CONSTRUCTORS = createServiceToken3("task.constructors");
-if (!globalServiceRegistry4.has(TASK_CONSTRUCTORS)) {
-  globalServiceRegistry4.register(TASK_CONSTRUCTORS, () => TaskRegistry.all, true);
+var TASK_CONSTRUCTORS = createServiceToken2("task.constructors");
+if (!globalServiceRegistry2.has(TASK_CONSTRUCTORS)) {
+  globalServiceRegistry2.register(TASK_CONSTRUCTORS, () => TaskRegistry.all, true);
 }
 function getGlobalTaskConstructors() {
-  return globalServiceRegistry4.get(TASK_CONSTRUCTORS);
+  return globalServiceRegistry2.get(TASK_CONSTRUCTORS);
 }
 function setGlobalTaskConstructors(map) {
-  globalServiceRegistry4.registerInstance(TASK_CONSTRUCTORS, map);
+  globalServiceRegistry2.registerInstance(TASK_CONSTRUCTORS, map);
 }
 function getTaskConstructors(registry) {
   if (!registry)
@@ -5911,6 +2321,7 @@ function resolveTaskFromRegistry(id, _format, registry) {
 registerInputResolver("tasks", resolveTaskFromRegistry);
 
 // src/task/TaskJSON.ts
+init_GraphAsTask();
 var createSingleTaskFromJSON = (item, registry) => {
   if (!item.id)
     throw new TaskJSONError("Task id required");
@@ -5966,21 +2377,25 @@ var createGraphFromGraphJSON = (graphJsonObj, registry) => {
   }
   return subGraph;
 };
+
 // src/task/index.ts
+init_ConditionalTask();
+init_TaskTypes();
+init_GraphAsTask();
 var registerBaseTasks = () => {
   const tasks = [GraphAsTask, ConditionalTask, FallbackTask, MapTask, WhileTask, ReduceTask];
   tasks.map(TaskRegistry.registerTask);
   return tasks;
 };
 // src/storage/TaskGraphRepository.ts
-import { createServiceToken as createServiceToken4, EventEmitter as EventEmitter6 } from "@workglow/util";
-var TASK_GRAPH_REPOSITORY = createServiceToken4("taskgraph.taskGraphRepository");
+import { createServiceToken as createServiceToken3, EventEmitter } from "@workglow/util";
+var TASK_GRAPH_REPOSITORY = createServiceToken3("taskgraph.taskGraphRepository");
 
 class TaskGraphRepository {
   type = "TaskGraphRepository";
   get events() {
     if (!this._events) {
-      this._events = new EventEmitter6;
+      this._events = new EventEmitter;
     }
     return this._events;
   }
@@ -6048,7 +2463,12 @@ class TaskGraphTabularRepository extends TaskGraphRepository {
     return await this.tabularRepository.size();
   }
 }
+
+// src/common.ts
+init_TaskOutputRepository();
+
 // src/storage/TaskOutputTabularRepository.ts
+init_TaskOutputRepository();
 import { compress, decompress, makeFingerprint } from "@workglow/util";
 var TaskOutputSchema = {
   type: "object",
@@ -6138,6 +2558,7 @@ export {
   serialGraph,
   schemaAcceptsArray,
   resolveSchemaInputs,
+  resetMethodNameCache,
   removeIterationProperties,
   registerJobQueueFactory,
   registerBaseTasks,
@@ -6155,6 +2576,7 @@ export {
   hasVectorOutput,
   hasVectorLikeInput,
   hasStructuredOutput,
+  graphToWorkflowCode,
   graphAsTaskConfigSchema,
   getTaskQueueRegistry,
   getTaskConstructors,
@@ -6170,6 +2592,7 @@ export {
   getInputModeFromSchema,
   getGlobalTaskConstructors,
   getAppendPortId,
+  formatValue,
   findArrayPorts,
   filterIterationProperties,
   fallbackTaskConfigSchema,
@@ -6251,4 +2674,4 @@ export {
   ConditionalTask
 };
 
-//# debugId=4EA0BC88063B5C3D64756E2164756E21
+//# debugId=C456BB2ACC871E6964756E2164756E21