@workglow/task-graph 0.0.85 → 0.0.86

package/dist/browser.js

@@ -1,12 +1,3 @@
-// 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";
 
@@ -42,14 +33,12 @@ class Dataflow {
     return Dataflow.createId(this.sourceTaskId, this.sourceTaskPortId, this.targetTaskId, this.targetTaskPortId);
   }
   value = undefined;
-  provenance = {};
   status = TaskStatus.PENDING;
   error;
   reset() {
     this.status = TaskStatus.PENDING;
     this.error = undefined;
     this.value = undefined;
-    this.provenance = {};
     this.emit("reset");
     this.emit("status", this.status);
   }
@@ -79,7 +68,7 @@ class Dataflow {
     }
     this.emit("status", this.status);
   }
-  setPortData(entireDataBlock, nodeProvenance) {
+  setPortData(entireDataBlock) {
     if (this.sourceTaskPortId === DATAFLOW_ALL_PORTS) {
       this.value = entireDataBlock;
     } else if (this.sourceTaskPortId === DATAFLOW_ERROR_PORT) {
@@ -87,8 +76,6 @@ class Dataflow {
     } else {
       this.value = entireDataBlock[this.sourceTaskPortId];
     }
-    if (nodeProvenance)
-      this.provenance = nodeProvenance;
   }
   getPortData() {
     if (this.targetTaskPortId === DATAFLOW_ALL_PORTS) {
@@ -171,11 +158,17 @@ class DataflowArrow extends Dataflow {
     super(sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId);
   }
 }
+// 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/TaskGraphRunner.ts
 import {
   collectPropertyValues,
   globalServiceRegistry as globalServiceRegistry2,
+  ServiceRegistry as ServiceRegistry2,
   uuid4 as uuid42
 } from "@workglow/util";
 
@@ -280,13 +273,69 @@ class TaskInvalidInputError extends TaskError {
 
 // src/task/TaskRunner.ts
 import { 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 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)) {
+    const value = resolved[key];
+    const format = getSchemaFormat(propSchema);
+    if (!format)
+      continue;
+    let resolver = resolvers.get(format);
+    if (!resolver) {
+      const prefix = getFormatPrefix(format);
+      resolver = resolvers.get(prefix);
+    }
+    if (!resolver)
+      continue;
+    if (typeof value === "string") {
+      resolved[key] = await resolver(value, format, config.registry);
+    } else if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+      const results = await Promise.all(value.map((item) => resolver(item, format, config.registry)));
+      resolved[key] = results.filter((result) => result !== undefined);
+    }
+  }
+  return resolved;
+}
+
+// src/task/TaskRunner.ts
 class TaskRunner {
   running = false;
   reactiveRunning = false;
-  nodeProvenance = {};
   task;
   abortController;
   outputCache;
+  registry = globalServiceRegistry;
   constructor(task) {
     this.task = task;
     this.own = this.own.bind(this);
@@ -296,6 +345,8 @@ class TaskRunner {
     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");
@@ -331,6 +382,8 @@ class TaskRunner {
       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);
@@ -361,8 +414,8 @@ class TaskRunner {
     const result = await this.task.execute(input, {
       signal: this.abortController.signal,
       updateProgress: this.handleProgress.bind(this),
-      nodeProvenance: this.nodeProvenance,
-      own: this.own
+      own: this.own,
+      registry: this.registry
     });
     return await this.executeTaskReactive(input, result || {});
   }
@@ -373,7 +426,6 @@ class TaskRunner {
   async handleStart(config = {}) {
     if (this.task.status === TaskStatus.PROCESSING)
       return;
-    this.nodeProvenance = {};
     this.running = true;
     this.task.startedAt = new Date;
     this.task.progress = 0;
@@ -382,7 +434,6 @@ class TaskRunner {
     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);
@@ -395,6 +446,9 @@ class TaskRunner {
     if (config.updateProgress) {
       this.updateProgress = config.updateProgress;
     }
+    if (config.registry) {
+      this.registry = config.registry;
+    }
     this.task.emit("start");
     this.task.emit("status", this.task.status);
   }
@@ -421,7 +475,6 @@ class TaskRunner {
     this.task.progress = 100;
     this.task.status = TaskStatus.COMPLETED;
     this.abortController = undefined;
-    this.nodeProvenance = {};
     this.task.emit("complete");
     this.task.emit("status", this.task.status);
   }
@@ -435,7 +488,6 @@ class TaskRunner {
     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);
   }
@@ -455,7 +507,6 @@ class TaskRunner {
     this.task.status = TaskStatus.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);
   }
@@ -553,7 +604,6 @@ class Task {
     return this._events;
   }
   _events;
-  nodeProvenance = {};
   constructor(callerDefaultInputs = {}, config = {}) {
     const inputDefaults = this.getDefaultInputsFromStaticInputDefinitions();
     const mergedDefaults = Object.assign(inputDefaults, callerDefaultInputs);
@@ -590,10 +640,45 @@ class Task {
     }
   }
   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 Error("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 {
-      this.runInputData = structuredClone(this.defaults);
-    } catch (err) {
-      this.runInputData = JSON.parse(JSON.stringify(this.defaults));
+      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) {
@@ -621,7 +706,7 @@ class Task {
     }
     if (schema.additionalProperties === true) {
       for (const [inputId, value] of Object.entries(input)) {
-        if (value !== undefined && !(inputId in properties)) {
+        if (!(inputId in properties)) {
           this.runInputData[inputId] = value;
         }
       }
@@ -674,7 +759,7 @@ class Task {
     }
     if (inputSchema.additionalProperties === true) {
       for (const [inputId, value] of Object.entries(overrides)) {
-        if (value !== undefined && !(inputId in properties)) {
+        if (!(inputId in properties)) {
           if (!deepEqual(this.runInputData[inputId], value)) {
             this.runInputData[inputId] = value;
             changed = true;
@@ -684,7 +769,7 @@ class Task {
     }
     return changed;
   }
-  async narrowInput(input) {
+  async narrowInput(input, _registry) {
     return input;
   }
   subscribe(name, fn) {
@@ -744,20 +829,20 @@ class Task {
         const path = e.data.pointer || "";
         return `${e.message}${path ? ` (${path})` : ""}`;
       });
-      throw new TaskInvalidInputError(`Input ${JSON.stringify(input)} does not match schema: ${errorMessages.join(", ")}`);
+      throw new TaskInvalidInputError(`Input ${JSON.stringify(Object.keys(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 (ArrayBuffer.isView(obj)) {
+      return obj;
+    }
     if (Array.isArray(obj)) {
       return obj.map((item) => this.stripSymbols(item));
     }
@@ -773,14 +858,12 @@ class Task {
     return obj;
   }
   toJSON() {
-    const provenance = this.getProvenance();
     const extras = this.config.extras;
     let json = this.stripSymbols({
       id: this.config.id,
       type: this.type,
       ...this.config.name ? { name: this.config.name } : {},
       defaults: this.defaults,
-      ...Object.keys(provenance).length ? { provenance } : {},
       ...extras && Object.keys(extras).length ? { extras } : {}
     });
     return json;
@@ -826,8 +909,9 @@ class Task {
 // src/task/ConditionalTask.ts
 class ConditionalTask extends Task {
   static type = "ConditionalTask";
-  static category = "Flow Control";
+  static category = "Hidden";
   static title = "Conditional Task";
+  static description = "Evaluates conditions to determine which dataflows are active";
   static hasDynamicSchemas = true;
   activeBranches = new Set;
   async execute(input, context) {
@@ -1052,9 +1136,9 @@ class TaskGraphRunner {
   reactiveScheduler;
   running = false;
   reactiveRunning = false;
-  provenanceInput;
   graph;
   outputCache;
+  registry = globalServiceRegistry2;
   abortController;
   inProgressTasks = new Map;
   inProgressFunctions = new Map;
@@ -1063,7 +1147,6 @@ class TaskGraphRunner {
     this.processScheduler = processScheduler;
     this.reactiveScheduler = reactiveScheduler;
     this.graph = graph;
-    this.provenanceInput = new Map;
     graph.outputCache = outputCache;
     this.handleProgress = this.handleProgress.bind(this);
   }
@@ -1083,7 +1166,7 @@ class TaskGraphRunner {
         const runAsync = async () => {
           try {
             const taskInput = isRootTask ? input : this.filterInputForTask(task, input);
-            const taskPromise = this.runTaskWithProvenance(task, taskInput, config?.parentProvenance || {});
+            const taskPromise = this.runTask(task, taskInput);
             this.inProgressTasks.set(task.config.id, taskPromise);
             const taskResult = await taskPromise;
             if (this.graph.getTargetDataflows(task.config.id).length === 0) {
@@ -1193,23 +1276,16 @@ class TaskGraphRunner {
       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) {
+  async pushOutputFromNodeToEdges(node, results) {
     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);
+        dataflow.setPortData(results);
       } else if (compatibility === "runtime") {
         const task = this.graph.getTask(dataflow.targetTaskId);
-        const narrowed = await task.narrowInput({ ...results });
-        dataflow.setPortData(narrowed, nodeProvenance);
+        const narrowed = await task.narrowInput({ ...results }, this.registry);
+        dataflow.setPortData(narrowed);
       } else {}
     }
   }
@@ -1279,20 +1355,14 @@ class TaskGraphRunner {
       }
     }
   }
-  async runTaskWithProvenance(task, input, parentProvenance) {
-    const nodeProvenance = {
-      ...parentProvenance,
-      ...this.getInputProvenance(task),
-      ...task.getProvenance()
-    };
-    this.provenanceInput.set(task.config.id, nodeProvenance);
+  async runTask(task, input) {
     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)
+      updateProgress: async (task2, progress, message, ...args) => await this.handleProgress(task2, progress, message, ...args),
+      registry: this.registry
     });
-    await this.pushOutputFromNodeToEdges(task, results, nodeProvenance);
+    await this.pushOutputFromNodeToEdges(task, results);
     return {
       id: task.config.id,
       type: task.constructor.runtype || task.constructor.type,
@@ -1326,10 +1396,15 @@ class TaskGraphRunner {
     });
   }
   async handleStart(config) {
+    if (config?.registry !== undefined) {
+      this.registry = config.registry;
+    } else {
+      this.registry = new ServiceRegistry2(globalServiceRegistry2.container.createChildContainer());
+    }
     if (config?.outputCache !== undefined) {
       if (typeof config.outputCache === "boolean") {
         if (config.outputCache === true) {
-          this.outputCache = globalServiceRegistry2.get(TASK_OUTPUT_REPOSITORY);
+          this.outputCache = this.registry.get(TASK_OUTPUT_REPOSITORY);
         } else {
           this.outputCache = undefined;
         }
@@ -1415,7 +1490,7 @@ class TaskGraphRunner {
       progress = Math.round(completed / total);
     }
     this.pushStatusFromNodeToEdges(this.graph, task);
-    await this.pushOutputFromNodeToEdges(task, task.runOutputData, task.getProvenance());
+    await this.pushOutputFromNodeToEdges(task, task.runOutputData);
     this.graph.emit("graph_progress", progress, message, args);
   }
 }
@@ -1427,7 +1502,6 @@ class GraphAsTaskRunner extends TaskRunner {
       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
     });
@@ -1443,27 +1517,12 @@ class GraphAsTaskRunner extends TaskRunner {
     }
     super.handleDisable();
   }
-  fixInput(input) {
-    const inputSchema = this.task.inputSchema();
-    if (typeof inputSchema === "boolean") {
-      return input;
-    }
-    const flattenedInput = Object.entries(input).reduce((acc, [key, value]) => {
-      const inputDef = inputSchema.properties?.[key];
-      const shouldFlatten = Array.isArray(value) && typeof inputDef === "object" && inputDef !== null && "x-replicate" in inputDef && inputDef["x-replicate"] === true;
-      if (shouldFlatten) {
-        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));
+      const result = await super.executeTask(input);
       this.task.runOutputData = result ?? {};
     }
     return this.task.runOutputData;
@@ -1473,7 +1532,7 @@ class GraphAsTaskRunner extends TaskRunner {
       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);
+      const reactiveResults = await super.executeTaskReactive(input, output);
       this.task.runOutputData = Object.assign({}, output, reactiveResults ?? {});
     }
     return this.task.runOutputData;
@@ -1483,6 +1542,8 @@ class GraphAsTaskRunner extends TaskRunner {
 // src/task/GraphAsTask.ts
 class GraphAsTask extends Task {
   static type = "GraphAsTask";
+  static title = "Graph as Task";
+  static description = "A task that contains a subgraph of tasks";
   static category = "Hidden";
   static compoundMerge = PROPERTY_ARRAY;
   static hasDynamicSchemas = true;
@@ -1709,6 +1770,15 @@ class Workflow {
         const sourceSchema = parent.outputSchema();
         const targetSchema = task.inputSchema();
         const makeMatch = (comparator) => {
+          if (typeof sourceSchema === "object") {
+            if (targetSchema === true || typeof targetSchema === "object" && targetSchema.additionalProperties === true) {
+              for (const fromOutputPortId of Object.keys(sourceSchema.properties || {})) {
+                matches.set(fromOutputPortId, fromOutputPortId);
+                this.connect(parent.config.id, fromOutputPortId, task.config.id, fromOutputPortId);
+              }
+              return matches;
+            }
+          }
           if (typeof sourceSchema === "boolean" || typeof targetSchema === "boolean") {
             return matches;
           }
@@ -1722,25 +1792,135 @@ class Workflow {
           }
           return matches;
         };
-        makeMatch(([fromOutputPortId, fromPortOutputSchema], [toInputPortId, toPortInputSchema]) => {
+        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") {
-            if (fromPortOutputSchema === true && toPortInputSchema === true) {
+            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 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));
+          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;
+        };
+        makeMatch(([fromOutputPortId, fromPortOutputSchema], [toInputPortId, toPortInputSchema]) => {
           const outputPortIdMatch = fromOutputPortId === toInputPortId;
           const outputPortIdOutputInput = fromOutputPortId === "output" && toInputPortId === "input";
           const portIdsCompatible = outputPortIdMatch || outputPortIdOutputInput;
-          return (idTypeMatch || typeMatch) && portIdsCompatible;
+          return portIdsCompatible && isTypeCompatible(fromPortOutputSchema, toPortInputSchema, false);
         });
-        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.`;
+        makeMatch(([_fromOutputPortId, fromPortOutputSchema], [_toInputPortId, toPortInputSchema]) => {
+          return isTypeCompatible(fromPortOutputSchema, toPortInputSchema, true);
+        });
+        const requiredInputs = new Set(typeof targetSchema === "object" ? targetSchema.required || [] : []);
+        const providedInputKeys = new Set(Object.keys(input || {}));
+        const requiredInputsNeedingConnection = [...requiredInputs].filter((r) => !providedInputKeys.has(r));
+        let unmatchedRequired = requiredInputsNeedingConnection.filter((r) => !matches.has(r));
+        if (unmatchedRequired.length > 0) {
+          const nodes = this._graph.getTasks();
+          const parentIndex = nodes.findIndex((n) => n.config.id === parent.config.id);
+          for (let i = parentIndex - 1;i >= 0 && unmatchedRequired.length > 0; i--) {
+            const earlierTask = nodes[i];
+            const earlierOutputSchema = earlierTask.outputSchema();
+            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);
+                    this.connect(earlierTask.config.id, fromOutputPortId, task.config.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) {
+          this._error = `Could not find matches for required inputs [${stillUnmatchedRequired.join(", ")}] of ${task.type}. ` + `Attempted to match from ${parent.type} and earlier tasks. Task not added.`;
           console.error(this._error);
           this.graph.removeTask(task.config.id);
+        } else if (matches.size === 0 && requiredInputsNeedingConnection.length === 0) {
+          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) {
+            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;
@@ -1785,7 +1965,6 @@ class Workflow {
     try {
       const output = await this.graph.run(input, {
         parentSignal: this._abortController.signal,
-        parentProvenance: {},
         outputCache: this._repository
       });
       const results = this.graph.mergeExecuteOutputsToRunOutput(output, PROPERTY_ARRAY);
@@ -1917,7 +2096,8 @@ class Workflow {
       if (targetSchema === false) {
         throw new WorkflowError(`Target task has schema 'false' and accepts no inputs`);
       }
-    } else if (!targetSchema.properties?.[targetTaskPortId]) {
+      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);
@@ -2097,7 +2277,6 @@ class TaskGraph {
   run(input = {}, config = {}) {
     return this.runner.runGraph(input, {
       outputCache: config?.outputCache || this.outputCache,
-      parentProvenance: config?.parentProvenance || {},
       parentSignal: config?.parentSignal || undefined
     });
   }
@@ -2338,142 +2517,6 @@ function serialGraph(tasks, inputHandle, outputHandle) {
   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;
-    }
-    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({});
-  }
-  async executeTaskReactive(input, output) {
-    const reactiveResults = await super.executeTaskReactive(input, output);
-    if (this.task.hasChildren()) {
-      return reactiveResults;
-    } else {
-      this.task.runOutputData = Object.assign({}, output, reactiveResults ?? {});
-      return this.task.runOutputData;
-    }
-  }
-}
-// src/task/InputTask.ts
-import { Task as Task2 } from "@workglow/task-graph";
-
-class InputTask extends Task2 {
-  static type = "InputTask";
-  static category = "Flow Control";
-  static title = "Input";
-  static description = "Starts the workflow";
-  static hasDynamicSchemas = true;
-  static cacheable = false;
-  static inputSchema() {
-    return {
-      type: "object",
-      properties: {},
-      additionalProperties: true
-    };
-  }
-  static outputSchema() {
-    return {
-      type: "object",
-      properties: {},
-      additionalProperties: true
-    };
-  }
-  inputSchema() {
-    return this.config?.extras?.inputSchema ?? this.constructor.inputSchema();
-  }
-  outputSchema() {
-    return this.config?.extras?.outputSchema ?? this.constructor.outputSchema();
-  }
-  async execute(input, _context) {
-    return input;
-  }
-  async executeReactive(input, _output, _context) {
-    return input;
-  }
-}
 // src/task/JobQueueFactory.ts
 import {
   JobQueueClient,
@@ -2602,7 +2645,7 @@ function setTaskQueueRegistry(registry) {
 }
 
 // src/task/JobQueueTask.ts
-class JobQueueTask extends ArrayTask {
+class JobQueueTask extends GraphAsTask {
   static type = "JobQueueTask";
   static canRunDirectly = true;
   currentQueueName;
@@ -2734,43 +2777,6 @@ class JobQueueTask extends ArrayTask {
     super.abort();
   }
 }
-// src/task/OutputTask.ts
-import { Task as Task3 } from "@workglow/task-graph";
-
-class OutputTask extends Task3 {
-  static type = "OutputTask";
-  static category = "Flow Control";
-  static title = "Output";
-  static description = "Ends the workflow";
-  static hasDynamicSchemas = true;
-  static cacheable = false;
-  static inputSchema() {
-    return {
-      type: "object",
-      properties: {},
-      additionalProperties: true
-    };
-  }
-  static outputSchema() {
-    return {
-      type: "object",
-      properties: {},
-      additionalProperties: true
-    };
-  }
-  inputSchema() {
-    return this.config?.extras?.inputSchema ?? this.constructor.inputSchema();
-  }
-  outputSchema() {
-    return this.config?.extras?.outputSchema ?? this.constructor.outputSchema();
-  }
-  async execute(input, _context) {
-    return input;
-  }
-  async executeReactive(input, _output, _context) {
-    return input;
-  }
-}
 // src/task/TaskRegistry.ts
 var taskConstructors = new Map;
 function registerTask(baseClass) {
@@ -2788,17 +2794,14 @@ var createSingleTaskFromJSON = (item) => {
     throw new TaskJSONError("Task id required");
   if (!item.type)
     throw new TaskJSONError("Task type required");
-  if (item.defaults && (Array.isArray(item.defaults) || Array.isArray(item.provenance)))
+  if (item.defaults && Array.isArray(item.defaults))
     throw new TaskJSONError("Task defaults 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.defaults ?? {}, taskConfig);
@@ -2841,6 +2844,12 @@ var createGraphFromGraphJSON = (graphJsonObj) => {
   }
   return subGraph;
 };
+// src/task/index.ts
+var registerBaseTasks = () => {
+  const tasks = [ConditionalTask, GraphAsTask];
+  tasks.map(TaskRegistry.registerTask);
+  return tasks;
+};
 // src/storage/TaskGraphRepository.ts
 import { createServiceToken as createServiceToken3, EventEmitter as EventEmitter6 } from "@workglow/util";
 var TASK_GRAPH_REPOSITORY = createServiceToken3("taskgraph.taskGraphRepository");
@@ -3000,7 +3009,9 @@ class TaskOutputTabularRepository extends TaskOutputRepository {
 export {
   setTaskQueueRegistry,
   serialGraph,
+  resolveSchemaInputs,
   registerJobQueueFactory,
+  registerBaseTasks,
   pipe,
   parallel,
   getTaskQueueRegistry,
@@ -3038,11 +3049,9 @@ export {
   TASK_OUTPUT_REPOSITORY,
   TASK_GRAPH_REPOSITORY,
   PROPERTY_ARRAY,
-  OutputTask,
   JobTaskFailedError,
   JobQueueTask,
   JOB_QUEUE_FACTORY,
-  InputTask,
   GraphAsTaskRunner,
   GraphAsTask,
   GRAPH_RESULT_ARRAY,
@@ -3053,8 +3062,7 @@ export {
   DATAFLOW_ERROR_PORT,
   DATAFLOW_ALL_PORTS,
   CreateWorkflow,
-  ConditionalTask,
-  ArrayTask
+  ConditionalTask
 };
 
-//# debugId=E59B822A237BFEFE64756E2164756E21
+//# debugId=C40AC8C0A1FC6ED164756E2164756E21