@nfdi4plants/arctrl 3.0.0-beta.9 → 3.0.1

package/dist/ts/ts/WorkflowGraph/Builder.js

@@ -0,0 +1,556 @@
+import { Record } from '../../node_modules/@fable-org/fable-library-js/Types.js';
+import { WorkflowGraph_$reflection, WorkflowGraph_create_4D231A1, GraphBuildIssue_create_Z2F3B511A, WorkflowGraphEdge_create_5E4B5E48, GraphId_edgeId, GraphId_unitNodeId, WorkflowGraphNode_create_62C775C0, NodeKind_ProcessingUnitNode, GraphId_portNodeId, NodeKind_PortNode, GraphId_stepNodeId, NodeKind_StepNode, EdgeKind_Contains, PortDirection_Input, PortDirection_Output, GraphIssueKind_CycleDetected, GraphIssueKind_ResolutionFailed, ProcessingUnitKind_CommandLineTool, ProcessingUnitKind_Workflow, ProcessingUnitKind_Operation, ProcessingUnitKind_ExpressionTool, ProcessingUnitKind_UnresolvedReference, ProcessingUnitKind_ExternalReference, GraphIssueKind_UnexpectedRuntimeType, GraphIssueKind_InvalidReference, EdgeKind_BindsWorkflowInput, EdgeKind_DataFlow, GraphIssueKind_MissingReference, EdgeKind_BindsWorkflowOutput, EdgeKind_Calls, GraphId_childScope, GraphId_normalizeSegment } from './GraphTypes.js';
+import { empty, FSharpSet__Contains, FSharpSet__Add } from '../../node_modules/@fable-org/fable-library-js/Set.js';
+import { empty as empty$1, FSharpMap__ContainsKey, FSharpMap__get_Item, FSharpMap__Add, tryFind } from '../../node_modules/@fable-org/fable-library-js/Map.js';
+import { WorkflowStepRun_$reflection, WorkflowStepRun_RunString } from '../CWL/WorkflowSteps.js';
+import { WorkflowGraphBuildOptions_$reflection, WorkflowGraphBuildOptionsModule_defaultOptions } from './BuildOptions.js';
+import { record_type, class_type, string_type, option_type, bool_type, array_type } from '../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { unwrap, value, map, defaultArg, bind, some } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { comparePrimitives, getEnumerator, disposeSafe, stringHash } from '../../node_modules/@fable-org/fable-library-js/Util.js';
+import { DynamicObj } from '../fable_modules/DynamicObj.7.1.0/DynamicObj.fs.js';
+import { setProperty } from '../fable_modules/DynamicObj.7.1.0/DynObj.fs.js';
+import { ofArray, tryPick, singleton } from '../../node_modules/@fable-org/fable-library-js/List.js';
+import { toArray, iterate, tryHead, toList, delay, singleton as singleton$1 } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { ReferenceParsing_extractStepOutputId, ReferenceParsing_parseSourceReference } from './ReferenceParsing.js';
+import { isNullOrWhiteSpace, substring, endsWith } from '../../node_modules/@fable-org/fable-library-js/String.js';
+import { getFileName, normalize, resolvePathFromFile, normalizePathKey } from '../FileSystem/Path.js';
+import { Array_distinct } from '../../node_modules/@fable-org/fable-library-js/Seq2.js';
+import { WorkflowStepRunOps_fromTool, WorkflowStepRunOps_fromOperation, WorkflowStepRunOps_fromExpressionTool, WorkflowStepRunOps_fromWorkflow, WorkflowStepRunOps_tryGetOperation, CWLProcessingUnit_Operation, WorkflowStepRunOps_tryGetExpressionTool, CWLProcessingUnit_ExpressionTool, WorkflowStepRunOps_tryGetWorkflow, CWLProcessingUnit_Workflow, WorkflowStepRunOps_tryGetTool, CWLProcessingUnit_CommandLineTool } from '../CWL/CWLProcessingUnit.js';
+import { map as map$1, item, tryPick as tryPick$1 } from '../../node_modules/@fable-org/fable-library-js/Array.js';
+
+class BuildState extends Record {
+  constructor(Graph, NodeIds, EdgeIds, RunResolutionStack, RunResolutionCache, RunNodeCache, Options) {
+    super();
+    this.Graph = Graph;
+    this.NodeIds = NodeIds;
+    this.EdgeIds = EdgeIds;
+    this.RunResolutionStack = RunResolutionStack;
+    this.RunResolutionCache = RunResolutionCache;
+    this.RunNodeCache = RunNodeCache;
+    this.Options = Options;
+  }
+}
+function BuildState_$reflection() {
+  return record_type("ARCtrl.WorkflowGraph.Builder.BuildState", [], BuildState, () => [["Graph", WorkflowGraph_$reflection()], ["NodeIds", class_type("Microsoft.FSharp.Collections.FSharpSet`1", [string_type])], ["EdgeIds", class_type("Microsoft.FSharp.Collections.FSharpSet`1", [string_type])], ["RunResolutionStack", class_type("Microsoft.FSharp.Collections.FSharpSet`1", [string_type])], ["RunResolutionCache", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, WorkflowStepRun_$reflection()])], ["RunNodeCache", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, string_type])], ["Options", WorkflowGraphBuildOptions_$reflection()]]);
+}
+class RunResolutionResult extends Record {
+  constructor(ResolvedRun, ResolvedFromPath, AttemptedLookup, ResolutionPathKeys) {
+    super();
+    this.ResolvedRun = ResolvedRun;
+    this.ResolvedFromPath = ResolvedFromPath;
+    this.AttemptedLookup = AttemptedLookup;
+    this.ResolutionPathKeys = ResolutionPathKeys;
+  }
+}
+function RunResolutionResult_$reflection() {
+  return record_type("ARCtrl.WorkflowGraph.Builder.RunResolutionResult", [], RunResolutionResult, () => [["ResolvedRun", WorkflowStepRun_$reflection()], ["ResolvedFromPath", option_type(string_type)], ["AttemptedLookup", bool_type], ["ResolutionPathKeys", array_type(string_type)]]);
+}
+function createGraph(rootNodeId) {
+  return WorkflowGraph_create_4D231A1(rootNodeId);
+}
+function createState(options, rootNodeId) {
+  return new BuildState(createGraph(rootNodeId), empty({
+    Compare: comparePrimitives
+  }), empty({
+    Compare: comparePrimitives
+  }), empty({
+    Compare: comparePrimitives
+  }), empty$1({
+    Compare: comparePrimitives
+  }), empty$1({
+    Compare: comparePrimitives
+  }), options);
+}
+function addDiagnostic(state, kind, message, scope, reference) {
+  void state.Graph.Diagnostics.push(GraphBuildIssue_create_Z2F3B511A(kind, message, unwrap(scope), unwrap(reference)));
+}
+function hasNode(state, nodeId) {
+  return FSharpSet__Contains(state.NodeIds, nodeId);
+}
+function addNode(state, node) {
+  if (!FSharpSet__Contains(state.NodeIds, node.Id)) {
+    state.NodeIds = FSharpSet__Add(state.NodeIds, node.Id);
+    void state.Graph.Nodes.push(node);
+  }
+}
+function addEdge(state, edge) {
+  if (!FSharpSet__Contains(state.EdgeIds, edge.Id)) {
+    state.EdgeIds = FSharpSet__Add(state.EdgeIds, edge.Id);
+    void state.Graph.Edges.push(edge);
+  }
+}
+function addEdgeByType(state, kind, sourceNodeId, targetNodeId, label) {
+  addEdge(state, WorkflowGraphEdge_create_5E4B5E48(GraphId_edgeId(kind, sourceNodeId, targetNodeId), sourceNodeId, targetNodeId, kind, unwrap(label)));
+}
+function createMetadata(pairs) {
+  const metadata = new DynamicObj();
+  let hasMetadata = false;
+  const enumerator = getEnumerator(pairs);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const forLoopVar = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      const valueOpt = forLoopVar[1];
+      if (valueOpt == null) {
+      } else {
+        const value$1 = value(valueOpt);
+        hasMetadata = true;
+        setProperty(forLoopVar[0], value$1, metadata);
+      }
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  if (hasMetadata) {
+    return metadata;
+  } else {
+    return void 0;
+  }
+}
+function addProcessingUnitNode(state, scope, kind, label, ownerNodeId, reference, metadata) {
+  const nodeId = GraphId_unitNodeId(scope);
+  addNode(state, WorkflowGraphNode_create_62C775C0(nodeId, NodeKind_ProcessingUnitNode(kind), label, unwrap(ownerNodeId), unwrap(reference), unwrap(metadata)));
+  return nodeId;
+}
+function addPortNode(state, ownerNodeId, direction, portId, label) {
+  const nodeId = GraphId_portNodeId(ownerNodeId, direction, portId);
+  addNode(state, WorkflowGraphNode_create_62C775C0(nodeId, NodeKind_PortNode(direction), label, ownerNodeId));
+  return nodeId;
+}
+function addStepNode(state, scope, workflowNodeId, step) {
+  const stepNodeId = GraphId_stepNodeId(scope, step.Id);
+  const metadata = createMetadata(ofArray([["when", map((value) => value, step.When_)], ["scatterMethod", map((sm) => sm.AsCwlString, step.ScatterMethod)], ["scatter", map(toArray, step.Scatter)]]));
+  addNode(state, WorkflowGraphNode_create_62C775C0(stepNodeId, NodeKind_StepNode(), defaultArg(step.Label, step.Id), workflowNodeId, void 0, unwrap(metadata)));
+  addEdgeByType(state, EdgeKind_Contains(), workflowNodeId, stepNodeId, void 0);
+  return stepNodeId;
+}
+function addWorkflowPorts(state, workflowNodeId, workflow) {
+  iterate((input) => {
+    addPortNode(state, workflowNodeId, PortDirection_Input(), input.Name, input.Name);
+  }, workflow.Inputs);
+  iterate((output) => {
+    addPortNode(state, workflowNodeId, PortDirection_Output(), output.Name, output.Name);
+  }, workflow.Outputs);
+}
+function addToolPorts(state, toolNodeId, tool) {
+  iterate((input) => {
+    addPortNode(state, toolNodeId, PortDirection_Input(), input.Name, input.Name);
+  }, defaultArg(tool.Inputs, []));
+  iterate((output) => {
+    addPortNode(state, toolNodeId, PortDirection_Output(), output.Name, output.Name);
+  }, tool.Outputs);
+}
+function addExpressionToolPorts(state, toolNodeId, tool) {
+  iterate((input) => {
+    addPortNode(state, toolNodeId, PortDirection_Input(), input.Name, input.Name);
+  }, defaultArg(tool.Inputs, []));
+  iterate((output) => {
+    addPortNode(state, toolNodeId, PortDirection_Output(), output.Name, output.Name);
+  }, tool.Outputs);
+}
+function addOperationPorts(state, operationNodeId, operation) {
+  iterate((input) => {
+    addPortNode(state, operationNodeId, PortDirection_Input(), input.Name, input.Name);
+  }, operation.Inputs);
+  iterate((output) => {
+    addPortNode(state, operationNodeId, PortDirection_Output(), output.Name, output.Name);
+  }, operation.Outputs);
+}
+function addStepPorts(state, stepNodeId, step) {
+  iterate((input) => {
+    addPortNode(state, stepNodeId, PortDirection_Input(), input.Id, input.Id);
+  }, step.In);
+  iterate((output) => {
+    const outputId = ReferenceParsing_extractStepOutputId(output);
+    addPortNode(state, stepNodeId, PortDirection_Output(), outputId, outputId);
+  }, step.Out);
+}
+function trimToNameCandidate(value) {
+  if (isNullOrWhiteSpace(value)) {
+    return "";
+  } else {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("#")) {
+      return substring(trimmed, 1);
+    } else {
+      const hashIndex = trimmed.indexOf("#") | 0;
+      const withoutHash = hashIndex >= 0 ? substring(trimmed, 0, hashIndex) : trimmed;
+      const queryIndex = withoutHash.indexOf("?") | 0;
+      if (queryIndex >= 0) {
+        return substring(withoutHash, 0, queryIndex);
+      } else {
+        return withoutHash;
+      }
+    }
+  }
+}
+function isCwlReference(runPath) {
+  const candidate = trimToNameCandidate(runPath);
+  if (!isNullOrWhiteSpace(candidate)) {
+    return endsWith(candidate, ".cwl", 5);
+  } else {
+    return false;
+  }
+}
+function tryBasenameNoCwlExtension(value) {
+  const candidate = trimToNameCandidate(value);
+  if (isNullOrWhiteSpace(candidate)) {
+    return void 0;
+  } else {
+    const fileName = (candidate.indexOf("/") >= 0 ? true : candidate.indexOf("\\") >= 0) ? getFileName(candidate) : candidate;
+    const withoutCwlExtension = endsWith(fileName, ".cwl", 5) ? substring(fileName, 0, fileName.length - ".cwl".length) : fileName;
+    if (isNullOrWhiteSpace(withoutCwlExtension)) {
+      return void 0;
+    } else {
+      return withoutCwlExtension;
+    }
+  }
+}
+function tryGetProcessingUnitName(processingUnit) {
+  return tryPick((key) => {
+    let dynObj, matchValue, o;
+    return bind(tryBasenameNoCwlExtension, (dynObj = processingUnit, matchValue = dynObj.TryGetPropertyValue(key), matchValue != null ? (o = value(matchValue), typeof o === "string" ? o : void 0) : void 0));
+  }, ofArray(["name", "id"]));
+}
+function chooseLabel(fallback, candidates) {
+  return defaultArg(tryPick((x) => x, candidates), fallback);
+}
+function getRunPathCandidates(workflowFilePath, runPath) {
+  let array, array_2;
+  if (isNullOrWhiteSpace(runPath)) {
+    return [];
+  } else {
+    const trimmedRunPath = runPath.trim();
+    const normalizedRunPath = normalize(trimmedRunPath);
+    let matchResult, workflowPath_1;
+    if (workflowFilePath != null) {
+      if (!isNullOrWhiteSpace(value(workflowFilePath))) {
+        matchResult = 0;
+        workflowPath_1 = value(workflowFilePath);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0: {
+        const pathFromWorkflowFile = resolvePathFromFile(workflowPath_1, trimmedRunPath);
+        return Array_distinct((array = [trimmedRunPath, normalizedRunPath, pathFromWorkflowFile, normalize(pathFromWorkflowFile)], array.filter((arg) => !isNullOrWhiteSpace(arg))), {
+          Equals: (x, y) => x === y,
+          GetHashCode: stringHash
+        });
+      }
+      default:
+        return Array_distinct((array_2 = [trimmedRunPath, normalizedRunPath], array_2.filter((arg_1) => !isNullOrWhiteSpace(arg_1))), {
+          Equals: (x_1, y_1) => x_1 === y_1,
+          GetHashCode: stringHash
+        });
+    }
+  }
+}
+function resolveRunString(state, workflowFilePath, runPath) {
+  if (isNullOrWhiteSpace(runPath) ? true : !isCwlReference(runPath)) {
+    return new RunResolutionResult(WorkflowStepRun_RunString(runPath), void 0, false, []);
+  } else {
+    const matchValue = state.Options.TryResolveRunPath;
+    if (matchValue != null) {
+      const tryResolveRunPath = value(matchValue);
+      const candidates = getRunPathCandidates(workflowFilePath, runPath);
+      const candidateKeys = Array_distinct(map$1(normalizePathKey, candidates), {
+        Equals: (x, y) => x === y,
+        GetHashCode: stringHash
+      });
+      let resolvedRun = void 0;
+      for (let idx = 0; idx <= candidates.length - 1; idx++) {
+        const candidate = item(idx, candidates);
+        if (resolvedRun == null) {
+          const pathKey = normalizePathKey(candidate);
+          if (FSharpSet__Contains(state.RunResolutionStack, pathKey)) {
+            addDiagnostic(state, GraphIssueKind_CycleDetected(), `Cycle detected while resolving run reference '${candidate}'.`, workflowFilePath, candidate);
+          } else if (FSharpMap__ContainsKey(state.RunResolutionCache, pathKey)) {
+            resolvedRun = [FSharpMap__get_Item(state.RunResolutionCache, pathKey), candidate];
+          } else {
+            const matchValue_1 = tryResolveRunPath(candidate);
+            if (matchValue_1 == null) {
+            } else {
+              switch (value(matchValue_1).tag) {
+                case /* Workflow */
+                1: {
+                  const workflow = value(matchValue_1).fields[0];
+                  const run_1 = WorkflowStepRunOps_fromWorkflow(workflow);
+                  for (let idx_2 = 0; idx_2 <= candidateKeys.length - 1; idx_2++) {
+                    const key_1 = item(idx_2, candidateKeys);
+                    state.RunResolutionCache = FSharpMap__Add(state.RunResolutionCache, key_1, run_1);
+                  }
+                  resolvedRun = [run_1, candidate];
+                  break;
+                }
+                case /* ExpressionTool */
+                2: {
+                  const expressionTool = value(matchValue_1).fields[0];
+                  const run_2 = WorkflowStepRunOps_fromExpressionTool(expressionTool);
+                  for (let idx_3 = 0; idx_3 <= candidateKeys.length - 1; idx_3++) {
+                    const key_2 = item(idx_3, candidateKeys);
+                    state.RunResolutionCache = FSharpMap__Add(state.RunResolutionCache, key_2, run_2);
+                  }
+                  resolvedRun = [run_2, candidate];
+                  break;
+                }
+                case /* Operation */
+                3: {
+                  const operation = value(matchValue_1).fields[0];
+                  const run_3 = WorkflowStepRunOps_fromOperation(operation);
+                  for (let idx_4 = 0; idx_4 <= candidateKeys.length - 1; idx_4++) {
+                    const key_3 = item(idx_4, candidateKeys);
+                    state.RunResolutionCache = FSharpMap__Add(state.RunResolutionCache, key_3, run_3);
+                  }
+                  resolvedRun = [run_3, candidate];
+                  break;
+                }
+                default: {
+                  const tool = value(matchValue_1).fields[0];
+                  const run = WorkflowStepRunOps_fromTool(tool);
+                  for (let idx_1 = 0; idx_1 <= candidateKeys.length - 1; idx_1++) {
+                    const key = item(idx_1, candidateKeys);
+                    state.RunResolutionCache = FSharpMap__Add(state.RunResolutionCache, key, run);
+                  }
+                  resolvedRun = [run, candidate];
+                }
+              }
+            }
+          }
+        }
+      }
+      if (resolvedRun == null) {
+        addDiagnostic(state, GraphIssueKind_ResolutionFailed(), `Unable to resolve CWL run reference '${runPath}'.`, workflowFilePath, runPath);
+        return new RunResolutionResult(WorkflowStepRun_RunString(runPath), void 0, true, candidateKeys);
+      } else {
+        return new RunResolutionResult(value(resolvedRun)[0], value(resolvedRun)[1], true, candidateKeys);
+      }
+    } else {
+      if (state.Options.StrictUnresolvedRunReferences) {
+        addDiagnostic(state, GraphIssueKind_ResolutionFailed(), `Unable to resolve CWL run reference '${runPath}' because no run resolver is configured.`, workflowFilePath, runPath);
+      }
+      return new RunResolutionResult(WorkflowStepRun_RunString(runPath), void 0, state.Options.StrictUnresolvedRunReferences, []);
+    }
+  }
+}
+function buildProcessingUnit(state, scope, workflowFilePath, ownerNodeId, isRoot, processingUnit) {
+  switch (processingUnit.tag) {
+    case /* ExpressionTool */
+    2: {
+      const expressionTool = processingUnit.fields[0];
+      const nodeId_1 = addProcessingUnitNode(state, scope, ProcessingUnitKind_ExpressionTool(), chooseLabel("ExpressionTool", ofArray([tryGetProcessingUnitName(expressionTool), bind(tryBasenameNoCwlExtension, expressionTool.Label), bind(tryBasenameNoCwlExtension, workflowFilePath)])), ownerNodeId, void 0, createMetadata(ofArray([["cwlVersion", some(expressionTool.CWLVersion)], ["expression", some(expressionTool.Expression)]])));
+      addExpressionToolPorts(state, nodeId_1, expressionTool);
+      return nodeId_1;
+    }
+    case /* Operation */
+    3: {
+      const operation = processingUnit.fields[0];
+      const nodeId_2 = addProcessingUnitNode(state, scope, ProcessingUnitKind_Operation(), chooseLabel("Operation", ofArray([tryGetProcessingUnitName(operation), bind(tryBasenameNoCwlExtension, operation.Label), bind(tryBasenameNoCwlExtension, workflowFilePath)])), ownerNodeId, void 0, createMetadata(singleton(["cwlVersion", some(operation.CWLVersion)])));
+      addOperationPorts(state, nodeId_2, operation);
+      return nodeId_2;
+    }
+    case /* Workflow */
+    1: {
+      const workflow = processingUnit.fields[0];
+      const nodeId_3 = addProcessingUnitNode(state, scope, ProcessingUnitKind_Workflow(), chooseLabel("Workflow", ofArray([tryGetProcessingUnitName(workflow), bind(tryBasenameNoCwlExtension, workflow.Label), bind(tryBasenameNoCwlExtension, workflowFilePath)])), ownerNodeId, void 0, createMetadata(singleton(["cwlVersion", some(workflow.CWLVersion)])));
+      addWorkflowPorts(state, nodeId_3, workflow);
+      if (isRoot ? true : state.Options.ExpandNestedWorkflows) {
+        buildWorkflowSteps(state, scope, workflowFilePath, nodeId_3, workflow);
+      }
+      return nodeId_3;
+    }
+    default: {
+      const tool = processingUnit.fields[0];
+      const nodeId = addProcessingUnitNode(state, scope, ProcessingUnitKind_CommandLineTool(), chooseLabel("CommandLineTool", ofArray([tryGetProcessingUnitName(tool), bind(tryBasenameNoCwlExtension, tool.Label), bind(tryBasenameNoCwlExtension, bind(tryHead, tool.BaseCommand)), bind(tryBasenameNoCwlExtension, workflowFilePath)])), ownerNodeId, void 0, createMetadata(singleton(["cwlVersion", some(tool.CWLVersion)])));
+      addToolPorts(state, nodeId, tool);
+      return nodeId;
+    }
+  }
+}
+function buildRunNode(state, runScope, stepNodeId, workflowFilePath, run) {
+  let currentPath;
+  switch (run.tag) {
+    case /* RunCommandLineTool */
+    1: {
+      const matchValue_2 = WorkflowStepRunOps_tryGetTool(run);
+      if (matchValue_2 == null) {
+        const badNodeId = addProcessingUnitNode(state, runScope, ProcessingUnitKind_UnresolvedReference(), "Invalid CommandLineTool payload", stepNodeId, void 0, void 0);
+        addDiagnostic(state, GraphIssueKind_UnexpectedRuntimeType(), "WorkflowStepRun.RunCommandLineTool had an unexpected payload type.", workflowFilePath, void 0);
+        return [run, badNodeId];
+      } else {
+        return [run, buildProcessingUnit(state, runScope, workflowFilePath, stepNodeId, false, CWLProcessingUnit_CommandLineTool(value(matchValue_2)))];
+      }
+    }
+    case /* RunWorkflow */
+    2: {
+      const matchValue_3 = WorkflowStepRunOps_tryGetWorkflow(run);
+      if (matchValue_3 == null) {
+        const badNodeId_1 = addProcessingUnitNode(state, runScope, ProcessingUnitKind_UnresolvedReference(), "Invalid Workflow payload", stepNodeId, void 0, void 0);
+        addDiagnostic(state, GraphIssueKind_UnexpectedRuntimeType(), "WorkflowStepRun.RunWorkflow had an unexpected payload type.", workflowFilePath, void 0);
+        return [run, badNodeId_1];
+      } else {
+        const workflow = value(matchValue_3);
+        return [run, buildProcessingUnit(state, runScope, (currentPath = defaultArg(workflowFilePath, ""), isNullOrWhiteSpace(currentPath) ? void 0 : currentPath), stepNodeId, false, CWLProcessingUnit_Workflow(workflow))];
+      }
+    }
+    case /* RunExpressionTool */
+    3: {
+      const matchValue_4 = WorkflowStepRunOps_tryGetExpressionTool(run);
+      if (matchValue_4 == null) {
+        const badNodeId_2 = addProcessingUnitNode(state, runScope, ProcessingUnitKind_UnresolvedReference(), "Invalid ExpressionTool payload", stepNodeId, void 0, void 0);
+        addDiagnostic(state, GraphIssueKind_UnexpectedRuntimeType(), "WorkflowStepRun.RunExpressionTool had an unexpected payload type.", workflowFilePath, void 0);
+        return [run, badNodeId_2];
+      } else {
+        return [run, buildProcessingUnit(state, runScope, workflowFilePath, stepNodeId, false, CWLProcessingUnit_ExpressionTool(value(matchValue_4)))];
+      }
+    }
+    case /* RunOperation */
+    4: {
+      const matchValue_5 = WorkflowStepRunOps_tryGetOperation(run);
+      if (matchValue_5 == null) {
+        const badNodeId_3 = addProcessingUnitNode(state, runScope, ProcessingUnitKind_UnresolvedReference(), "Invalid Operation payload", stepNodeId, void 0, void 0);
+        addDiagnostic(state, GraphIssueKind_UnexpectedRuntimeType(), "WorkflowStepRun.RunOperation had an unexpected payload type.", workflowFilePath, void 0);
+        return [run, badNodeId_3];
+      } else {
+        return [run, buildProcessingUnit(state, runScope, workflowFilePath, stepNodeId, false, CWLProcessingUnit_Operation(value(matchValue_5)))];
+      }
+    }
+    default: {
+      const resolution = resolveRunString(state, workflowFilePath, run.fields[0]);
+      const matchValue = resolution.ResolvedRun;
+      if (matchValue.tag === /* RunString */
+      0) {
+        const unresolvedPath = matchValue.fields[0];
+        const unresolvedLabel = chooseLabel(unresolvedPath, toList(delay(() => isCwlReference(unresolvedPath) ? singleton$1(tryBasenameNoCwlExtension(unresolvedPath)) : singleton$1(void 0))));
+        return [resolution.ResolvedRun, addProcessingUnitNode(state, runScope, resolution.AttemptedLookup && isCwlReference(unresolvedPath) ? ProcessingUnitKind_UnresolvedReference() : ProcessingUnitKind_ExternalReference(), unresolvedLabel, stepNodeId, unresolvedPath, void 0)];
+      } else {
+        const resolvedRun = matchValue;
+        const cachedRunNodeId = tryPick$1((key) => tryFind(key, state.RunNodeCache), resolution.ResolutionPathKeys);
+        if (cachedRunNodeId == null) {
+          let patternInput;
+          const matchValue_1 = resolution.ResolvedFromPath;
+          if (matchValue_1 == null) {
+            patternInput = buildRunNode(state, runScope, stepNodeId, resolution.ResolvedFromPath, resolvedRun);
+          } else {
+            const resolvedPathKey = normalizePathKey(value(matchValue_1));
+            const previousStack = state.RunResolutionStack;
+            state.RunResolutionStack = FSharpSet__Add(previousStack, resolvedPathKey);
+            try {
+              patternInput = buildRunNode(state, runScope, stepNodeId, resolution.ResolvedFromPath, resolvedRun);
+            } finally {
+              state.RunResolutionStack = previousStack;
+            }
+          }
+          const builtNodeId = patternInput[1];
+          const arr = resolution.ResolutionPathKeys;
+          for (let idx = 0; idx <= arr.length - 1; idx++) {
+            const key_1 = item(idx, arr);
+            state.RunNodeCache = FSharpMap__Add(state.RunNodeCache, key_1, builtNodeId);
+          }
+          return [patternInput[0], builtNodeId];
+        } else {
+          return [resolvedRun, value(cachedRunNodeId)];
+        }
+      }
+    }
+  }
+}
+function wireStepInputs(state, scope, workflowNodeId, step) {
+  const stepNodeId = GraphId_stepNodeId(scope, step.Id);
+  let enumerator = getEnumerator(step.In);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const stepInput = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      const targetInputPortId = GraphId_portNodeId(stepNodeId, PortDirection_Input(), stepInput.Id);
+      const matchValue = stepInput.Source;
+      if (matchValue != null) {
+        let enumerator_1 = getEnumerator(value(matchValue));
+        try {
+          while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+            const source = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            const sourceRef = ReferenceParsing_parseSourceReference(source);
+            if (isNullOrWhiteSpace(sourceRef.PortId)) {
+              addDiagnostic(state, GraphIssueKind_InvalidReference(), `Step '${step.Id}' input '${stepInput.Id}' has invalid source '${source}'.`, scope, source);
+            } else {
+              let sourcePortId;
+              const matchValue_1 = sourceRef.StepId;
+              sourcePortId = matchValue_1 == null ? GraphId_portNodeId(workflowNodeId, PortDirection_Input(), sourceRef.PortId) : GraphId_portNodeId(GraphId_stepNodeId(scope, value(matchValue_1)), PortDirection_Output(), sourceRef.PortId);
+              if (hasNode(state, sourcePortId) && hasNode(state, targetInputPortId)) {
+                addEdgeByType(state, sourceRef.StepId == null ? EdgeKind_BindsWorkflowInput() : EdgeKind_DataFlow(), sourcePortId, targetInputPortId, void 0);
+              } else {
+                addDiagnostic(state, GraphIssueKind_MissingReference(), `Unable to wire source '${source}' to step input '${step.Id}/${stepInput.Id}'.`, scope, source);
+              }
+            }
+          }
+        } finally {
+          disposeSafe(enumerator_1);
+        }
+      }
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+}
+function wireWorkflowOutputs(state, scope, workflowNodeId, workflow) {
+  let enumerator = getEnumerator(workflow.Outputs);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const output = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      let enumerator_1 = getEnumerator(output.GetOutputSources());
+      try {
+        while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+          const outputSource = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+          const parsedSource = ReferenceParsing_parseSourceReference(outputSource);
+          if (isNullOrWhiteSpace(parsedSource.PortId)) {
+            addDiagnostic(state, GraphIssueKind_InvalidReference(), `Workflow output '${output.Name}' has invalid outputSource '${outputSource}'.`, scope, outputSource);
+          } else {
+            let sourcePortId;
+            const matchValue = parsedSource.StepId;
+            sourcePortId = matchValue == null ? GraphId_portNodeId(workflowNodeId, PortDirection_Input(), parsedSource.PortId) : GraphId_portNodeId(GraphId_stepNodeId(scope, value(matchValue)), PortDirection_Output(), parsedSource.PortId);
+            const targetPortId = GraphId_portNodeId(workflowNodeId, PortDirection_Output(), output.Name);
+            if (hasNode(state, sourcePortId) && hasNode(state, targetPortId)) {
+              addEdgeByType(state, EdgeKind_BindsWorkflowOutput(), sourcePortId, targetPortId, void 0);
+            } else {
+              addDiagnostic(state, GraphIssueKind_MissingReference(), `Unable to wire workflow output '${output.Name}' from source '${outputSource}'.`, scope, outputSource);
+            }
+          }
+        }
+      } finally {
+        disposeSafe(enumerator_1);
+      }
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+}
+function buildWorkflowSteps(state, scope, workflowFilePath, workflowNodeId, workflow) {
+  let enumerator = getEnumerator(workflow.Steps);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const step = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      const stepNodeId = addStepNode(state, scope, workflowNodeId, step);
+      addStepPorts(state, stepNodeId, step);
+      addEdgeByType(state, EdgeKind_Calls(), stepNodeId, buildRunNode(state, GraphId_childScope(scope, `${step.Id}/run`), stepNodeId, workflowFilePath, step.Run)[1], "calls");
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  iterate((step_1) => {
+    wireStepInputs(state, scope, workflowNodeId, step_1);
+  }, workflow.Steps);
+  wireWorkflowOutputs(state, scope, workflowNodeId, workflow);
+}
+function buildWith(options, processingUnit) {
+  const rootScope = GraphId_normalizeSegment(options.RootScope);
+  const rootScope_1 = isNullOrWhiteSpace(rootScope) ? "root" : rootScope;
+  const state = createState(options, GraphId_unitNodeId(rootScope_1));
+  buildProcessingUnit(state, rootScope_1, options.RootWorkflowFilePath, void 0, true, processingUnit);
+  return state.Graph;
+}
+function build(processingUnit) {
+  return buildWith(WorkflowGraphBuildOptionsModule_defaultOptions, processingUnit);
+}
+
+export { BuildState, BuildState_$reflection, RunResolutionResult, RunResolutionResult_$reflection, addDiagnostic, addEdge, addEdgeByType, addExpressionToolPorts, addNode, addOperationPorts, addPortNode, addProcessingUnitNode, addStepNode, addStepPorts, addToolPorts, addWorkflowPorts, build, buildProcessingUnit, buildRunNode, buildWith, buildWorkflowSteps, chooseLabel, createGraph, createMetadata, createState, getRunPathCandidates, hasNode, isCwlReference, resolveRunString, trimToNameCandidate, tryBasenameNoCwlExtension, tryGetProcessingUnitName, wireStepInputs, wireWorkflowOutputs };