@nfdi4plants/arctrl 3.0.0-beta.9 → 3.0.1

package/dist/ts/ts/Conversion/Workflow.js

@@ -0,0 +1,455 @@
+import { class_type } from '../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { isComplexType, cwlTypeToYamlString, writeYaml, encodeCWLType } from '../CWL/Encode.js';
+import { read } from '../fable_modules/YAMLicious.1.0.0-alpha.4/Reader.fs.js';
+import { YAMLElement_Sequence, YAMLElement_Comment } from '../fable_modules/YAMLicious.1.0.0-alpha.4/YAMLiciousTypes.fs.js';
+import { object } from '../fable_modules/YAMLicious.1.0.0-alpha.4/Decode.fs.js';
+import { Decode_cwlTypeDecoder$0027, Decode_cwlTypeStringMatcher } from '../CWL/Decode.js';
+import { isEmpty, head, tail } from '../../node_modules/@fable-org/fable-library-js/List.js';
+import { value, defaultArg, unwrap, bind, map } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { LDPropertyValue } from '../ROCrate/LDTypes/PropertyValue.js';
+import { LDFormalParameter } from '../ROCrate/LDTypes/FormalParameter.js';
+import { InputBinding_create_ZAC0108A, CWLInput } from '../CWL/Inputs.js';
+import { tryPick, exactlyOne, toArray, find } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { OutputBinding_create_6DFDD678, CWLOutput } from '../CWL/Outputs.js';
+import { int32ToString, stringHash } from '../../node_modules/@fable-org/fable-library-js/Util.js';
+import { Component_create_Z2F0B38C7 } from '../Core/Process/Component.js';
+import { BaseTypes_decomposePropertyValue_Z2F770004, BaseTypes_composeDefinedTerm_ZDED3A0F, BaseTypes_composeComment_Z13201A7E, BaseTypes_decomposeDefinedTerm_Z2F770004, BaseTypes_decomposeComment_Z2F770004 } from './Basic.js';
+import { CWLProcessingUnit_getInputs_30922B92, CWLProcessingUnit_Workflow, CWLProcessingUnit_ExpressionTool, CWLProcessingUnit_Operation, CWLProcessingUnit_CommandLineTool } from '../CWL/CWLProcessingUnit.js';
+import { WorkflowStep, WorkflowStepRun_RunString } from '../CWL/WorkflowSteps.js';
+import { normalize } from '../FileSystem/Path.js';
+import { tryPick as tryPick$1 } from '../../node_modules/@fable-org/fable-library-js/Array.js';
+import { distinct } from '../../node_modules/@fable-org/fable-library-js/Seq2.js';
+import { LDDataset } from '../ROCrate/LDTypes/Dataset.js';
+import { LDWorkflowProtocol } from '../ROCrate/LDTypes/WorkflowProtocol.js';
+import { ResizeArray_map, ResizeArray_singleton, Option_fromSeq, ResizeArray_choose, ResizeArray_appendSingleton, Option_fromValueWithDefault } from '../Core/Helper/Collections.js';
+import { LDComputerLanguage } from '../ROCrate/LDTypes/ComputerLanguage.js';
+import { CWLToolDescription } from '../CWL/ToolDescription.js';
+import { LDComputationalWorkflow } from '../ROCrate/LDTypes/ComputationalWorkflow.js';
+import { LDLabProtocol } from '../ROCrate/LDTypes/LabProtocol.js';
+import { CWLExpressionToolDescription } from '../CWL/ExpressionToolDescription.js';
+import { CWLOperationDescription } from '../CWL/OperationDescription.js';
+import { CWLWorkflowDescription } from '../CWL/WorkflowDescription.js';
+import { resolveWorkflowStepRunFromLookup } from '../CWLRunResolver.js';
+import { Workflow_cwlFileNameFromIdentifier } from '../Core/Helper/Identifier.js';
+import { toFail, printf } from '../../node_modules/@fable-org/fable-library-js/String.js';
+import { LDOrganization } from '../ROCrate/LDTypes/Organization.js';
+import { PersonConversion_composePerson_Z64D846DC, PersonConversion_decomposePerson_Z6839B9E8 } from './Person.js';
+import { utcNow } from '../../node_modules/@fable-org/fable-library-js/Date.js';
+import { DatamapConversion_composeFragmentDescriptors_Z892BFC3, DatamapConversion_decomposeFragmentDescriptors_Z6E59645F } from './Datamap.js';
+import { Datamap } from '../Core/Datamap.js';
+import { ArcWorkflow } from '../Core/ArcTypes.js';
+
+class WorkflowConversion {
+  constructor() {
+  }
+}
+function WorkflowConversion_$reflection() {
+  return class_type("ARCtrl.Conversion.WorkflowConversion", void 0, WorkflowConversion);
+}
+function WorkflowConversion_composeAdditionalType_Z5C31A0F9(t) {
+  if (isComplexType(t)) {
+    return cwlTypeToYamlString(t);
+  } else {
+    const s = writeYaml(encodeCWLType(t));
+    return s.trim();
+  }
+}
+function WorkflowConversion_decomposeAdditionalType_Z721C83C5(t) {
+  const yamlElement = read(t);
+  let matchResult, items;
+  switch (yamlElement.tag) {
+    case /* Value */
+    1: {
+      matchResult = 0;
+      break;
+    }
+    case /* Object */
+    3: {
+      if (!isEmpty(yamlElement.fields[0])) {
+        if (head(yamlElement.fields[0]).tag === /* Sequence */
+        2) {
+          if (isEmpty(tail(yamlElement.fields[0]))) {
+            matchResult = 1;
+            items = head(yamlElement.fields[0]).fields[0];
+          } else {
+            matchResult = 2;
+          }
+        } else {
+          matchResult = 2;
+        }
+      } else {
+        matchResult = 2;
+      }
+      break;
+    }
+    default:
+      matchResult = 2;
+  }
+  switch (matchResult) {
+    case 0:
+      return object((get$) => Decode_cwlTypeStringMatcher(t, get$), YAMLElement_Comment("unused-shorthand-context"))[0];
+    case 1:
+      return Decode_cwlTypeDecoder$0027(YAMLElement_Sequence(items));
+    default:
+      return Decode_cwlTypeDecoder$0027(yamlElement);
+  }
+}
+function WorkflowConversion_composeFormalParamInputIdentifiers(prefix, position) {
+  if (prefix == null) {
+    if (position == null) {
+      return void 0;
+    } else {
+      const po_1 = value(position) | 0;
+      return [LDPropertyValue.createPosition(po_1)];
+    }
+  } else if (position == null) {
+    const pr_1 = value(prefix);
+    return [LDPropertyValue.createPrefix(pr_1)];
+  } else {
+    const po = value(position) | 0;
+    const pr = value(prefix);
+    return [LDPropertyValue.createPosition(po), LDPropertyValue.createPrefix(pr)];
+  }
+}
+function WorkflowConversion_composeFormalParameterFromInput_Z7A02DED7(inp, workflowName, runName) {
+  let additionalType;
+  const matchValue = inp.Type_;
+  if (matchValue == null) {
+    throw new Error("Input must have a type");
+  } else {
+    additionalType = WorkflowConversion_composeAdditionalType_Z5C31A0F9(value(matchValue));
+  }
+  const valueRequired = !defaultArg(inp.Optional, false);
+  const id = LDFormalParameter.genID(inp.Name, unwrap(workflowName), unwrap(runName));
+  const identifiers = bind((ib) => WorkflowConversion_composeFormalParamInputIdentifiers(ib.Prefix, ib.Position), inp.InputBinding);
+  return LDFormalParameter.create(additionalType, id, void 0, inp.Name, void 0, void 0, void 0, void 0, valueRequired, unwrap(identifiers));
+}
+function WorkflowConversion_decomposeInputBindings_1AAAE9A5(identifiers, context) {
+  const prefix = tryPick((n) => LDPropertyValue.tryGetAsPrefix(n, unwrap(context)), identifiers);
+  const position = tryPick((n_1) => LDPropertyValue.tryGetAsPosition(n_1, unwrap(context)), identifiers);
+  let matchResult;
+  if (prefix == null) {
+    if (position == null) {
+      matchResult = 0;
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return void 0;
+    default:
+      return InputBinding_create_ZAC0108A(unwrap(prefix), unwrap(position));
+  }
+}
+function WorkflowConversion_decomposeInputFromFormalParameter_2664C4B8(inp, context, graph) {
+  const t_1 = WorkflowConversion_decomposeAdditionalType_Z721C83C5(exactlyOne(inp.AdditionalType));
+  const binding = WorkflowConversion_decomposeInputBindings_1AAAE9A5(LDFormalParameter.getIdentifiers(inp, unwrap(graph), unwrap(context)), unwrap(context));
+  let optional;
+  const matchValue = LDFormalParameter.tryGetValueRequiredAsBoolean(inp, unwrap(context));
+  let matchResult;
+  if (matchValue != null) {
+    if (value(matchValue)) {
+      matchResult = 0;
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0: {
+      optional = void 0;
+      break;
+    }
+    default:
+      optional = true;
+  }
+  return new CWLInput(LDFormalParameter.getNameAsString(inp, unwrap(context)), t_1, unwrap(binding), unwrap(optional));
+}
+function WorkflowConversion_composeFormalParameterOutputIdentifiers_6DFDD678(glob) {
+  if (glob == null) {
+    return void 0;
+  } else {
+    const g = value(glob);
+    return [LDPropertyValue.createGlob(g)];
+  }
+}
+function WorkflowConversion_composeFormalParameterFromOutput_Z25C7EC80(out, workflowName, runName) {
+  let additionalType;
+  const matchValue = out.Type_;
+  if (matchValue == null) {
+    throw new Error("Output must have a type");
+  } else {
+    additionalType = WorkflowConversion_composeAdditionalType_Z5C31A0F9(value(matchValue));
+  }
+  const id = LDFormalParameter.genID(out.Name, unwrap(workflowName), unwrap(runName));
+  const identifiers = bind((ob) => WorkflowConversion_composeFormalParameterOutputIdentifiers_6DFDD678(ob.Glob), out.OutputBinding);
+  return LDFormalParameter.create(additionalType, id, void 0, out.Name, void 0, void 0, void 0, void 0, true, unwrap(identifiers));
+}
+function WorkflowConversion_decomposeOutputBindings_1AAAE9A5(identifiers, context) {
+  return OutputBinding_create_6DFDD678(unwrap(tryPick((n) => LDPropertyValue.tryGetAsGlob(n, unwrap(context)), identifiers)));
+}
+function WorkflowConversion_decomposeOutputFromFormalParameter_2664C4B8(outp, context, graph) {
+  const t_1 = WorkflowConversion_decomposeAdditionalType_Z721C83C5(exactlyOne(outp.AdditionalType));
+  const binding = WorkflowConversion_decomposeOutputBindings_1AAAE9A5(LDFormalParameter.getIdentifiers(outp, unwrap(graph), unwrap(context)), unwrap(context));
+  const optional = map((value) => !value, LDFormalParameter.tryGetValueRequiredAsBoolean(outp, unwrap(context)));
+  return new CWLOutput(LDFormalParameter.getNameAsString(outp, unwrap(context)), t_1, binding);
+}
+function WorkflowConversion_composeComputationalTool_Z685B8F25(tool) {
+  let c, f, i, oa, s;
+  let patternInput;
+  const matchValue = tool.ComponentType;
+  let matchResult, c_1;
+  if (matchValue != null) {
+    if (c = value(matchValue), c.Name != null) {
+      matchResult = 0;
+      c_1 = value(matchValue);
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0: {
+      patternInput = [value(c_1.Name), c_1.TermAccessionNumber];
+      break;
+    }
+    default:
+      throw new Error("Component must have a type");
+  }
+  let patternInput_1;
+  const matchValue_1 = tool.ComponentValue;
+  patternInput_1 = matchValue_1 == null ? [void 0, void 0] : value(matchValue_1).tag === /* Float */
+  2 ? (f = value(matchValue_1).fields[0], [f.toString(), void 0]) : value(matchValue_1).tag === /* Int */
+  1 ? (i = value(matchValue_1).fields[0] | 0, [int32ToString(i), void 0]) : value(matchValue_1).tag === /* Ontology */
+  0 ? (oa = value(matchValue_1).fields[0], [oa.Name, oa.TermAccessionNumber]) : (s = value(matchValue_1).fields[0], [s, void 0]);
+  let patternInput_2;
+  const matchValue_2 = tool.ComponentUnit;
+  if (matchValue_2 == null) {
+    patternInput_2 = [void 0, void 0];
+  } else {
+    const oa_1 = value(matchValue_2);
+    patternInput_2 = [oa_1.Name, oa_1.TermAccessionNumber];
+  }
+  return LDPropertyValue.createComponent(patternInput[0], unwrap(patternInput_1[0]), void 0, unwrap(patternInput[1]), unwrap(patternInput_2[1]), unwrap(patternInput_2[0]), unwrap(patternInput_1[1]));
+}
+function WorkflowConversion_decomposeComputationalTool_Z6839B9E8(tool, graph, context) {
+  const patternInput = BaseTypes_decomposePropertyValue_Z2F770004(tool, unwrap(context));
+  return Component_create_Z2F0B38C7(unwrap(patternInput[1]), unwrap(patternInput[2]), patternInput[0]);
+}
+function WorkflowConversion_getInputParametersFromProcessingUnit_30922B92(pu) {
+  return CWLProcessingUnit_getInputs_30922B92(pu);
+}
+function WorkflowConversion_get_toolDescriptionTypeName() {
+  return "ToolDescription";
+}
+function WorkflowConversion_get_workflowDescriptionTypeName() {
+  return "WorkflowDescription";
+}
+function WorkflowConversion_get_expressionToolDescriptionTypeName() {
+  return "ExpressionToolDescription";
+}
+function WorkflowConversion_get_operationDescriptionTypeName() {
+  return "OperationDescription";
+}
+function WorkflowConversion_runToIdentifier_Z4EBA8CB1(run) {
+  switch (run.tag) {
+    case /* RunCommandLineTool */
+    1:
+      return "inline:CommandLineTool";
+    case /* RunWorkflow */
+    2:
+      return "inline:Workflow";
+    case /* RunExpressionTool */
+    3:
+      return "inline:ExpressionTool";
+    case /* RunOperation */
+    4:
+      return "inline:Operation";
+    default:
+      return run.fields[0];
+  }
+}
+function WorkflowConversion_tryDecodeProcessingUnitFromGraph_Z5AC69418(resolvedRunPath, graph, context) {
+  let node, node_1, node_2;
+  const tryDecodeWorkflowProtocol = (protocol) => {
+    try {
+      return WorkflowConversion_decomposeWorkflowProtocolToProcessingUnit_ZB11202F(protocol, false, unwrap(context), unwrap(graph));
+    } catch (matchValue) {
+      return void 0;
+    }
+  };
+  if (graph != null) {
+    const graph_1 = value(graph);
+    const normalizedResolvedRunPath = normalize(resolvedRunPath);
+    const candidateNode = tryPick$1((id) => graph_1.TryGetNode(id), toArray(distinct([resolvedRunPath, normalizedResolvedRunPath, `./${normalizedResolvedRunPath}`], {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    })));
+    let matchResult, node_3, node_4, node_5;
+    if (candidateNode != null) {
+      if (node = value(candidateNode), LDWorkflowProtocol.validate(node, unwrap(context))) {
+        matchResult = 0;
+        node_3 = value(candidateNode);
+      } else if (node_1 = value(candidateNode), LDDataset.validateARCWorkflow(node_1, graph_1, unwrap(context))) {
+        matchResult = 1;
+        node_4 = value(candidateNode);
+      } else if (node_2 = value(candidateNode), LDDataset.validateARCRun(node_2, unwrap(context))) {
+        matchResult = 2;
+        node_5 = value(candidateNode);
+      } else {
+        matchResult = 3;
+      }
+    } else {
+      matchResult = 3;
+    }
+    switch (matchResult) {
+      case 0:
+        return tryDecodeWorkflowProtocol(node_3);
+      case 1:
+        return bind(tryDecodeWorkflowProtocol, LDDataset.tryGetMainEntityAsWorkflowProtocol(node_4, graph_1, unwrap(context)));
+      case 2:
+        return bind(tryDecodeWorkflowProtocol, LDDataset.tryGetMainEntityAsWorkflowProtocol(node_5, graph_1, unwrap(context)));
+      default:
+        return void 0;
+    }
+  } else {
+    return void 0;
+  }
+}
+function WorkflowConversion_composeWorkflowProtocolFromToolDescription_7B8357DA(filePath, workflow, workflowName, runName) {
+  const inputs = map((a) => ResizeArray_map((i) => WorkflowConversion_composeFormalParameterFromInput_Z7A02DED7(i, unwrap(workflowName), unwrap(runName)), a), workflow.Inputs);
+  const outputs = ResizeArray_map((o) => WorkflowConversion_composeFormalParameterFromOutput_Z25C7EC80(o, unwrap(workflowName), unwrap(runName)), workflow.Outputs);
+  return LDWorkflowProtocol.create(filePath, unwrap(inputs), outputs, void 0, void 0, void 0, filePath, ResizeArray_singleton(LDComputerLanguage.createCWL()), void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, [WorkflowConversion_get_toolDescriptionTypeName()]);
+}
+function WorkflowConversion_decomposeWorkflowProtocolToToolDescription_2664C4B8(protocol, context, graph) {
+  const inputs = ResizeArray_map((i) => WorkflowConversion_decomposeInputFromFormalParameter_2664C4B8(i, unwrap(context), unwrap(graph)), LDComputationalWorkflow.getInputsAsFormalParameters(protocol, unwrap(graph), unwrap(context)));
+  return new CWLToolDescription(ResizeArray_map((o) => WorkflowConversion_decomposeOutputFromFormalParameter_2664C4B8(o, unwrap(context), unwrap(graph)), LDComputationalWorkflow.getOutputsAsFormalParameter(protocol, unwrap(graph), unwrap(context))), void 0, void 0, void 0, void 0, void 0, inputs);
+}
+function WorkflowConversion_composeWorkflowProtocolFromExpressionToolDescription_Z7BEB6658(filePath, expressionTool, workflowName, runName) {
+  const inputs = map((a) => ResizeArray_map((i) => WorkflowConversion_composeFormalParameterFromInput_Z7A02DED7(i, unwrap(workflowName), unwrap(runName)), a), expressionTool.Inputs);
+  const outputs = ResizeArray_map((o) => WorkflowConversion_composeFormalParameterFromOutput_Z25C7EC80(o, unwrap(workflowName), unwrap(runName)), expressionTool.Outputs);
+  const protocol = LDWorkflowProtocol.create(filePath, unwrap(inputs), outputs, void 0, void 0, void 0, filePath, ResizeArray_singleton(LDComputerLanguage.createCWL()), void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, [WorkflowConversion_get_expressionToolDescriptionTypeName()]);
+  LDLabProtocol.setDescriptionAsString(protocol, expressionTool.Expression);
+  return protocol;
+}
+function WorkflowConversion_decomposeWorkflowProtocolToExpressionToolDescription_2664C4B8(protocol, context, graph) {
+  const inputs = ResizeArray_map((i) => WorkflowConversion_decomposeInputFromFormalParameter_2664C4B8(i, unwrap(context), unwrap(graph)), LDComputationalWorkflow.getInputsAsFormalParameters(protocol, unwrap(graph), unwrap(context)));
+  return new CWLExpressionToolDescription(ResizeArray_map((o) => WorkflowConversion_decomposeOutputFromFormalParameter_2664C4B8(o, unwrap(context), unwrap(graph)), LDComputationalWorkflow.getOutputsAsFormalParameter(protocol, unwrap(graph), unwrap(context))), defaultArg(LDLabProtocol.tryGetDescriptionAsString(protocol, unwrap(context)), "$(null)"), void 0, void 0, void 0, void 0, inputs);
+}
+function WorkflowConversion_composeWorkflowProtocolFromOperationDescription_Z75DE0D49(filePath, operation, workflowName, runName) {
+  const inputs = ResizeArray_map((i) => WorkflowConversion_composeFormalParameterFromInput_Z7A02DED7(i, unwrap(workflowName), unwrap(runName)), operation.Inputs);
+  const outputs = ResizeArray_map((o) => WorkflowConversion_composeFormalParameterFromOutput_Z25C7EC80(o, unwrap(workflowName), unwrap(runName)), operation.Outputs);
+  return LDWorkflowProtocol.create(filePath, inputs, outputs, void 0, void 0, void 0, filePath, ResizeArray_singleton(LDComputerLanguage.createCWL()), void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, [WorkflowConversion_get_operationDescriptionTypeName()]);
+}
+function WorkflowConversion_decomposeWorkflowProtocolToOperationDescription_2664C4B8(protocol, context, graph) {
+  return new CWLOperationDescription(ResizeArray_map((i) => WorkflowConversion_decomposeInputFromFormalParameter_2664C4B8(i, unwrap(context), unwrap(graph)), LDComputationalWorkflow.getInputsAsFormalParameters(protocol, unwrap(graph), unwrap(context))), ResizeArray_map((o) => WorkflowConversion_decomposeOutputFromFormalParameter_2664C4B8(o, unwrap(context), unwrap(graph)), LDComputationalWorkflow.getOutputsAsFormalParameter(protocol, unwrap(graph), unwrap(context))));
+}
+function WorkflowConversion_composeWorkflowStep_Z35AB9E5D(step, workflowID) {
+  const id = `WorkflowStep_${workflowID}_${step.Id}`;
+  const cw = LDComputationalWorkflow.create(id, void 0, void 0, void 0, void 0, void 0, step.Id);
+  LDDataset.setIdentifierAsString(cw, WorkflowConversion_runToIdentifier_Z4EBA8CB1(step.Run));
+  return cw;
+}
+function WorkflowConversion_composeWorkflowProtocolFromWorkflow_Z6FBB852F(filePath, workflow, workflowName, runName) {
+  const inputs = ResizeArray_map((i) => WorkflowConversion_composeFormalParameterFromInput_Z7A02DED7(i, unwrap(workflowName), unwrap(runName)), workflow.Inputs);
+  const outputs = ResizeArray_map((o) => WorkflowConversion_composeFormalParameterFromOutput_Z25C7EC80(o, unwrap(workflowName), unwrap(runName)), workflow.Outputs);
+  const steps = ResizeArray_map((s) => WorkflowConversion_composeWorkflowStep_Z35AB9E5D(s, filePath), workflow.Steps);
+  return LDWorkflowProtocol.create(filePath, inputs, outputs, void 0, void 0, void 0, filePath, ResizeArray_singleton(LDComputerLanguage.createCWL()), void 0, void 0, void 0, void 0, steps, void 0, void 0, void 0, [WorkflowConversion_get_workflowDescriptionTypeName()]);
+}
+function WorkflowConversion_decomposeWorkflowStep_77DD0449(step, workflowFilePath, resolveRunReferences, context, graph) {
+  let initialRun;
+  return new WorkflowStep(LDComputationalWorkflow.getNameAsString(step, unwrap(context)), [], [], (initialRun = WorkflowStepRun_RunString(LDDataset.getIdentifierAsString(step, unwrap(context))), !defaultArg(resolveRunReferences, true) ? initialRun : workflowFilePath == null ? initialRun : resolveWorkflowStepRunFromLookup(value(workflowFilePath), initialRun, (runPath) => WorkflowConversion_tryDecodeProcessingUnitFromGraph_Z5AC69418(runPath, unwrap(graph), unwrap(context)))));
+}
+function WorkflowConversion_decomposeWorkflowProtocolToWorkflow_ZB11202F(protocol, resolveRunReferences, context, graph) {
+  const workflowFilePath = defaultArg(LDDataset.tryGetIdentifierAsString(protocol, unwrap(context)), protocol.Id);
+  const shouldResolveRunReferences = defaultArg(resolveRunReferences, true);
+  const inputs = ResizeArray_map((i) => WorkflowConversion_decomposeInputFromFormalParameter_2664C4B8(i, unwrap(context), unwrap(graph)), LDComputationalWorkflow.getInputsAsFormalParameters(protocol, unwrap(graph), unwrap(context)));
+  const outputs = ResizeArray_map((o) => WorkflowConversion_decomposeOutputFromFormalParameter_2664C4B8(o, unwrap(context), unwrap(graph)), LDComputationalWorkflow.getOutputsAsFormalParameter(protocol, unwrap(graph), unwrap(context)));
+  return new CWLWorkflowDescription(ResizeArray_map((s) => WorkflowConversion_decomposeWorkflowStep_77DD0449(s, workflowFilePath, shouldResolveRunReferences, unwrap(context), unwrap(graph)), LDComputationalWorkflow.getHasPart(protocol, unwrap(graph), unwrap(context))), inputs, outputs);
+}
+function WorkflowConversion_composeWorkflowProtocolFromProcessingUnit_Z3099C0F7(filePath, pu, workflowName, runName) {
+  switch (pu.tag) {
+    case /* Workflow */
+    1:
+      return WorkflowConversion_composeWorkflowProtocolFromWorkflow_Z6FBB852F(filePath, pu.fields[0], unwrap(workflowName), unwrap(runName));
+    case /* ExpressionTool */
+    2:
+      return WorkflowConversion_composeWorkflowProtocolFromExpressionToolDescription_Z7BEB6658(filePath, pu.fields[0], unwrap(workflowName), unwrap(runName));
+    case /* Operation */
+    3:
+      return WorkflowConversion_composeWorkflowProtocolFromOperationDescription_Z75DE0D49(filePath, pu.fields[0], unwrap(workflowName), unwrap(runName));
+    default:
+      return WorkflowConversion_composeWorkflowProtocolFromToolDescription_7B8357DA(filePath, pu.fields[0], unwrap(workflowName), unwrap(runName));
+  }
+}
+function WorkflowConversion_decomposeWorkflowProtocolToProcessingUnit_ZB11202F(protocol, resolveRunReferences, context, graph) {
+  const shouldResolveRunReferences = defaultArg(resolveRunReferences, true);
+  const matchValue = LDComputationalWorkflow.getAdditionalTypeAsString(protocol, unwrap(context));
+  if (matchValue === WorkflowConversion_get_workflowDescriptionTypeName()) {
+    return CWLProcessingUnit_Workflow(WorkflowConversion_decomposeWorkflowProtocolToWorkflow_ZB11202F(protocol, shouldResolveRunReferences, unwrap(context), unwrap(graph)));
+  } else if (matchValue === WorkflowConversion_get_expressionToolDescriptionTypeName()) {
+    return CWLProcessingUnit_ExpressionTool(WorkflowConversion_decomposeWorkflowProtocolToExpressionToolDescription_2664C4B8(protocol, unwrap(context), unwrap(graph)));
+  } else if (matchValue === WorkflowConversion_get_operationDescriptionTypeName()) {
+    return CWLProcessingUnit_Operation(WorkflowConversion_decomposeWorkflowProtocolToOperationDescription_2664C4B8(protocol, unwrap(context), unwrap(graph)));
+  } else {
+    return CWLProcessingUnit_CommandLineTool(WorkflowConversion_decomposeWorkflowProtocolToToolDescription_2664C4B8(protocol, unwrap(context), unwrap(graph)));
+  }
+}
+function WorkflowConversion_composeWorkflow_42450E6E(workflow, fs) {
+  let workflowProtocol;
+  const workflowFilePath = Workflow_cwlFileNameFromIdentifier(workflow.Identifier);
+  const matchValue = workflow.CWLDescription;
+  if (matchValue == null) {
+    const arg = workflow.Identifier;
+    workflowProtocol = toFail(printf("Workflow %s must have a CWL description"))(arg);
+  } else {
+    workflowProtocol = WorkflowConversion_composeWorkflowProtocolFromProcessingUnit_Z3099C0F7(workflowFilePath, value(matchValue), workflow.Identifier);
+  }
+  const publisher = LDOrganization.create("DataPLANT");
+  const creators = Option_fromSeq(ResizeArray_map(PersonConversion_composePerson_Z64D846DC, workflow.Contacts));
+  const dateCreated = utcNow();
+  if (creators != null) {
+    LDComputationalWorkflow.setCreators(workflowProtocol, value(creators));
+  }
+  LDComputationalWorkflow.setSdPublisher(workflowProtocol, publisher);
+  LDComputationalWorkflow.setDateCreatedAsDateTime(workflowProtocol, dateCreated);
+  if (workflow.Version != null) {
+    LDLabProtocol.setVersionAsString(workflowProtocol, value(workflow.Version));
+  }
+  if (workflow.URI != null) {
+    LDLabProtocol.setUrl(workflowProtocol, value(workflow.URI));
+  }
+  if (workflow.WorkflowType != null) {
+    const intendedUse = BaseTypes_composeDefinedTerm_ZDED3A0F(value(workflow.WorkflowType));
+    LDLabProtocol.setIntendedUseAsDefinedTerm(workflowProtocol, intendedUse);
+  }
+  const dataFiles = ResizeArray_choose((df) => LDPropertyValue.tryGetSubjectOf(df), defaultArg(map(DatamapConversion_composeFragmentDescriptors_Z892BFC3, workflow.Datamap), []));
+  if (workflow.Components.length > 0) {
+    const softwareTools = ResizeArray_map(WorkflowConversion_composeComputationalTool_Z685B8F25, workflow.Components);
+    LDLabProtocol.setComputationalTools(workflowProtocol, softwareTools);
+  }
+  const hasParts = dataFiles.length === 0 ? ResizeArray_singleton(workflowProtocol) : ResizeArray_appendSingleton(workflowProtocol, dataFiles);
+  const comments = Option_fromSeq(ResizeArray_map(BaseTypes_composeComment_Z13201A7E, workflow.Comments));
+  return LDDataset.createARCWorkflow(workflow.Identifier, ResizeArray_singleton(workflowProtocol), void 0, unwrap(workflow.Title), unwrap(workflow.Description), unwrap(creators), unwrap(hasParts), unwrap(comments));
+}
+function WorkflowConversion_decomposeWorkflow_Z6839B9E8(workflow, graph, context) {
+  const workflowProtocol = find((me) => LDComputationalWorkflow.validate(me, unwrap(context)), LDDataset.getMainEntities(workflow, unwrap(graph), unwrap(context)));
+  const cwlDescription = WorkflowConversion_decomposeWorkflowProtocolToProcessingUnit_ZB11202F(workflowProtocol, void 0, unwrap(context), unwrap(graph));
+  const version = LDLabProtocol.tryGetVersionAsString(workflowProtocol, unwrap(context));
+  const uri = LDLabProtocol.tryGetUrl(workflowProtocol, unwrap(context));
+  const workflowType = map((iu) => BaseTypes_decomposeDefinedTerm_Z2F770004(iu, unwrap(context)), LDLabProtocol.tryGetIntendedUseAsDefinedTerm(workflowProtocol, unwrap(graph), unwrap(context)));
+  const components = ResizeArray_map((ct) => WorkflowConversion_decomposeComputationalTool_Z6839B9E8(ct, unwrap(graph), unwrap(context)), LDLabProtocol.getComputationalTools(workflowProtocol, unwrap(graph), unwrap(context)));
+  const contacts = ResizeArray_map((c) => PersonConversion_decomposePerson_Z6839B9E8(c, unwrap(graph), unwrap(context)), LDDataset.getCreators(workflow, unwrap(graph), unwrap(context)));
+  const comments = ResizeArray_map((c_1) => BaseTypes_decomposeComment_Z2F770004(c_1, unwrap(context)), LDDataset.getComments(workflow, unwrap(graph), unwrap(context)));
+  let datamap;
+  const v = DatamapConversion_decomposeFragmentDescriptors_Z6E59645F(LDDataset.getVariableMeasuredAsFragmentDescriptors(workflow, unwrap(graph), unwrap(context)), unwrap(graph), unwrap(context));
+  datamap = Option_fromValueWithDefault(Datamap.init(), v);
+  return ArcWorkflow.create(LDDataset.getIdentifierAsString(workflow, unwrap(context)), unwrap(LDDataset.tryGetNameAsString(workflow, unwrap(context))), unwrap(LDDataset.tryGetDescriptionAsString(workflow, unwrap(context))), unwrap(workflowType), unwrap(uri), unwrap(version), void 0, void 0, components, unwrap(datamap), contacts, cwlDescription, comments);
+}
+
+export { WorkflowConversion, WorkflowConversion_$reflection, WorkflowConversion_composeAdditionalType_Z5C31A0F9, WorkflowConversion_composeComputationalTool_Z685B8F25, WorkflowConversion_composeFormalParamInputIdentifiers, WorkflowConversion_composeFormalParameterFromInput_Z7A02DED7, WorkflowConversion_composeFormalParameterFromOutput_Z25C7EC80, WorkflowConversion_composeFormalParameterOutputIdentifiers_6DFDD678, WorkflowConversion_composeWorkflowProtocolFromExpressionToolDescription_Z7BEB6658, WorkflowConversion_composeWorkflowProtocolFromOperationDescription_Z75DE0D49, WorkflowConversion_composeWorkflowProtocolFromProcessingUnit_Z3099C0F7, WorkflowConversion_composeWorkflowProtocolFromToolDescription_7B8357DA, WorkflowConversion_composeWorkflowProtocolFromWorkflow_Z6FBB852F, WorkflowConversion_composeWorkflowStep_Z35AB9E5D, WorkflowConversion_composeWorkflow_42450E6E, WorkflowConversion_decomposeAdditionalType_Z721C83C5, WorkflowConversion_decomposeComputationalTool_Z6839B9E8, WorkflowConversion_decomposeInputBindings_1AAAE9A5, WorkflowConversion_decomposeInputFromFormalParameter_2664C4B8, WorkflowConversion_decomposeOutputBindings_1AAAE9A5, WorkflowConversion_decomposeOutputFromFormalParameter_2664C4B8, WorkflowConversion_decomposeWorkflowProtocolToExpressionToolDescription_2664C4B8, WorkflowConversion_decomposeWorkflowProtocolToOperationDescription_2664C4B8, WorkflowConversion_decomposeWorkflowProtocolToProcessingUnit_ZB11202F, WorkflowConversion_decomposeWorkflowProtocolToToolDescription_2664C4B8, WorkflowConversion_decomposeWorkflowProtocolToWorkflow_ZB11202F, WorkflowConversion_decomposeWorkflowStep_77DD0449, WorkflowConversion_decomposeWorkflow_Z6839B9E8, WorkflowConversion_getInputParametersFromProcessingUnit_30922B92, WorkflowConversion_get_expressionToolDescriptionTypeName, WorkflowConversion_get_operationDescriptionTypeName, WorkflowConversion_get_toolDescriptionTypeName, WorkflowConversion_get_workflowDescriptionTypeName, WorkflowConversion_runToIdentifier_Z4EBA8CB1, WorkflowConversion_tryDecodeProcessingUnitFromGraph_Z5AC69418 };