@workglow/task-graph 0.0.52

package/dist/browser.js

@@ -0,0 +1,2842 @@
+// src/task/ArrayTask.ts
+import { uuid4 as uuid44 } from "@workglow/util";
+
+// src/task-graph/TaskGraph.ts
+import { DirectedAcyclicGraph, EventEmitter as EventEmitter5, uuid4 as uuid43 } from "@workglow/util";
+
+// src/task/GraphAsTask.ts
+import { compileSchema as compileSchema2 } from "@workglow/util";
+
+// src/task-graph/Dataflow.ts
+import { areSemanticallyCompatible, EventEmitter } from "@workglow/util";
+
+// src/task/TaskTypes.ts
+var TaskStatus;
+((TaskStatus2) => {
+  TaskStatus2["PENDING"] = "PENDING";
+  TaskStatus2["DISABLED"] = "DISABLED";
+  TaskStatus2["PROCESSING"] = "PROCESSING";
+  TaskStatus2["COMPLETED"] = "COMPLETED";
+  TaskStatus2["ABORTING"] = "ABORTING";
+  TaskStatus2["FAILED"] = "FAILED";
+})(TaskStatus ||= {});
+
+// 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;
+  provenance = {};
+  status = "PENDING" /* PENDING */;
+  error;
+  reset() {
+    this.status = "PENDING" /* PENDING */;
+    this.error = undefined;
+    this.value = undefined;
+    this.provenance = {};
+    this.emit("reset");
+    this.emit("status", this.status);
+  }
+  setStatus(status) {
+    if (status === this.status)
+      return;
+    this.status = status;
+    switch (status) {
+      case "PROCESSING" /* PROCESSING */:
+        this.emit("start");
+        break;
+      case "COMPLETED" /* COMPLETED */:
+        this.emit("complete");
+        break;
+      case "ABORTING" /* ABORTING */:
+        this.emit("abort");
+        break;
+      case "PENDING" /* PENDING */:
+        this.emit("reset");
+        break;
+      case "FAILED" /* FAILED */:
+        this.emit("error", this.error);
+        break;
+      case "DISABLED" /* DISABLED */:
+        this.emit("disabled");
+        break;
+    }
+    this.emit("status", this.status);
+  }
+  setPortData(entireDataBlock, nodeProvenance) {
+    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];
+    }
+    if (nodeProvenance)
+      this.provenance = nodeProvenance;
+  }
+  getPortData() {
+    if (this.targetTaskPortId === DATAFLOW_ALL_PORTS) {
+      return this.value;
+    } else if (this.targetTaskPortId === DATAFLOW_ERROR_PORT) {
+      return { [DATAFLOW_ERROR_PORT]: this.error };
+    } else {
+      return { [this.targetTaskPortId]: this.value };
+    }
+  }
+  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/TaskGraphRunner.ts
+import {
+  collectPropertyValues,
+  globalServiceRegistry as globalServiceRegistry2,
+  uuid4 as uuid42
+} 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/Task.ts
+import {
+  compileSchema,
+  deepEqual,
+  EventEmitter as EventEmitter3,
+  uuid4
+} 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 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 { globalServiceRegistry } from "@workglow/util";
+class TaskRunner {
+  running = false;
+  reactiveRunning = false;
+  nodeProvenance = {};
+  task;
+  abortController;
+  outputCache;
+  constructor(task) {
+    this.task = task;
+    this.own = this.own.bind(this);
+    this.handleProgress = this.handleProgress.bind(this);
+  }
+  async run(overrides = {}, config = {}) {
+    await this.handleStart(config);
+    try {
+      this.task.setInput(overrides);
+      const 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;
+      if (this.task.cacheable) {
+        outputs = await this.outputCache?.getOutput(this.task.type, inputs);
+        if (outputs) {
+          this.task.runOutputData = await this.executeTaskReactive(inputs, outputs);
+        }
+      }
+      if (!outputs) {
+        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 err;
+    }
+  }
+  async runReactive(overrides = {}) {
+    if (this.task.status === "PROCESSING" /* PROCESSING */) {
+      return this.task.runOutputData;
+    }
+    this.task.setInput(overrides);
+    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),
+      nodeProvenance: this.nodeProvenance,
+      own: this.own
+    });
+    return await this.executeTaskReactive(input, result || {});
+  }
+  async executeTaskReactive(input, output) {
+    const reactiveResult = await this.task.executeReactive(input, output, { own: this.own });
+    return Object.keys(reactiveResult || {}) >= Object.keys(output || {}) ? reactiveResult : output ?? {};
+  }
+  async handleStart(config = {}) {
+    if (this.task.status === "PROCESSING" /* PROCESSING */)
+      return;
+    this.nodeProvenance = {};
+    this.running = true;
+    this.task.startedAt = new Date;
+    this.task.progress = 0;
+    this.task.status = "PROCESSING" /* PROCESSING */;
+    this.abortController = new AbortController;
+    this.abortController.signal.addEventListener("abort", () => {
+      this.handleAbort();
+    });
+    this.nodeProvenance = config.nodeProvenance ?? {};
+    const cache = this.task.config.outputCache ?? config.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;
+    }
+    if (config.updateProgress) {
+      this.updateProgress = config.updateProgress;
+    }
+    this.task.emit("start");
+    this.task.emit("status", this.task.status);
+  }
+  updateProgress = async (task, progress, message, ...args) => {};
+  async handleStartReactive() {
+    this.reactiveRunning = true;
+  }
+  async handleAbort() {
+    if (this.task.status === "ABORTING" /* ABORTING */)
+      return;
+    this.task.status = "ABORTING" /* ABORTING */;
+    this.task.progress = 100;
+    this.task.error = new TaskAbortedError;
+    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 === "COMPLETED" /* COMPLETED */)
+      return;
+    this.task.completedAt = new Date;
+    this.task.progress = 100;
+    this.task.status = "COMPLETED" /* COMPLETED */;
+    this.abortController = undefined;
+    this.nodeProvenance = {};
+    this.task.emit("complete");
+    this.task.emit("status", this.task.status);
+  }
+  async handleCompleteReactive() {
+    this.reactiveRunning = false;
+  }
+  async handleDisable() {
+    if (this.task.status === "DISABLED" /* DISABLED */)
+      return;
+    this.task.status = "DISABLED" /* DISABLED */;
+    this.task.progress = 100;
+    this.task.completedAt = new Date;
+    this.abortController = undefined;
+    this.nodeProvenance = {};
+    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 === "FAILED" /* FAILED */)
+      return;
+    if (this.task.hasChildren()) {
+      this.task.subGraph.abort();
+    }
+    this.task.completedAt = new Date;
+    this.task.progress = 100;
+    this.task.status = "FAILED" /* FAILED */;
+    this.task.error = err instanceof TaskError ? err : new TaskFailedError(err?.message || "Task failed");
+    this.abortController = undefined;
+    this.nodeProvenance = {};
+    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 cacheable = true;
+  static hasDynamicSchemas = false;
+  static inputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    };
+  }
+  static outputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    };
+  }
+  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 = {}) {
+    return this.runner.run(overrides);
+  }
+  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();
+  }
+  get type() {
+    return this.constructor.type;
+  }
+  get category() {
+    return this.constructor.category;
+  }
+  get title() {
+    return this.constructor.title;
+  }
+  get cacheable() {
+    return this.config?.cacheable ?? this.constructor.cacheable;
+  }
+  defaults;
+  runInputData = {};
+  runOutputData = {};
+  config;
+  status = "PENDING" /* PENDING */;
+  progress = 0;
+  createdAt = new Date;
+  startedAt;
+  completedAt;
+  error;
+  get events() {
+    if (!this._events) {
+      this._events = new EventEmitter3;
+    }
+    return this._events;
+  }
+  _events;
+  nodeProvenance = {};
+  constructor(callerDefaultInputs = {}, config = {}) {
+    const inputDefaults = this.getDefaultInputsFromStaticInputDefinitions();
+    const mergedDefaults = Object.assign(inputDefaults, callerDefaultInputs);
+    this.defaults = this.stripSymbols(mergedDefaults);
+    this.resetInputData();
+    const name = this.title || new.target.title || new.target.name;
+    this.config = Object.assign({
+      id: uuid4(),
+      name
+    }, config);
+  }
+  getDefaultInputsFromStaticInputDefinitions() {
+    const schema = this.inputSchema();
+    if (typeof schema === "boolean") {
+      return {};
+    }
+    try {
+      const compiledSchema = this.getInputSchemaNode(this.type);
+      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() {
+    try {
+      this.runInputData = structuredClone(this.defaults);
+    } catch (err) {
+      this.runInputData = JSON.parse(JSON.stringify(this.defaults));
+    }
+  }
+  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 === true) {
+      for (const [inputId, value] of Object.entries(input)) {
+        if (value !== undefined && !(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]];
+          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 === true) {
+      for (const [inputId, value] of Object.entries(overrides)) {
+        if (value !== undefined && !(inputId in properties)) {
+          if (!deepEqual(this.runInputData[inputId], value)) {
+            this.runInputData[inputId] = value;
+            changed = true;
+          }
+        }
+      }
+    }
+    return changed;
+  }
+  async narrowInput(input) {
+    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 _inputSchemaNode = new Map;
+  static generateInputSchemaNode(schema) {
+    if (typeof schema === "boolean") {
+      if (schema === false) {
+        return compileSchema({ not: {} });
+      }
+      return compileSchema({});
+    }
+    return compileSchema(schema);
+  }
+  static getInputSchemaNode(type) {
+    if (!this._inputSchemaNode.has(type)) {
+      const dataPortSchema = this.inputSchema();
+      const schemaNode = this.generateInputSchemaNode(dataPortSchema);
+      try {
+        this._inputSchemaNode.set(type, schemaNode);
+      } catch (error) {
+        console.warn(`Failed to compile input schema for ${this.type}, falling back to permissive validation:`, error);
+        this._inputSchemaNode.set(type, compileSchema({}));
+      }
+    }
+    return this._inputSchemaNode.get(type);
+  }
+  getInputSchemaNode(type) {
+    return this.constructor.getInputSchemaNode(type);
+  }
+  async validateInput(input) {
+    const schemaNode = this.getInputSchemaNode(this.type);
+    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(input)} does not match schema: ${errorMessages.join(", ")}`);
+    }
+    return true;
+  }
+  id() {
+    return this.config.id;
+  }
+  getProvenance() {
+    return this.config.provenance ?? {};
+  }
+  stripSymbols(obj) {
+    if (obj === null || obj === undefined) {
+      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() {
+    const provenance = this.getProvenance();
+    const extras = this.config.extras;
+    let json = this.stripSymbols({
+      id: this.config.id,
+      type: this.type,
+      input: this.defaults,
+      ...Object.keys(provenance).length ? { provenance } : {},
+      ...extras && Object.keys(extras).length ? { extras } : {}
+    });
+    return json;
+  }
+  toDependencyJSON() {
+    const json = this.toJSON();
+    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.config.id);
+      }
+    }
+    this.events.emit("regenerate");
+  }
+}
+
+// src/task/ConditionalTask.ts
+class ConditionalTask extends Task {
+  static type = "ConditionalTask";
+  static category = "Flow Control";
+  static title = "Conditional Task";
+  static hasDynamicSchemas = true;
+  activeBranches = new Set;
+  async execute(input, context) {
+    if (context.signal?.aborted) {
+      return;
+    }
+    this.activeBranches.clear();
+    const branches = this.config.branches ?? [];
+    const isExclusive = this.config.exclusive ?? true;
+    for (const branch of branches) {
+      try {
+        const isActive = branch.condition(input);
+        if (isActive) {
+          this.activeBranches.add(branch.id);
+          if (isExclusive) {
+            break;
+          }
+        }
+      } catch (error) {
+        console.warn(`Condition evaluation failed for branch "${branch.id}":`, error);
+      }
+    }
+    if (this.activeBranches.size === 0 && this.config.defaultBranch) {
+      const defaultBranchExists = branches.some((b) => b.id === this.config.defaultBranch);
+      if (defaultBranchExists) {
+        this.activeBranches.add(this.config.defaultBranch);
+      }
+    }
+    return this.buildOutput(input);
+  }
+  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) {}
+  reset() {
+    this.sortedNodes = this.dag.topologicallySortedNodes();
+    this.currentIndex = 0;
+  }
+}
+
+class DependencyBasedScheduler {
+  dag;
+  completedTasks;
+  pendingTasks;
+  nextResolver = null;
+  constructor(dag) {
+    this.dag = dag;
+    this.completedTasks = new Set;
+    this.pendingTasks = new Set;
+    this.reset();
+  }
+  isTaskReady(task) {
+    if (task.status === "DISABLED" /* DISABLED */) {
+      return false;
+    }
+    const sourceDataflows = this.dag.getSourceDataflows(task.config.id);
+    if (sourceDataflows.length > 0) {
+      const allIncomingDisabled = sourceDataflows.every((df) => df.status === "DISABLED" /* DISABLED */);
+      if (allIncomingDisabled) {
+        return false;
+      }
+    }
+    const dependencies = sourceDataflows.filter((df) => df.status !== "DISABLED" /* DISABLED */).map((dataflow) => dataflow.sourceTaskId);
+    return dependencies.every((dep) => this.completedTasks.has(dep));
+  }
+  async waitForNextTask() {
+    if (this.pendingTasks.size === 0)
+      return null;
+    for (const task of Array.from(this.pendingTasks)) {
+      if (task.status === "DISABLED" /* 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 === "DISABLED" /* 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);
+      }
+    }
+  }
+  reset() {
+    this.completedTasks.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;
+  provenanceInput;
+  graph;
+  outputCache;
+  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;
+    this.provenanceInput = new Map;
+    graph.outputCache = outputCache;
+    this.handleProgress = this.handleProgress.bind(this);
+  }
+  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.config.id).length === 0;
+        const runAsync = async () => {
+          try {
+            const taskInput = isRootTask ? input : this.filterInputForTask(task, input);
+            const taskPromise = this.runTaskWithProvenance(task, taskInput, config?.parentProvenance || {});
+            this.inProgressTasks.set(task.config.id, taskPromise);
+            const taskResult = await taskPromise;
+            if (this.graph.getTargetDataflows(task.config.id).length === 0) {
+              results.push(taskResult);
+            }
+          } catch (error2) {
+            this.failedTaskErrors.set(task.config.id, error2);
+          } finally {
+            this.pushStatusFromNodeToEdges(this.graph, task);
+            this.pushErrorFromNodeToEdges(this.graph, task);
+            this.processScheduler.onTaskCompleted(task.config.id);
+          }
+        };
+        this.inProgressFunctions.set(Symbol(task.config.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() {
+    await this.handleStartReactive();
+    const results = [];
+    try {
+      for await (const task of this.reactiveScheduler.tasks()) {
+        if (task.status === "PENDING" /* PENDING */) {
+          task.resetInputData();
+          this.copyInputFromEdgesToNode(task);
+        }
+        const taskResult = await task.runReactive();
+        await this.pushOutputFromNodeToEdges(task, taskResult);
+        if (this.graph.getTargetDataflows(task.config.id).length === 0) {
+          results.push({
+            id: task.config.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.config.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.config.id);
+    for (const dataflow of dataflows) {
+      this.addInputData(task, dataflow.getPortData());
+    }
+  }
+  getInputProvenance(node) {
+    const nodeProvenance = {};
+    this.graph.getSourceDataflows(node.config.id).forEach((dataflow) => {
+      Object.assign(nodeProvenance, dataflow.provenance);
+    });
+    return nodeProvenance;
+  }
+  async pushOutputFromNodeToEdges(node, results, nodeProvenance) {
+    const dataflows = this.graph.getTargetDataflows(node.config.id);
+    for (const dataflow of dataflows) {
+      const compatibility = dataflow.semanticallyCompatible(this.graph, dataflow);
+      if (compatibility === "static") {
+        dataflow.setPortData(results, nodeProvenance);
+      } else if (compatibility === "runtime") {
+        const task = this.graph.getTask(dataflow.targetTaskId);
+        const narrowed = await task.narrowInput({ ...results });
+        dataflow.setPortData(narrowed, nodeProvenance);
+      } else {}
+    }
+  }
+  pushStatusFromNodeToEdges(graph, node, status) {
+    if (!node?.config?.id)
+      return;
+    const dataflows = graph.getTargetDataflows(node.config.id);
+    const effectiveStatus = status ?? node.status;
+    if (node instanceof ConditionalTask && effectiveStatus === "COMPLETED" /* 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("COMPLETED" /* COMPLETED */);
+          } else {
+            dataflow.setStatus("DISABLED" /* 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.config.id).forEach((dataflow) => {
+      dataflow.error = node.error;
+    });
+  }
+  propagateDisabledStatus(graph) {
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const task of graph.getTasks()) {
+        if (task.status !== "PENDING" /* PENDING */) {
+          continue;
+        }
+        const incomingDataflows = graph.getSourceDataflows(task.config.id);
+        if (incomingDataflows.length === 0) {
+          continue;
+        }
+        const allDisabled = incomingDataflows.every((df) => df.status === "DISABLED" /* DISABLED */);
+        if (allDisabled) {
+          task.status = "DISABLED" /* DISABLED */;
+          task.progress = 100;
+          task.completedAt = new Date;
+          task.emit("disabled");
+          task.emit("status", task.status);
+          graph.getTargetDataflows(task.config.id).forEach((dataflow) => {
+            dataflow.setStatus("DISABLED" /* DISABLED */);
+          });
+          this.processScheduler.onTaskCompleted(task.config.id);
+          changed = true;
+        }
+      }
+    }
+  }
+  async runTaskWithProvenance(task, input, parentProvenance) {
+    const nodeProvenance = {
+      ...parentProvenance,
+      ...this.getInputProvenance(task),
+      ...task.getProvenance()
+    };
+    this.provenanceInput.set(task.config.id, nodeProvenance);
+    this.copyInputFromEdgesToNode(task);
+    const results = await task.runner.run(input, {
+      nodeProvenance,
+      outputCache: this.outputCache,
+      updateProgress: async (task2, progress, message, ...args) => await this.handleProgress(task2, progress, message, ...args)
+    });
+    await this.pushOutputFromNodeToEdges(task, results, nodeProvenance);
+    return {
+      id: task.config.id,
+      type: task.constructor.runtype || task.constructor.type,
+      data: results
+    };
+  }
+  resetTask(graph, task, runId) {
+    task.status = "PENDING" /* PENDING */;
+    task.resetInputData();
+    task.runOutputData = {};
+    task.error = undefined;
+    task.progress = 0;
+    if (task.config) {
+      task.config.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?.outputCache !== undefined) {
+      if (typeof config.outputCache === "boolean") {
+        if (config.outputCache === true) {
+          this.outputCache = globalServiceRegistry2.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.resetGraph(this.graph, uuid42());
+    this.processScheduler.reset();
+    this.inProgressTasks.clear();
+    this.inProgressFunctions.clear();
+    this.failedTaskErrors.clear();
+    this.graph.emit("start");
+  }
+  async handleStartReactive() {
+    if (this.reactiveRunning) {
+      throw new TaskConfigurationError("Graph is already running reactively");
+    }
+    this.reactiveScheduler.reset();
+    this.reactiveRunning = true;
+  }
+  async handleComplete() {
+    this.running = false;
+    this.graph.emit("complete");
+  }
+  async handleCompleteReactive() {
+    this.reactiveRunning = false;
+  }
+  async handleError(error) {
+    await Promise.allSettled(this.graph.getTasks().map(async (task) => {
+      if (["PROCESSING" /* PROCESSING */].includes(task.status)) {
+        task.abort();
+      }
+    }));
+    this.running = false;
+    this.graph.emit("error", error);
+  }
+  async handleErrorReactive() {
+    this.reactiveRunning = false;
+  }
+  async handleAbort() {
+    this.graph.getTasks().map(async (task) => {
+      if (["PROCESSING" /* PROCESSING */].includes(task.status)) {
+        task.abort();
+      }
+    });
+    this.running = false;
+    this.graph.emit("abort");
+  }
+  async handleAbortReactive() {
+    this.reactiveRunning = false;
+  }
+  async handleDisable() {
+    await Promise.allSettled(this.graph.getTasks().map(async (task) => {
+      if (["PENDING" /* PENDING */].includes(task.status)) {
+        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, task.getProvenance());
+    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, {
+      parentProvenance: this.nodeProvenance || {},
+      parentSignal: this.abortController?.signal,
+      outputCache: this.outputCache
+    });
+    unsubscribe();
+    return results;
+  }
+  async executeTaskChildrenReactive() {
+    return this.task.subGraph.runReactive();
+  }
+  async handleDisable() {
+    if (this.task.hasChildren()) {
+      await this.task.subGraph.disable();
+    }
+    super.handleDisable();
+  }
+  fixInput(input) {
+    const flattenedInput = Object.entries(input).reduce((acc, [key, value]) => {
+      if (Array.isArray(value)) {
+        return { ...acc, [key]: value[0] };
+      }
+      return { ...acc, [key]: value };
+    }, {});
+    return flattenedInput;
+  }
+  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(this.fixInput(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(this.fixInput(input), output);
+      this.task.runOutputData = reactiveResults ?? output ?? {};
+    }
+    return this.task.runOutputData;
+  }
+}
+
+// src/task/GraphAsTask.ts
+class GraphAsTask extends Task {
+  static type = "GraphAsTask";
+  static category = "Hidden";
+  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;
+  }
+  get compoundMerge() {
+    return this.config?.compoundMerge || this.constructor.compoundMerge;
+  }
+  get cacheable() {
+    return this.config?.cacheable ?? (this.constructor.cacheable && !this.hasChildren());
+  }
+  inputSchema() {
+    if (!this.hasChildren()) {
+      return this.constructor.inputSchema();
+    }
+    const properties = {};
+    const required = [];
+    const tasks = this.subGraph.getTasks();
+    const startingNodes = tasks.filter((task) => this.subGraph.getSourceDataflows(task.config.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);
+          }
+        }
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      ...required.length > 0 ? { required } : {},
+      additionalProperties: false
+    };
+  }
+  _inputSchemaNode;
+  getInputSchemaNode(type) {
+    if (!this._inputSchemaNode) {
+      const dataPortSchema = this.inputSchema();
+      const schemaNode = Task.generateInputSchemaNode(dataPortSchema);
+      try {
+        this._inputSchemaNode = schemaNode;
+      } catch (error) {
+        console.warn(`Failed to compile input schema for ${type}, falling back to permissive validation:`, error);
+        this._inputSchemaNode = compileSchema2({});
+      }
+    }
+    return this._inputSchemaNode;
+  }
+  calculateNodeDepths() {
+    const depths = new Map;
+    const tasks = this.subGraph.getTasks();
+    for (const task of tasks) {
+      depths.set(task.config.id, 0);
+    }
+    const sortedTasks = this.subGraph.topologicallySortedNodes();
+    for (const task of sortedTasks) {
+      const currentDepth = depths.get(task.config.id) || 0;
+      const targetTasks = this.subGraph.getTargetTasks(task.config.id);
+      for (const targetTask of targetTasks) {
+        const targetDepth = depths.get(targetTask.config.id) || 0;
+        depths.set(targetTask.config.id, Math.max(targetDepth, currentDepth + 1));
+      }
+    }
+    return depths;
+  }
+  outputSchema() {
+    if (!this.hasChildren()) {
+      return this.constructor.outputSchema();
+    }
+    const properties = {};
+    const required = [];
+    const tasks = this.subGraph.getTasks();
+    const endingNodes = tasks.filter((task) => this.subGraph.getTargetDataflows(task.config.id).length === 0);
+    const depths = this.calculateNodeDepths();
+    const maxDepth = Math.max(...endingNodes.map((task) => depths.get(task.config.id) || 0));
+    const lastLevelNodes = endingNodes.filter((task) => depths.get(task.config.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;
+        }
+      }
+    }
+    for (const [outputName, count] of Object.entries(propertyCount)) {
+      const outputProp = propertySchema[outputName];
+      if (lastLevelNodes.length === 1) {
+        properties[outputName] = outputProp;
+      } else {
+        properties[outputName] = {
+          type: "array",
+          items: outputProp
+        };
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      ...required.length > 0 ? { required } : {},
+      additionalProperties: false
+    };
+  }
+  resetInputData() {
+    super.resetInputData();
+    if (this.hasChildren()) {
+      this.subGraph.getTasks().forEach((node) => {
+        node.resetInputData();
+      });
+      this.subGraph.getDataflows().forEach((dataflow) => {
+        dataflow.reset();
+      });
+    }
+  }
+  regenerateGraph() {
+    this._inputSchemaNode = undefined;
+    this.events.emit("regenerate");
+  }
+  toJSON() {
+    let json = super.toJSON();
+    const hasChildren = this.hasChildren();
+    if (hasChildren) {
+      json = {
+        ...json,
+        merge: this.compoundMerge,
+        subgraph: this.subGraph.toJSON()
+      };
+    }
+    return json;
+  }
+  toDependencyJSON() {
+    const json = this.toJSON();
+    if (this.hasChildren()) {
+      if ("subgraph" in json) {
+        delete json.subgraph;
+      }
+      return { ...json, subtasks: this.subGraph.toDependencyJSON() };
+    }
+    return json;
+  }
+}
+
+// src/task-graph/Workflow.ts
+import { EventEmitter as EventEmitter4 } from "@workglow/util";
+class WorkflowTask extends GraphAsTask {
+  static type = "Workflow";
+  static compoundMerge = PROPERTY_ARRAY;
+}
+var taskIdCounter = 0;
+
+class Workflow {
+  constructor(repository) {
+    this._repository = repository;
+    this._graph = new TaskGraph({
+      outputCache: this._repository
+    });
+    this._onChanged = this._onChanged.bind(this);
+    this.setupEvents();
+  }
+  _graph;
+  _dataFlows = [];
+  _error = "";
+  _repository;
+  _abortController;
+  events = new EventEmitter4;
+  static createWorkflow(taskClass) {
+    const helper = function(input = {}, config = {}) {
+      this._error = "";
+      const parent = getLastTask(this);
+      taskIdCounter++;
+      const task = this.addTask(taskClass, input, { id: String(taskIdCounter), ...config });
+      if (this._dataFlows.length > 0) {
+        this._dataFlows.forEach((dataflow) => {
+          const taskSchema = task.inputSchema();
+          if (typeof taskSchema !== "boolean" && taskSchema.properties?.[dataflow.targetTaskPortId] === undefined || taskSchema === true && dataflow.targetTaskPortId !== DATAFLOW_ALL_PORTS) {
+            this._error = `Input ${dataflow.targetTaskPortId} not found on task ${task.config.id}`;
+            console.error(this._error);
+            return;
+          }
+          dataflow.targetTaskId = task.config.id;
+          this.graph.addDataflow(dataflow);
+        });
+        this._dataFlows = [];
+      }
+      if (parent && this.graph.getTargetDataflows(parent.config.id).length === 0) {
+        const matches = new Map;
+        const sourceSchema = parent.outputSchema();
+        const targetSchema = task.inputSchema();
+        const makeMatch = (comparator) => {
+          if (typeof sourceSchema === "boolean" || typeof targetSchema === "boolean") {
+            return matches;
+          }
+          for (const [fromOutputPortId, fromPortOutputSchema] of Object.entries(sourceSchema.properties || {})) {
+            for (const [toInputPortId, toPortInputSchema] of Object.entries(targetSchema.properties || {})) {
+              if (!matches.has(toInputPortId) && comparator([fromOutputPortId, fromPortOutputSchema], [toInputPortId, toPortInputSchema])) {
+                matches.set(toInputPortId, fromOutputPortId);
+                this.connect(parent.config.id, fromOutputPortId, task.config.id, toInputPortId);
+              }
+            }
+          }
+          return matches;
+        };
+        makeMatch(([fromOutputPortId, fromPortOutputSchema], [toInputPortId, toPortInputSchema]) => {
+          if (typeof fromPortOutputSchema === "boolean" || typeof toPortInputSchema === "boolean") {
+            if (fromPortOutputSchema === true && toPortInputSchema === true) {
+              return true;
+            }
+            return false;
+          }
+          const idTypeMatch = fromPortOutputSchema.$id !== undefined && fromPortOutputSchema.$id === toPortInputSchema.$id;
+          const idTypeBlank = fromPortOutputSchema.$id === undefined && toPortInputSchema.$id === undefined;
+          const typeMatch = idTypeBlank && (fromPortOutputSchema.type === toPortInputSchema.type || (toPortInputSchema.oneOf?.some((i) => i.type == fromPortOutputSchema.type) ?? false));
+          const outputPortIdMatch = fromOutputPortId === toInputPortId;
+          const outputPortIdOutputInput = fromOutputPortId === "output" && toInputPortId === "input";
+          const portIdsCompatible = outputPortIdMatch || outputPortIdOutputInput;
+          return (idTypeMatch || typeMatch) && portIdsCompatible;
+        });
+        if (matches.size === 0) {
+          this._error = `Could not find a match between the outputs of ${parent.type} and the inputs of ${task.type}. ` + `You now need to connect the outputs to the inputs via connect() manually before adding this task. Task not added.`;
+          console.error(this._error);
+          this.graph.removeTask(task.config.id);
+        }
+      }
+      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 = {}) {
+    this.events.emit("start");
+    this._abortController = new AbortController;
+    try {
+      const output = await this.graph.run(input, {
+        parentSignal: this._abortController.signal,
+        parentProvenance: {},
+        outputCache: this._repository
+      });
+      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 {
+      this._abortController = undefined;
+    }
+  }
+  async abort() {
+    this._abortController?.abort();
+  }
+  pop() {
+    this._error = "";
+    const nodes = this._graph.getTasks();
+    if (nodes.length === 0) {
+      this._error = "No tasks to remove";
+      console.error(this._error);
+      return this;
+    }
+    const lastNode = nodes[nodes.length - 1];
+    this._graph.removeTask(lastNode.config.id);
+    return this;
+  }
+  toJSON() {
+    return this._graph.toJSON();
+  }
+  toDependencyJSON() {
+    return this._graph.toDependencyJSON();
+  }
+  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;
+      console.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.config.id} has schema 'false' and outputs nothing`;
+        this._error = errorMsg;
+        console.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.config.id}`;
+      this._error = errorMsg;
+      console.error(this._error);
+      throw new WorkflowError(errorMsg);
+    }
+    this._dataFlows.push(new Dataflow(lastNode.config.id, source, undefined, target));
+    return this;
+  }
+  toTaskGraph() {
+    return this._graph;
+  }
+  toTask() {
+    const task = new WorkflowTask;
+    task.subGraph = this.toTaskGraph();
+    return task;
+  }
+  reset() {
+    taskIdCounter = 0;
+    this.clearEvents();
+    this._graph = new TaskGraph({
+      outputCache: this._repository
+    });
+    this._dataFlows = [];
+    this._error = "";
+    this.setupEvents();
+    this.events.emit("changed", undefined);
+    this.events.emit("reset");
+    return this;
+  }
+  setupEvents() {
+    this._graph.on("task_added", this._onChanged);
+    this._graph.on("task_replaced", this._onChanged);
+    this._graph.on("task_removed", this._onChanged);
+    this._graph.on("dataflow_added", this._onChanged);
+    this._graph.on("dataflow_replaced", this._onChanged);
+    this._graph.on("dataflow_removed", this._onChanged);
+  }
+  clearEvents() {
+    this._graph.off("task_added", this._onChanged);
+    this._graph.off("task_replaced", this._onChanged);
+    this._graph.off("task_removed", this._onChanged);
+    this._graph.off("dataflow_added", this._onChanged);
+    this._graph.off("dataflow_replaced", this._onChanged);
+    this._graph.off("dataflow_removed", this._onChanged);
+  }
+  _onChanged(id) {
+    this.events.emit("changed", id);
+  }
+  connect(sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId) {
+    const sourceTask = this.graph.getTask(sourceTaskId);
+    const targetTask = this.graph.getTask(targetTaskId);
+    if (!sourceTask || !targetTask) {
+      throw new WorkflowError("Source or target task not found");
+    }
+    const sourceSchema = sourceTask.outputSchema();
+    const targetSchema = targetTask.inputSchema();
+    if (typeof sourceSchema === "boolean") {
+      if (sourceSchema === false) {
+        throw new WorkflowError(`Source task has schema 'false' and outputs nothing`);
+      }
+    } else if (!sourceSchema.properties?.[sourceTaskPortId]) {
+      throw new WorkflowError(`Output ${sourceTaskPortId} not found on source task`);
+    }
+    if (typeof targetSchema === "boolean") {
+      if (targetSchema === false) {
+        throw new WorkflowError(`Target task has schema 'false' and accepts no inputs`);
+      }
+    } 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;
+  }
+  addTask(taskClass, input, config) {
+    const task = new taskClass(input, config);
+    const id = this.graph.addTask(task);
+    this.events.emit("changed", id);
+    return task;
+  }
+}
+function CreateWorkflow(taskClass) {
+  return Workflow.createWorkflow(taskClass);
+}
+
+// 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");
+    });
+    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) {
+    if (config.isOwned) {
+      return new OwnGraphTask({}, { ...config, subGraph: arg });
+    } else {
+      return new GraphTask({}, { ...config, subGraph: arg });
+    }
+  }
+  if (arg instanceof Workflow) {
+    if (config.isOwned) {
+      return new OwnWorkflowTask({}, { ...config, subGraph: arg.graph });
+    } else {
+      return new WorkflowTask2({}, { ...config, subGraph: arg.graph });
+    }
+  }
+  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.config.id, "*", target.config.id, "*"));
+}
+function pipe(args, workflow = new Workflow) {
+  let previousTask = getLastTask(workflow);
+  const tasks = args.map((arg) => ensureTask(arg));
+  tasks.forEach((task) => {
+    workflow.graph.addTask(task);
+    if (previousTask) {
+      connect(previousTask, task, workflow);
+    }
+    previousTask = task;
+  });
+  return workflow;
+}
+function parallel(args, mergeFn = PROPERTY_ARRAY, workflow = new Workflow) {
+  let previousTask = getLastTask(workflow);
+  const tasks = args.map((arg) => ensureTask(arg));
+  const input = {};
+  const config = {
+    compoundMerge: mergeFn
+  };
+  const name = `‖${args.map((arg) => "\uD835\uDC53").join("‖")}‖`;
+
+  class ParallelTask extends GraphAsTask {
+    static type = name;
+  }
+  const mergeTask = new ParallelTask(input, config);
+  mergeTask.subGraph.addTasks(tasks);
+  workflow.graph.addTask(mergeTask);
+  if (previousTask) {
+    connect(previousTask, mergeTask, workflow);
+  }
+  return workflow;
+}
+
+// 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-graph/TaskGraph.ts
+class TaskGraphDAG extends DirectedAcyclicGraph {
+  constructor() {
+    super((task) => task.config.id, (dataflow) => dataflow.id);
+  }
+}
+
+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,
+      parentProvenance: config?.parentProvenance || {},
+      parentSignal: config?.parentSignal || undefined
+    });
+  }
+  runReactive() {
+    return this.runner.runGraphReactive();
+  }
+  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, uuid43());
+  }
+  toJSON() {
+    const tasks = this.getTasks().map((node) => node.toJSON());
+    const dataflows = this.getDataflows().map((df) => df.toJSON());
+    return {
+      tasks,
+      dataflows
+    };
+  }
+  toDependencyJSON() {
+    const tasks = this.getTasks().flatMap((node) => node.toDependencyJSON());
+    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 }
+          ];
+        }
+      }
+    });
+    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);
+  }
+  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].config.id, inputHandle, tasks[i + 1].config.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/ArrayTask.ts
+class ArrayTask extends GraphAsTask {
+  static type = "ArrayTask";
+  static compoundMerge = PROPERTY_ARRAY;
+  inputSchema() {
+    return this.constructor.inputSchema();
+  }
+  outputSchema() {
+    return this.constructor.outputSchema();
+  }
+  regenerateGraph() {
+    const arrayInputs = new Map;
+    let hasArrayInputs = false;
+    const inputSchema = this.inputSchema();
+    if (typeof inputSchema !== "boolean") {
+      const keys = Object.keys(inputSchema.properties || {});
+      for (const inputId of keys) {
+        const inputValue = this.runInputData[inputId];
+        const inputDef = inputSchema.properties?.[inputId];
+        if (typeof inputDef === "object" && inputDef !== null && "x-replicate" in inputDef && inputDef["x-replicate"] === true && Array.isArray(inputValue) && inputValue.length > 1) {
+          arrayInputs.set(inputId, inputValue);
+          hasArrayInputs = true;
+        }
+      }
+    }
+    this.subGraph = new TaskGraph;
+    if (!hasArrayInputs) {
+      super.regenerateGraph();
+      return;
+    }
+    this.subGraph = new TaskGraph;
+    const inputIds = Array.from(arrayInputs.keys());
+    const inputObject = Object.fromEntries(arrayInputs);
+    const combinations = this.generateCombinations(inputObject, inputIds);
+    const tasks = combinations.map((combination) => {
+      const { id, name, ...rest } = this.config;
+      const task = new this.constructor({ ...this.defaults, ...this.runInputData, ...combination }, { ...rest, id: `${id}_${uuid44()}` });
+      return task;
+    });
+    this.subGraph.addTasks(tasks);
+    super.regenerateGraph();
+  }
+  generateCombinations(input, inputMakeArray) {
+    const arraysToCombine = inputMakeArray.map((key) => Array.isArray(input[key]) ? input[key] : []);
+    const indices = arraysToCombine.map(() => 0);
+    const combinations = [];
+    let done = false;
+    while (!done) {
+      combinations.push([...indices]);
+      for (let i = indices.length - 1;i >= 0; i--) {
+        if (++indices[i] < arraysToCombine[i].length)
+          break;
+        if (i === 0)
+          done = true;
+        else
+          indices[i] = 0;
+      }
+    }
+    const combos = combinations.map((combination) => {
+      const result = { ...input };
+      combination.forEach((valueIndex, arrayIndex) => {
+        const key = inputMakeArray[arrayIndex];
+        if (Array.isArray(input[key]))
+          result[key] = input[key][valueIndex];
+      });
+      return result;
+    });
+    return combos;
+  }
+  toJSON() {
+    const { subgraph, ...result } = super.toJSON();
+    return result;
+  }
+  toDependencyJSON() {
+    const { subtasks, ...result } = super.toDependencyJSON();
+    return result;
+  }
+  get runner() {
+    if (!this._runner) {
+      this._runner = new ArrayTaskRunner(this);
+    }
+    return this._runner;
+  }
+}
+
+class ArrayTaskRunner extends GraphAsTaskRunner {
+  async executeTaskChildren(_input) {
+    return super.executeTaskChildren({});
+  }
+}
+// src/task/JobQueueFactory.ts
+import { JobQueue } 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");
+var defaultJobQueueFactory = async ({ queueName, jobClass, options }) => {
+  const queueOptions = {
+    ...options ?? {}
+  };
+  queueOptions.storage ??= new InMemoryQueueStorage(queueName);
+  return new JobQueue(queueName, jobClass, queueOptions);
+};
+function registerJobQueueFactory(factory) {
+  globalServiceRegistry3.registerInstance(JOB_QUEUE_FACTORY, factory);
+}
+function createJobQueueFactoryFromClass(QueueCtor, defaultOptions = {}) {
+  return ({ queueName, jobClass, options }) => {
+    const mergedOptions = {
+      ...defaultOptions,
+      ...options ?? {}
+    };
+    return new QueueCtor(queueName, jobClass, mergedOptions);
+  };
+}
+function getJobQueueFactory() {
+  if (!globalServiceRegistry3.has(JOB_QUEUE_FACTORY)) {
+    registerJobQueueFactory(defaultJobQueueFactory);
+  }
+  return globalServiceRegistry3.get(JOB_QUEUE_FACTORY);
+}
+if (!globalServiceRegistry3.has(JOB_QUEUE_FACTORY)) {
+  registerJobQueueFactory(defaultJobQueueFactory);
+}
+// src/task/JobQueueTask.ts
+import { Job as Job2 } from "@workglow/job-queue";
+
+// src/task/TaskQueueRegistry.ts
+var taskQueueRegistry = null;
+
+class TaskQueueRegistry {
+  queues = new Map;
+  registerQueue(jobQueue) {
+    if (this.queues.has(jobQueue.queueName)) {
+      throw new Error(`Queue with name ${jobQueue.queueName} already exists`);
+    }
+    this.queues.set(jobQueue.queueName, jobQueue);
+  }
+  getQueue(queue) {
+    return this.queues.get(queue);
+  }
+  startQueues() {
+    for (const queue of this.queues.values()) {
+      queue.start();
+    }
+    return this;
+  }
+  stopQueues() {
+    for (const queue of this.queues.values()) {
+      queue.stop();
+    }
+    return this;
+  }
+  clearQueues() {
+    for (const queue of this.queues.values()) {
+      queue.clear();
+    }
+    return this;
+  }
+}
+function getTaskQueueRegistry() {
+  if (!taskQueueRegistry) {
+    taskQueueRegistry = new TaskQueueRegistry;
+  }
+  return taskQueueRegistry;
+}
+function setTaskQueueRegistry(registry) {
+  if (taskQueueRegistry) {
+    taskQueueRegistry.stopQueues();
+    taskQueueRegistry.clearQueues();
+  }
+  taskQueueRegistry = registry;
+}
+
+// src/task/JobQueueTask.ts
+class JobQueueTask extends ArrayTask {
+  static type = "JobQueueTask";
+  static canRunDirectly = true;
+  currentQueueName;
+  currentJobId;
+  currentRunnerId;
+  jobClass;
+  constructor(input = {}, config = {}) {
+    config.queue ??= true;
+    super(input, config);
+    this.jobClass = Job2;
+  }
+  async execute(input, executeContext) {
+    let cleanup = () => {};
+    try {
+      if (this.config.queue === false && !this.constructor.canRunDirectly) {
+        throw new TaskConfigurationError(`${this.type} cannot run directly without a queue`);
+      }
+      const queue = await this.resolveQueue(input);
+      const job = await this.createJob(input, queue);
+      if (!queue) {
+        if (!this.constructor.canRunDirectly) {
+          const queueLabel = typeof this.config.queue === "string" ? this.config.queue : this.currentQueueName ?? this.type;
+          throw new TaskConfigurationError(`Queue ${queueLabel} not found, and ${this.type} cannot run directly`);
+        }
+        this.currentJobId = undefined;
+        cleanup = job.onJobProgress((progress, message, details) => {
+          executeContext.updateProgress(progress, message, details);
+        });
+        const output2 = await job.execute(job.input, {
+          signal: executeContext.signal,
+          updateProgress: executeContext.updateProgress.bind(this)
+        });
+        return output2;
+      }
+      const jobId = await queue.add(job);
+      this.currentJobId = jobId;
+      this.currentQueueName = queue?.queueName;
+      this.currentRunnerId = job.jobRunId;
+      cleanup = queue.onJobProgress(jobId, (progress, message, details) => {
+        executeContext.updateProgress(progress, message, details);
+      });
+      const output = await queue.waitFor(jobId);
+      if (output === undefined) {
+        throw new TaskConfigurationError("Job disabled, should not happen");
+      }
+      return output;
+    } catch (err) {
+      throw new JobTaskFailedError(err);
+    } finally {
+      cleanup();
+    }
+  }
+  async createJob(input, queue) {
+    const jobCtor = queue?.jobClass ?? this.jobClass;
+    return new jobCtor({
+      queueName: queue?.queueName ?? this.currentQueueName,
+      jobRunId: this.currentRunnerId,
+      input
+    });
+  }
+  async resolveQueue(input) {
+    const preference = this.config.queue ?? true;
+    if (preference === false) {
+      this.currentQueueName = undefined;
+      return;
+    }
+    if (typeof preference === "string") {
+      const queue2 = getTaskQueueRegistry().getQueue(preference);
+      if (queue2) {
+        this.currentQueueName = queue2.queueName;
+        return queue2;
+      }
+      this.currentQueueName = preference;
+      return;
+    }
+    const queueName = await this.getDefaultQueueName(input);
+    if (!queueName) {
+      this.currentQueueName = undefined;
+      return;
+    }
+    this.currentQueueName = queueName;
+    let queue = getTaskQueueRegistry().getQueue(queueName);
+    if (!queue) {
+      queue = await this.createAndRegisterQueue(queueName, input);
+      await queue.start();
+    }
+    return queue;
+  }
+  async getDefaultQueueName(_input) {
+    return this.type;
+  }
+  async createAndRegisterQueue(queueName, input) {
+    const factory = getJobQueueFactory();
+    let queue = await factory({
+      queueName,
+      jobClass: this.jobClass,
+      input,
+      config: this.config,
+      task: this
+    });
+    const registry = getTaskQueueRegistry();
+    try {
+      registry.registerQueue(queue);
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("already exists")) {
+        const existing = registry.getQueue(queueName);
+        if (existing) {
+          queue = existing;
+        }
+      } else {
+        throw err;
+      }
+    }
+    return queue;
+  }
+  async abort() {
+    if (this.currentQueueName) {
+      const queue = getTaskQueueRegistry().getQueue(this.currentQueueName);
+      if (queue) {
+        await queue.abort(this.currentJobId);
+      }
+    }
+    super.abort();
+  }
+}
+// src/task/TaskRegistry.ts
+var taskConstructors = new Map;
+function registerTask(baseClass) {
+  if (taskConstructors.has(baseClass.type)) {}
+  taskConstructors.set(baseClass.type, baseClass);
+}
+var TaskRegistry = {
+  all: taskConstructors,
+  registerTask
+};
+
+// src/task/TaskJSON.ts
+var createSingleTaskFromJSON = (item) => {
+  if (!item.id)
+    throw new TaskJSONError("Task id required");
+  if (!item.type)
+    throw new TaskJSONError("Task type required");
+  if (item.input && (Array.isArray(item.input) || Array.isArray(item.provenance)))
+    throw new TaskJSONError("Task input must be an object");
+  if (item.provenance && (Array.isArray(item.provenance) || typeof item.provenance !== "object"))
+    throw new TaskJSONError("Task provenance must be an object");
+  const taskClass = TaskRegistry.all.get(item.type);
+  if (!taskClass)
+    throw new TaskJSONError(`Task type ${item.type} not found, perhaps not registered?`);
+  const taskConfig = {
+    id: item.id,
+    name: item.name,
+    provenance: item.provenance ?? {},
+    extras: item.extras
+  };
+  const task = new taskClass(item.input ?? {}, taskConfig);
+  return task;
+};
+var createTaskFromDependencyJSON = (item) => {
+  const task = createSingleTaskFromJSON(item);
+  if (item.subtasks && item.subtasks.length > 0) {
+    if (!(task instanceof GraphAsTask)) {
+      throw new TaskConfigurationError("Subgraph is only supported for CompoundTasks");
+    }
+    task.subGraph = createGraphFromDependencyJSON(item.subtasks);
+  }
+  return task;
+};
+var createGraphFromDependencyJSON = (jsonItems) => {
+  const subGraph = new TaskGraph;
+  for (const subitem of jsonItems) {
+    subGraph.addTask(createTaskFromDependencyJSON(subitem));
+  }
+  return subGraph;
+};
+var createTaskFromGraphJSON = (item) => {
+  const task = createSingleTaskFromJSON(item);
+  if (item.subgraph) {
+    if (!(task instanceof GraphAsTask)) {
+      throw new TaskConfigurationError("Subgraph is only supported for GraphAsTask");
+    }
+    task.subGraph = createGraphFromGraphJSON(item.subgraph);
+  }
+  return task;
+};
+var createGraphFromGraphJSON = (graphJsonObj) => {
+  const subGraph = new TaskGraph;
+  for (const subitem of graphJsonObj.tasks) {
+    subGraph.addTask(createTaskFromGraphJSON(subitem));
+  }
+  for (const subitem of graphJsonObj.dataflows) {
+    subGraph.addDataflow(new Dataflow(subitem.sourceTaskId, subitem.sourceTaskPortId, subitem.targetTaskId, subitem.targetTaskPortId));
+  }
+  return subGraph;
+};
+// src/storage/TaskGraphRepository.ts
+import { createServiceToken as createServiceToken3, EventEmitter as EventEmitter6 } from "@workglow/util";
+var TASK_GRAPH_REPOSITORY = createServiceToken3("taskgraph.taskGraphRepository");
+
+class TaskGraphRepository {
+  type = "TaskGraphRepository";
+  get events() {
+    if (!this._events) {
+      this._events = new EventEmitter6;
+    }
+    return this._events;
+  }
+  _events;
+  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);
+  }
+}
+// src/storage/TaskGraphTabularRepository.ts
+var TaskGraphSchema = {
+  type: "object",
+  properties: {
+    key: { type: "string" },
+    value: { type: "string" }
+  },
+  additionalProperties: false
+};
+var TaskGraphPrimaryKeyNames = ["key"];
+
+class TaskGraphTabularRepository extends TaskGraphRepository {
+  type = "TaskGraphTabularRepository";
+  tabularRepository;
+  constructor({ tabularRepository }) {
+    super();
+    this.tabularRepository = tabularRepository;
+  }
+  async saveTaskGraph(key, output) {
+    const value = JSON.stringify(output.toJSON());
+    await this.tabularRepository.put({ key, value });
+    this.emit("graph_saved", key);
+  }
+  async getTaskGraph(key) {
+    const result = await this.tabularRepository.get({ key });
+    const value = result?.value;
+    if (!value) {
+      return;
+    }
+    const jsonObj = JSON.parse(value);
+    const graph = createGraphFromGraphJSON(jsonObj);
+    this.emit("graph_retrieved", key);
+    return graph;
+  }
+  async clear() {
+    await this.tabularRepository.deleteAll();
+    this.emit("graph_cleared");
+  }
+  async size() {
+    return await this.tabularRepository.size();
+  }
+}
+// src/storage/TaskOutputTabularRepository.ts
+import { compress, decompress, makeFingerprint } from "@workglow/util";
+var TaskOutputSchema = {
+  type: "object",
+  properties: {
+    key: { type: "string" },
+    taskType: { type: "string" },
+    value: { type: "string", contentEncoding: "blob" },
+    createdAt: { type: "string", format: "date-time" }
+  },
+  additionalProperties: false
+};
+var TaskOutputPrimaryKeyNames = ["key", "taskType"];
+
+class TaskOutputTabularRepository extends TaskOutputRepository {
+  tabularRepository;
+  constructor({ tabularRepository, outputCompression = true }) {
+    super({ outputCompression });
+    this.tabularRepository = tabularRepository;
+    this.outputCompression = outputCompression;
+  }
+  async keyFromInputs(inputs) {
+    return await makeFingerprint(inputs);
+  }
+  async saveOutput(taskType, inputs, output, createdAt = new Date) {
+    const key = await this.keyFromInputs(inputs);
+    const value = JSON.stringify(output);
+    if (this.outputCompression) {
+      const compressedValue = await compress(value);
+      await this.tabularRepository.put({
+        taskType,
+        key,
+        value: compressedValue,
+        createdAt: createdAt.toISOString()
+      });
+    } else {
+      const valueBuffer = Buffer.from(value);
+      await this.tabularRepository.put({
+        taskType,
+        key,
+        value: valueBuffer,
+        createdAt: createdAt.toISOString()
+      });
+    }
+    this.emit("output_saved", taskType);
+  }
+  async getOutput(taskType, inputs) {
+    const key = await this.keyFromInputs(inputs);
+    const output = await this.tabularRepository.get({ key, taskType });
+    this.emit("output_retrieved", taskType);
+    if (output?.value) {
+      if (this.outputCompression) {
+        const raw = output.value;
+        const bytes = raw instanceof Uint8Array ? raw : Array.isArray(raw) ? new Uint8Array(raw) : raw && typeof raw === "object" ? new Uint8Array(Object.keys(raw).filter((k) => /^\d+$/.test(k)).sort((a, b) => Number(a) - Number(b)).map((k) => raw[k])) : new Uint8Array;
+        const decompressedValue = await decompress(bytes);
+        const value = JSON.parse(decompressedValue);
+        return value;
+      } else {
+        const stringValue = output.value.toString();
+        const value = JSON.parse(stringValue);
+        return value;
+      }
+    } else {
+      return;
+    }
+  }
+  async clear() {
+    await this.tabularRepository.deleteAll();
+    this.emit("output_cleared");
+  }
+  async size() {
+    return await this.tabularRepository.size();
+  }
+  async clearOlderThan(olderThanInMs) {
+    const date = new Date(Date.now() - olderThanInMs).toISOString();
+    await this.tabularRepository.deleteSearch("createdAt", date, "<");
+    this.emit("output_pruned");
+  }
+}
+export {
+  setTaskQueueRegistry,
+  serialGraph,
+  registerJobQueueFactory,
+  pipe,
+  parallel,
+  getTaskQueueRegistry,
+  getLastTask,
+  getJobQueueFactory,
+  ensureTask,
+  createTaskFromGraphJSON,
+  createTaskFromDependencyJSON,
+  createJobQueueFactoryFromClass,
+  createGraphFromGraphJSON,
+  createGraphFromDependencyJSON,
+  connect,
+  WorkflowError,
+  Workflow,
+  TaskStatus,
+  TaskRegistry,
+  TaskQueueRegistry,
+  TaskOutputTabularRepository,
+  TaskOutputSchema,
+  TaskOutputRepository,
+  TaskOutputPrimaryKeyNames,
+  TaskJSONError,
+  TaskInvalidInputError,
+  TaskGraphTabularRepository,
+  TaskGraphSchema,
+  TaskGraphRunner,
+  TaskGraphRepository,
+  TaskGraphPrimaryKeyNames,
+  TaskGraph,
+  TaskFailedError,
+  TaskError,
+  TaskConfigurationError,
+  TaskAbortedError,
+  Task,
+  TASK_OUTPUT_REPOSITORY,
+  TASK_GRAPH_REPOSITORY,
+  PROPERTY_ARRAY,
+  JobTaskFailedError,
+  JobQueueTask,
+  JOB_QUEUE_FACTORY,
+  GraphAsTaskRunner,
+  GraphAsTask,
+  GRAPH_RESULT_ARRAY,
+  EventTaskGraphToDagMapping,
+  EventDagToTaskGraphMapping,
+  DataflowArrow,
+  Dataflow,
+  DATAFLOW_ERROR_PORT,
+  DATAFLOW_ALL_PORTS,
+  CreateWorkflow,
+  ConditionalTask,
+  ArrayTask
+};
+
+//# debugId=32538247DA95577364756E2164756E21