@f1studio/form-spec 5.0.0-alpha.101

package/FormSpec.TS/PathwayExecutor.js

@@ -0,0 +1,1321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get ClinicalPlan () {
+        return ClinicalPlan;
+    },
+    get ClinicalPlan_$reflection () {
+        return ClinicalPlan_$reflection;
+    },
+    get ExecutionContext$1 () {
+        return ExecutionContext$1;
+    },
+    get ExecutionContext$1_$reflection () {
+        return ExecutionContext$1_$reflection;
+    },
+    get ExecutionLogEntry () {
+        return ExecutionLogEntry;
+    },
+    get ExecutionLogEntry_$reflection () {
+        return ExecutionLogEntry_$reflection;
+    },
+    get FieldResolver_createResolver () {
+        return FieldResolver_createResolver;
+    },
+    get FieldResolver_extractFieldValues () {
+        return FieldResolver_extractFieldValues;
+    },
+    get FieldResolver_generateFieldKey () {
+        return FieldResolver_generateFieldKey;
+    },
+    get IncrementalExecutionResult$1 () {
+        return IncrementalExecutionResult$1;
+    },
+    get IncrementalExecutionResult$1_$reflection () {
+        return IncrementalExecutionResult$1_$reflection;
+    },
+    get MatchedTransition () {
+        return MatchedTransition;
+    },
+    get MatchedTransition_$reflection () {
+        return MatchedTransition_$reflection;
+    },
+    get PathwayExecutionResult$1 () {
+        return PathwayExecutionResult$1;
+    },
+    get PathwayExecutionResult$1_$reflection () {
+        return PathwayExecutionResult$1_$reflection;
+    },
+    get PredictedPathway () {
+        return PredictedPathway;
+    },
+    get PredictedPathway_$reflection () {
+        return PredictedPathway_$reflection;
+    },
+    get TransitionStatus () {
+        return TransitionStatus;
+    },
+    get TransitionStatus_$reflection () {
+        return TransitionStatus_$reflection;
+    },
+    get TransitionStatus_Failed () {
+        return TransitionStatus_Failed;
+    },
+    get TransitionStatus_Pending () {
+        return TransitionStatus_Pending;
+    },
+    get TransitionStatus_Satisfied () {
+        return TransitionStatus_Satisfied;
+    },
+    get VisualizationState () {
+        return VisualizationState;
+    },
+    get VisualizationState_$reflection () {
+        return VisualizationState_$reflection;
+    },
+    get calculateCompletionPercentage () {
+        return calculateCompletionPercentage;
+    },
+    get calculateProbability () {
+        return calculateProbability;
+    },
+    get categorizeTransitions () {
+        return categorizeTransitions;
+    },
+    get evaluateAllTransitions () {
+        return evaluateAllTransitions;
+    },
+    get evaluateFieldCondition () {
+        return evaluateFieldCondition;
+    },
+    get evaluateFieldConditionWithConditionValue () {
+        return evaluateFieldConditionWithConditionValue;
+    },
+    get evaluateTransitionWithPartialData () {
+        return evaluateTransitionWithPartialData;
+    },
+    get executeAction () {
+        return executeAction;
+    },
+    get executeActions () {
+        return executeActions;
+    },
+    get executeIncremental () {
+        return executeIncremental;
+    },
+    get executeSetFieldValueAction () {
+        return executeSetFieldValueAction;
+    },
+    get executeStep () {
+        return executeStep;
+    },
+    get extractActionsFromState () {
+        return extractActionsFromState;
+    },
+    get extractClinicalPlans () {
+        return extractClinicalPlans;
+    },
+    get findState () {
+        return findState;
+    },
+    get getVisualizationState () {
+        return getVisualizationState;
+    },
+    get initializeExecution () {
+        return initializeExecution;
+    },
+    get isExecutionComplete () {
+        return isExecutionComplete;
+    },
+    get isTerminalState () {
+        return isTerminalState;
+    },
+    get predictOutcomes () {
+        return predictOutcomes;
+    },
+    get resolveFieldValueSource () {
+        return resolveFieldValueSource;
+    },
+    get selectTransitionsByMode () {
+        return selectTransitionsByMode;
+    }
+});
+const _Types = require("@fable-org/fable-library-js/Types.js");
+const _List = require("@fable-org/fable-library-js/List.js");
+const _Reflection = require("@fable-org/fable-library-js/Reflection.js");
+const _FormSpec = require("./FormSpec.js");
+const _Util = require("@fable-org/fable-library-js/Util.js");
+const _Set = require("@fable-org/fable-library-js/Set.js");
+const _Array = require("@fable-org/fable-library-js/Array.js");
+const _BitConverter = require("@fable-org/fable-library-js/BitConverter.js");
+const _Guid = require("@fable-org/fable-library-js/Guid.js");
+const _Map = require("@fable-org/fable-library-js/Map.js");
+const _Option = require("@fable-org/fable-library-js/Option.js");
+const _Seq = require("@fable-org/fable-library-js/Seq.js");
+const _String = require("@fable-org/fable-library-js/String.js");
+const _Encodefs = require("./fable_modules/Thoth.Json.10.4.1/Encode.fs.js");
+const _Double = require("@fable-org/fable-library-js/Double.js");
+const _RegExp = require("@fable-org/fable-library-js/RegExp.js");
+const _Date = require("@fable-org/fable-library-js/Date.js");
+function TransitionStatus_Satisfied() {
+    return new TransitionStatus(0, []);
+}
+function TransitionStatus_Failed() {
+    return new TransitionStatus(1, []);
+}
+function TransitionStatus_Pending(missingFields) {
+    return new TransitionStatus(2, [
+        missingFields
+    ]);
+}
+class TransitionStatus extends _Types.Union {
+    cases() {
+        return [
+            "Satisfied",
+            "Failed",
+            "Pending"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function TransitionStatus_$reflection() {
+    return (0, _Reflection.union_type)("F1.Studio.PathwayExecutor.TransitionStatus", [], TransitionStatus, ()=>[
+            [],
+            [],
+            [
+                [
+                    "missingFields",
+                    (0, _Reflection.list_type)(_Reflection.string_type)
+                ]
+            ]
+        ]);
+}
+class MatchedTransition extends _Types.Record {
+    constructor(Transition, Priority, Status){
+        super();
+        this.Transition = Transition;
+        this.Priority = Priority | 0;
+        this.Status = Status;
+    }
+}
+function MatchedTransition_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.PathwayExecutor.MatchedTransition", [], MatchedTransition, ()=>[
+            [
+                "Transition",
+                (0, _FormSpec.ClinicalPathway_TransitionDefinition_$reflection)()
+            ],
+            [
+                "Priority",
+                _Reflection.int32_type
+            ],
+            [
+                "Status",
+                TransitionStatus_$reflection()
+            ]
+        ]);
+}
+class ExecutionLogEntry extends _Types.Record {
+    constructor(Timestamp, StateKey, Action, Details){
+        super();
+        this.Timestamp = Timestamp;
+        this.StateKey = StateKey;
+        this.Action = Action;
+        this.Details = Details;
+    }
+}
+function ExecutionLogEntry_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.PathwayExecutor.ExecutionLogEntry", [], ExecutionLogEntry, ()=>[
+            [
+                "Timestamp",
+                (0, _Reflection.class_type)("System.DateTime")
+            ],
+            [
+                "StateKey",
+                (0, _FormSpec.Shared_StateKey_$reflection)()
+            ],
+            [
+                "Action",
+                _Reflection.string_type
+            ],
+            [
+                "Details",
+                _Reflection.string_type
+            ]
+        ]);
+}
+class ExecutionContext$1 extends _Types.Record {
+    constructor(PathwaySpec, FormSpec, CurrentStates, VisitedStates, CompletedStates, ActiveTransitions, PendingTransitions, ExecutedActions, FormData, FieldResolver, ExecutionLog){
+        super();
+        this.PathwaySpec = PathwaySpec;
+        this.FormSpec = FormSpec;
+        this.CurrentStates = CurrentStates;
+        this.VisitedStates = VisitedStates;
+        this.CompletedStates = CompletedStates;
+        this.ActiveTransitions = ActiveTransitions;
+        this.PendingTransitions = PendingTransitions;
+        this.ExecutedActions = ExecutedActions;
+        this.FormData = FormData;
+        this.FieldResolver = FieldResolver;
+        this.ExecutionLog = ExecutionLog;
+    }
+}
+function ExecutionContext$1_$reflection(gen0) {
+    return (0, _Reflection.record_type)("F1.Studio.PathwayExecutor.ExecutionContext`1", [
+        gen0
+    ], ExecutionContext$1, ()=>[
+            [
+                "PathwaySpec",
+                (0, _FormSpec.ClinicalPathway_ClinicalPathwaySpec_$reflection)()
+            ],
+            [
+                "FormSpec",
+                (0, _FormSpec.Spec_FormSpec$1_$reflection)(gen0)
+            ],
+            [
+                "CurrentStates",
+                (0, _Reflection.class_type)("Microsoft.FSharp.Collections.FSharpSet`1", [
+                    (0, _FormSpec.Shared_StateKey_$reflection)()
+                ])
+            ],
+            [
+                "VisitedStates",
+                (0, _Reflection.class_type)("Microsoft.FSharp.Collections.FSharpSet`1", [
+                    (0, _FormSpec.Shared_StateKey_$reflection)()
+                ])
+            ],
+            [
+                "CompletedStates",
+                (0, _Reflection.class_type)("Microsoft.FSharp.Collections.FSharpSet`1", [
+                    (0, _FormSpec.Shared_StateKey_$reflection)()
+                ])
+            ],
+            [
+                "ActiveTransitions",
+                (0, _Reflection.list_type)(MatchedTransition_$reflection())
+            ],
+            [
+                "PendingTransitions",
+                (0, _Reflection.list_type)(MatchedTransition_$reflection())
+            ],
+            [
+                "ExecutedActions",
+                (0, _Reflection.list_type)((0, _FormSpec.ClinicalPathway_ActionInfo_$reflection)())
+            ],
+            [
+                "FormData",
+                (0, _FormSpec.Values_DynamicFormResultData$1_$reflection)(gen0)
+            ],
+            [
+                "FieldResolver",
+                (0, _Reflection.lambda_type)(_Reflection.string_type, (0, _FormSpec.Shared_FieldKey_$reflection)())
+            ],
+            [
+                "ExecutionLog",
+                (0, _Reflection.list_type)(ExecutionLogEntry_$reflection())
+            ]
+        ]);
+}
+class PredictedPathway extends _Types.Record {
+    constructor(PathwayId, Probability, RequiredFields, ExpectedActions, TargetState){
+        super();
+        this.PathwayId = PathwayId;
+        this.Probability = Probability;
+        this.RequiredFields = RequiredFields;
+        this.ExpectedActions = ExpectedActions;
+        this.TargetState = TargetState;
+    }
+}
+function PredictedPathway_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.PathwayExecutor.PredictedPathway", [], PredictedPathway, ()=>[
+            [
+                "PathwayId",
+                _Reflection.string_type
+            ],
+            [
+                "Probability",
+                _Reflection.float64_type
+            ],
+            [
+                "RequiredFields",
+                (0, _Reflection.list_type)(_Reflection.string_type)
+            ],
+            [
+                "ExpectedActions",
+                (0, _Reflection.list_type)((0, _FormSpec.ClinicalPathway_ActionInfo_$reflection)())
+            ],
+            [
+                "TargetState",
+                _Reflection.string_type
+            ]
+        ]);
+}
+class IncrementalExecutionResult$1 extends _Types.Record {
+    constructor(Context, NewlyActivatedStates, NewlyActiveTransitions, PredictedOutcomes, CompletionPercentage, IsComplete){
+        super();
+        this.Context = Context;
+        this.NewlyActivatedStates = NewlyActivatedStates;
+        this.NewlyActiveTransitions = NewlyActiveTransitions;
+        this.PredictedOutcomes = PredictedOutcomes;
+        this.CompletionPercentage = CompletionPercentage;
+        this.IsComplete = IsComplete;
+    }
+}
+function IncrementalExecutionResult$1_$reflection(gen0) {
+    return (0, _Reflection.record_type)("F1.Studio.PathwayExecutor.IncrementalExecutionResult`1", [
+        gen0
+    ], IncrementalExecutionResult$1, ()=>[
+            [
+                "Context",
+                ExecutionContext$1_$reflection(gen0)
+            ],
+            [
+                "NewlyActivatedStates",
+                (0, _Reflection.list_type)(_Reflection.string_type)
+            ],
+            [
+                "NewlyActiveTransitions",
+                (0, _Reflection.list_type)((0, _FormSpec.ClinicalPathway_TransitionDefinition_$reflection)())
+            ],
+            [
+                "PredictedOutcomes",
+                (0, _Reflection.list_type)(PredictedPathway_$reflection())
+            ],
+            [
+                "CompletionPercentage",
+                _Reflection.float64_type
+            ],
+            [
+                "IsComplete",
+                _Reflection.bool_type
+            ]
+        ]);
+}
+class ClinicalPlan extends _Types.Record {
+    constructor(PlanId, Actions, TargetState, Priority){
+        super();
+        this.PlanId = PlanId;
+        this.Actions = Actions;
+        this.TargetState = TargetState;
+        this.Priority = Priority | 0;
+    }
+}
+function ClinicalPlan_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.PathwayExecutor.ClinicalPlan", [], ClinicalPlan, ()=>[
+            [
+                "PlanId",
+                _Reflection.string_type
+            ],
+            [
+                "Actions",
+                (0, _Reflection.list_type)((0, _FormSpec.ClinicalPathway_ActionInfo_$reflection)())
+            ],
+            [
+                "TargetState",
+                _Reflection.string_type
+            ],
+            [
+                "Priority",
+                _Reflection.int32_type
+            ]
+        ]);
+}
+class VisualizationState extends _Types.Record {
+    constructor(CurrentStates, VisitedStates, ActiveTransitions, PendingTransitions, CompletedTransitions, PredictedOutcomes){
+        super();
+        this.CurrentStates = CurrentStates;
+        this.VisitedStates = VisitedStates;
+        this.ActiveTransitions = ActiveTransitions;
+        this.PendingTransitions = PendingTransitions;
+        this.CompletedTransitions = CompletedTransitions;
+        this.PredictedOutcomes = PredictedOutcomes;
+    }
+}
+function VisualizationState_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.PathwayExecutor.VisualizationState", [], VisualizationState, ()=>[
+            [
+                "CurrentStates",
+                (0, _Reflection.class_type)("Microsoft.FSharp.Collections.FSharpSet`1", [
+                    (0, _FormSpec.Shared_StateKey_$reflection)()
+                ])
+            ],
+            [
+                "VisitedStates",
+                (0, _Reflection.class_type)("Microsoft.FSharp.Collections.FSharpSet`1", [
+                    (0, _FormSpec.Shared_StateKey_$reflection)()
+                ])
+            ],
+            [
+                "ActiveTransitions",
+                (0, _Reflection.list_type)((0, _FormSpec.Shared_TransitionKey_$reflection)())
+            ],
+            [
+                "PendingTransitions",
+                (0, _Reflection.list_type)((0, _FormSpec.Shared_TransitionKey_$reflection)())
+            ],
+            [
+                "CompletedTransitions",
+                (0, _Reflection.list_type)(_Reflection.string_type)
+            ],
+            [
+                "PredictedOutcomes",
+                (0, _Reflection.list_type)(PredictedPathway_$reflection())
+            ]
+        ]);
+}
+function FieldResolver_generateFieldKey(fieldName) {
+    const hash = (0, _Util.stringHash)(fieldName) | 0;
+    const bytes = (0, _Array.fill)(new Array(16), 0, 16, 0);
+    (0, _Array.iterateIndexed)((i, b)=>{
+        if (i < 4) {
+            (0, _Array.setItem)(bytes, i, b);
+        }
+    }, Array.from((0, _BitConverter.getBytesInt32)(hash)));
+    (0, _Array.iterateIndexed)((i_1, b_1)=>{
+        if (i_1 < 4) {
+            (0, _Array.setItem)(bytes, i_1 + 4, b_1);
+        }
+    }, Array.from((0, _BitConverter.getBytesInt32)(hash >> 1)));
+    (0, _Array.iterateIndexed)((i_2, b_2)=>{
+        if (i_2 < 4) {
+            (0, _Array.setItem)(bytes, i_2 + 8, b_2);
+        }
+    }, Array.from((0, _BitConverter.getBytesInt32)(hash >> 2)));
+    (0, _Array.iterateIndexed)((i_3, b_3)=>{
+        if (i_3 < 4) {
+            (0, _Array.setItem)(bytes, i_3 + 12, b_3);
+        }
+    }, Array.from((0, _BitConverter.getBytesInt32)(hash >> 3)));
+    return new _FormSpec.Shared_FieldKey((0, _Guid.arrayToGuid)(bytes));
+}
+function FieldResolver_createResolver(formSpec) {
+    const labelToFieldKey = (0, _Map.ofList)((0, _List.map)((field)=>[
+            field.Label.toLocaleLowerCase().trim(),
+            field.FieldKey
+        ], (0, _List.collect)((step)=>step.Fields, formSpec.Steps)), {
+        Compare: _Util.comparePrimitives
+    });
+    return (fieldReference)=>{
+        const matchValue = (0, _Map.tryFind)(fieldReference.toLocaleLowerCase().trim(), labelToFieldKey);
+        return matchValue == null ? FieldResolver_generateFieldKey(fieldReference) : (0, _Option.value)(matchValue);
+    };
+}
+function FieldResolver_extractFieldValues(resolver, formData) {
+    return (0, _Map.ofSeq)((0, _Seq.collect)((tupledArg)=>(0, _Seq.map)((tupledArg_1)=>{
+            let matchValue, pluginData;
+            return [
+                tupledArg_1[0],
+                (matchValue = tupledArg_1[1].FieldValue, matchValue.tag === /* Multiple */ 1 ? (0, _String.join)(",", (0, _Set.toList)((0, _Set.map)((a)=>a.Value, matchValue.fields[0], {
+                    Compare: _Util.comparePrimitives
+                }))) : matchValue.tag === /* Matrix */ 2 ? (0, _String.join)(",", (0, _List.map)((tupledArg_2)=>tupledArg_2[1], (0, _Map.toList)(matchValue.fields[0].Values))) : matchValue.tag === /* PluginData */ 3 ? (pluginData = matchValue.fields[0], (0, _Encodefs.toString)(0, (0, _Encodefs.Auto_generateBoxedEncoder_437914C6)((0, _Reflection.list_type)((0, _FormSpec.Shared_PluginDataProperty_$reflection)()), undefined, undefined, undefined)(pluginData))) : matchValue.fields[0].Value)
+            ];
+        }, (0, _Map.toSeq)(tupledArg[1])), (0, _Map.toSeq)(formData.ResultSteps)), {
+        Compare: _Util.compare
+    });
+}
+function evaluateFieldCondition(actualValue, evaluator, expectedValue) {
+    switch(evaluator.tag){
+        case /* NotEquals */ 1:
+            return actualValue.trim().toLocaleLowerCase() !== expectedValue.trim().toLocaleLowerCase();
+        case /* GreaterThan */ 5:
+            {
+                let matchValue;
+                let outArg = 0;
+                matchValue = [
+                    (0, _Double.tryParse)(actualValue, new _Types.FSharpRef(()=>outArg, (v)=>{
+                        outArg = v;
+                    })),
+                    outArg
+                ];
+                let matchValue_1;
+                let outArg_1 = 0;
+                matchValue_1 = [
+                    (0, _Double.tryParse)(expectedValue, new _Types.FSharpRef(()=>outArg_1, (v_1)=>{
+                        outArg_1 = v_1;
+                    })),
+                    outArg_1
+                ];
+                let matchResult;
+                if (matchValue[0]) {
+                    if (matchValue_1[0]) {
+                        matchResult = 0;
+                    } else {
+                        matchResult = 1;
+                    }
+                } else {
+                    matchResult = 1;
+                }
+                switch(matchResult){
+                    case 0:
+                        return matchValue[1] > matchValue_1[1];
+                    default:
+                        return false;
+                }
+            }
+        case /* GreaterOrEqual */ 6:
+            {
+                let matchValue_3;
+                let outArg_2 = 0;
+                matchValue_3 = [
+                    (0, _Double.tryParse)(actualValue, new _Types.FSharpRef(()=>outArg_2, (v_2)=>{
+                        outArg_2 = v_2;
+                    })),
+                    outArg_2
+                ];
+                let matchValue_4;
+                let outArg_3 = 0;
+                matchValue_4 = [
+                    (0, _Double.tryParse)(expectedValue, new _Types.FSharpRef(()=>outArg_3, (v_3)=>{
+                        outArg_3 = v_3;
+                    })),
+                    outArg_3
+                ];
+                let matchResult_1;
+                if (matchValue_3[0]) {
+                    if (matchValue_4[0]) {
+                        matchResult_1 = 0;
+                    } else {
+                        matchResult_1 = 1;
+                    }
+                } else {
+                    matchResult_1 = 1;
+                }
+                switch(matchResult_1){
+                    case 0:
+                        return matchValue_3[1] >= matchValue_4[1];
+                    default:
+                        return false;
+                }
+            }
+        case /* LessThan */ 7:
+            {
+                let matchValue_6;
+                let outArg_4 = 0;
+                matchValue_6 = [
+                    (0, _Double.tryParse)(actualValue, new _Types.FSharpRef(()=>outArg_4, (v_4)=>{
+                        outArg_4 = v_4;
+                    })),
+                    outArg_4
+                ];
+                let matchValue_7;
+                let outArg_5 = 0;
+                matchValue_7 = [
+                    (0, _Double.tryParse)(expectedValue, new _Types.FSharpRef(()=>outArg_5, (v_5)=>{
+                        outArg_5 = v_5;
+                    })),
+                    outArg_5
+                ];
+                let matchResult_2;
+                if (matchValue_6[0]) {
+                    if (matchValue_7[0]) {
+                        matchResult_2 = 0;
+                    } else {
+                        matchResult_2 = 1;
+                    }
+                } else {
+                    matchResult_2 = 1;
+                }
+                switch(matchResult_2){
+                    case 0:
+                        return matchValue_6[1] < matchValue_7[1];
+                    default:
+                        return false;
+                }
+            }
+        case /* LessOrEqual */ 8:
+            {
+                let matchValue_9;
+                let outArg_6 = 0;
+                matchValue_9 = [
+                    (0, _Double.tryParse)(actualValue, new _Types.FSharpRef(()=>outArg_6, (v_6)=>{
+                        outArg_6 = v_6;
+                    })),
+                    outArg_6
+                ];
+                let matchValue_10;
+                let outArg_7 = 0;
+                matchValue_10 = [
+                    (0, _Double.tryParse)(expectedValue, new _Types.FSharpRef(()=>outArg_7, (v_7)=>{
+                        outArg_7 = v_7;
+                    })),
+                    outArg_7
+                ];
+                let matchResult_3;
+                if (matchValue_9[0]) {
+                    if (matchValue_10[0]) {
+                        matchResult_3 = 0;
+                    } else {
+                        matchResult_3 = 1;
+                    }
+                } else {
+                    matchResult_3 = 1;
+                }
+                switch(matchResult_3){
+                    case 0:
+                        return matchValue_9[1] <= matchValue_10[1];
+                    default:
+                        return false;
+                }
+            }
+        case /* Contains */ 9:
+            return actualValue.toLocaleLowerCase().indexOf(expectedValue.toLocaleLowerCase()) >= 0;
+        case /* IsPresent */ 10:
+            if (!(0, _String.isNullOrWhiteSpace)(actualValue) && actualValue.toLocaleLowerCase() !== "false") {
+                return actualValue.toLocaleLowerCase() !== "no";
+            } else {
+                return false;
+            }
+        case /* IsAbsent */ 11:
+            if ((0, _String.isNullOrWhiteSpace)(actualValue) ? true : actualValue.toLocaleLowerCase() === "false") {
+                return true;
+            } else {
+                return actualValue.toLocaleLowerCase() === "no";
+            }
+        case /* MatchesPattern */ 12:
+            return (0, _RegExp.isMatch)((0, _RegExp.create)(evaluator.fields[0]), actualValue);
+        case /* InRange */ 13:
+            {
+                const minVal = evaluator.fields[0] | 0;
+                const maxVal = evaluator.fields[1] | 0;
+                let matchValue_12;
+                let outArg_8 = 0;
+                matchValue_12 = [
+                    (0, _Double.tryParse)(actualValue, new _Types.FSharpRef(()=>outArg_8, (v_8)=>{
+                        outArg_8 = v_8;
+                    })),
+                    outArg_8
+                ];
+                if (matchValue_12[0]) {
+                    const actual_4 = matchValue_12[1];
+                    if (actual_4 >= minVal) {
+                        return actual_4 <= maxVal;
+                    } else {
+                        return false;
+                    }
+                } else {
+                    return false;
+                }
+            }
+        case /* InSet */ 2:
+            return (0, _List.exists)((v_9)=>v_9.trim().toLocaleLowerCase() === actualValue.trim().toLocaleLowerCase(), evaluator.fields[0]);
+        case /* NotInSet */ 3:
+            return !(0, _List.exists)((v_10)=>v_10.trim().toLocaleLowerCase() === actualValue.trim().toLocaleLowerCase(), evaluator.fields[0]);
+        case /* ContainsAll */ 4:
+            {
+                const values_2 = evaluator.fields[0];
+                const actualParts = (0, _Set.ofArray)((0, _Array.map)((s)=>s.trim().toLocaleLowerCase(), actualValue.split(",")), {
+                    Compare: _Util.comparePrimitives
+                });
+                return (0, _Set.isSubset)((0, _Set.ofList)((0, _List.map)((s_1)=>s_1.trim().toLocaleLowerCase(), values_2), {
+                    Compare: _Util.comparePrimitives
+                }), actualParts);
+            }
+        default:
+            return actualValue.trim().toLocaleLowerCase() === expectedValue.trim().toLocaleLowerCase();
+    }
+}
+function evaluateFieldConditionWithConditionValue(actualFieldValue, evaluator, expectedConditionValue) {
+    let pluginData, pluginData_1;
+    return evaluateFieldCondition(actualFieldValue.tag === /* Multiple */ 1 ? (0, _String.join)(",", (0, _Set.toList)((0, _Set.map)((a)=>a.Value, actualFieldValue.fields[0], {
+        Compare: _Util.comparePrimitives
+    }))) : actualFieldValue.tag === /* Matrix */ 2 ? (0, _String.join)(",", (0, _List.map)((tupledArg)=>tupledArg[1], (0, _Map.toList)(actualFieldValue.fields[0].Values))) : actualFieldValue.tag === /* PluginData */ 3 ? (pluginData = actualFieldValue.fields[0], (0, _Encodefs.toString)(0, (0, _Encodefs.Auto_generateBoxedEncoder_437914C6)((0, _Reflection.list_type)((0, _FormSpec.Shared_PluginDataProperty_$reflection)()), undefined, undefined, undefined)(pluginData))) : actualFieldValue.fields[0].Value, evaluator, expectedConditionValue.tag === /* Multiple */ 1 ? (0, _String.join)(",", (0, _Set.toList)(expectedConditionValue.fields[0])) : expectedConditionValue.tag === /* Matrix */ 2 ? (0, _String.join)(",", (0, _List.map)((tupledArg_1)=>tupledArg_1[1], (0, _Map.toList)(expectedConditionValue.fields[0]))) : expectedConditionValue.tag === /* PluginData */ 3 ? (pluginData_1 = expectedConditionValue.fields[0], (0, _Encodefs.toString)(0, (0, _Encodefs.Auto_generateBoxedEncoder_437914C6)((0, _FormSpec.Shared_PluginDataProperty_$reflection)(), undefined, undefined, undefined)(pluginData_1))) : expectedConditionValue.fields[0]);
+}
+function evaluateTransitionWithPartialData(resolver, formSpec, fieldValues, visitedStates, condition) {
+    let pluginData, pluginData_1;
+    switch(condition.tag){
+        case /* FieldCondition */ 0:
+            {
+                const fieldKey = condition.fields[0];
+                const evaluator = condition.fields[1];
+                const conditionValue = condition.fields[2];
+                const matchValue = (0, _Map.tryFind)(fieldKey, fieldValues);
+                if (matchValue == null) {
+                    return TransitionStatus_Pending((0, _List.singleton)(fieldKey.fields[0]));
+                } else if (evaluateFieldConditionWithConditionValue((0, _FormSpec.Shared_FieldValue_Single)(new _FormSpec.Shared_FieldAnswer(fieldKey, "", (0, _Option.value)(matchValue))), evaluator, conditionValue)) {
+                    return TransitionStatus_Satisfied();
+                } else {
+                    return TransitionStatus_Failed();
+                }
+            }
+        case /* StateCondition */ 3:
+            {
+                const evaluator_1 = condition.fields[1];
+                const stateVisited = (0, _Set.contains)(condition.fields[0], visitedStates);
+                switch(evaluator_1.tag){
+                    case /* HasValue */ 1:
+                        if (stateVisited) {
+                            return TransitionStatus_Satisfied();
+                        } else {
+                            return TransitionStatus_Failed();
+                        }
+                    case /* HasError */ 2:
+                        return TransitionStatus_Failed();
+                    case /* WasSkipped */ 3:
+                        if (!stateVisited) {
+                            return TransitionStatus_Satisfied();
+                        } else {
+                            return TransitionStatus_Failed();
+                        }
+                    default:
+                        if (stateVisited) {
+                            return TransitionStatus_Satisfied();
+                        } else {
+                            return TransitionStatus_Failed();
+                        }
+                }
+            }
+        case /* CompositeCondition */ 4:
+            {
+                const logicalOp = condition.fields[0];
+                const conditions = condition.fields[1];
+                switch(logicalOp.tag){
+                    case /* Or */ 1:
+                        {
+                            const results_1 = (0, _List.map)((condition_2)=>evaluateTransitionWithPartialData(resolver, formSpec, fieldValues, visitedStates, condition_2), conditions);
+                            if ((0, _List.exists)((r_3)=>(0, _Util.equals)(r_3, TransitionStatus_Satisfied()), results_1)) {
+                                return TransitionStatus_Satisfied();
+                            } else if ((0, _List.forAll)((r_4)=>(0, _Util.equals)(r_4, TransitionStatus_Failed()), results_1)) {
+                                return TransitionStatus_Failed();
+                            } else {
+                                return TransitionStatus_Pending((0, _List.concat)((0, _List.choose)((r_5)=>{
+                                    if (r_5.tag === /* Pending */ 2) {
+                                        return r_5.fields[0];
+                                    } else {
+                                        return undefined;
+                                    }
+                                }, results_1)));
+                            }
+                        }
+                    case /* Not */ 2:
+                        {
+                            let matchResult, cond;
+                            if (!(0, _List.isEmpty)(conditions)) {
+                                if ((0, _List.isEmpty)((0, _List.tail)(conditions))) {
+                                    matchResult = 0;
+                                    cond = (0, _List.head)(conditions);
+                                } else {
+                                    matchResult = 1;
+                                }
+                            } else {
+                                matchResult = 1;
+                            }
+                            switch(matchResult){
+                                case 0:
+                                    {
+                                        const matchValue_1 = evaluateTransitionWithPartialData(resolver, formSpec, fieldValues, visitedStates, cond);
+                                        switch(matchValue_1.tag){
+                                            case /* Failed */ 1:
+                                                return TransitionStatus_Satisfied();
+                                            case /* Pending */ 2:
+                                                return TransitionStatus_Pending(matchValue_1.fields[0]);
+                                            default:
+                                                return TransitionStatus_Failed();
+                                        }
+                                    }
+                                default:
+                                    return TransitionStatus_Failed();
+                            }
+                        }
+                    default:
+                        {
+                            const results = (0, _List.map)((condition_1)=>evaluateTransitionWithPartialData(resolver, formSpec, fieldValues, visitedStates, condition_1), conditions);
+                            if ((0, _List.exists)((r)=>(0, _Util.equals)(r, TransitionStatus_Failed()), results)) {
+                                return TransitionStatus_Failed();
+                            } else if ((0, _List.forAll)((r_1)=>(0, _Util.equals)(r_1, TransitionStatus_Satisfied()), results)) {
+                                return TransitionStatus_Satisfied();
+                            } else {
+                                return TransitionStatus_Pending((0, _List.concat)((0, _List.choose)((r_2)=>{
+                                    if (r_2.tag === /* Pending */ 2) {
+                                        return r_2.fields[0];
+                                    } else {
+                                        return undefined;
+                                    }
+                                }, results)));
+                            }
+                        }
+                }
+            }
+        case /* TestResultCondition */ 5:
+            {
+                const result = condition.fields[1];
+                return TransitionStatus_Pending((0, _List.singleton)(condition.fields[0]));
+            }
+        case /* FieldOptionCondition */ 1:
+            {
+                const optionKey = condition.fields[2];
+                const matrixItemKey = condition.fields[1];
+                const fieldKey_1 = condition.fields[0];
+                const evaluator_2 = condition.fields[3];
+                const conditionValue_1 = condition.fields[4];
+                const optionValueOpt = formSpec == null ? undefined : (0, _Option.bind)((field_1)=>{
+                    const fieldType = field_1.FieldType;
+                    return (0, _Option.map)((opt_1)=>opt_1.Value, (0, _List.tryFind)((opt)=>(0, _Util.equals)(opt.OptionKey, optionKey), fieldType.tag === /* SingleChoice */ 13 ? fieldType.fields[0].Options : fieldType.tag === /* Radio */ 12 ? fieldType.fields[0].Options : fieldType.tag === /* Dropdown */ 14 ? fieldType.fields[0].Options : fieldType.tag === /* MultiChoice */ 15 ? fieldType.fields[0].Options : fieldType.tag === /* CheckboxList */ 16 ? fieldType.fields[0].Options : (0, _List.empty)()));
+                }, (0, _List.tryFind)((field)=>(0, _Util.equals)(field.FieldKey, fieldKey_1), (0, _List.collect)((step)=>step.Fields, (0, _Option.value)(formSpec).Steps)));
+                const matchValue_2 = (0, _Map.tryFind)(fieldKey_1, fieldValues);
+                if (optionValueOpt == null) {
+                    const guid_1 = optionKey.fields[0];
+                    console.error((0, _Option.some)("[evaluateTransition] FieldOptionCondition: Could not find option in formSpec for optionKey:"), guid_1);
+                    return TransitionStatus_Failed();
+                } else if (matchValue_2 == null) {
+                    return TransitionStatus_Pending((0, _List.singleton)(fieldKey_1.fields[0]));
+                } else {
+                    const actualValueStr_1 = (0, _Option.value)(matchValue_2);
+                    const optionValue = (0, _Option.value)(optionValueOpt);
+                    const actualValues = (0, _Set.ofArray)((0, _Array.map)((s)=>s.trim().toLocaleLowerCase(), actualValueStr_1.split(",")), {
+                        Compare: _Util.comparePrimitives
+                    });
+                    const containsOption = (0, _Set.contains)(optionValue.trim().toLocaleLowerCase(), actualValues);
+                    switch(evaluator_2.tag){
+                        case /* Equals */ 0:
+                            if (containsOption) {
+                                return TransitionStatus_Satisfied();
+                            } else {
+                                return TransitionStatus_Failed();
+                            }
+                        case /* NotEquals */ 1:
+                            if (!containsOption) {
+                                return TransitionStatus_Satisfied();
+                            } else {
+                                return TransitionStatus_Failed();
+                            }
+                        case /* IsPresent */ 10:
+                            if (containsOption) {
+                                return TransitionStatus_Satisfied();
+                            } else {
+                                return TransitionStatus_Failed();
+                            }
+                        case /* IsAbsent */ 11:
+                            if (!containsOption) {
+                                return TransitionStatus_Satisfied();
+                            } else {
+                                return TransitionStatus_Failed();
+                            }
+                        default:
+                            if (evaluateFieldCondition(actualValueStr_1, evaluator_2, conditionValue_1.tag === /* Multiple */ 1 ? (0, _String.join)(",", (0, _Set.toList)(conditionValue_1.fields[0])) : conditionValue_1.tag === /* Matrix */ 2 ? (0, _String.join)(",", (0, _List.map)((tupledArg)=>tupledArg[1], (0, _Map.toList)(conditionValue_1.fields[0]))) : conditionValue_1.tag === /* PluginData */ 3 ? (pluginData = conditionValue_1.fields[0], (0, _Encodefs.toString)(0, (0, _Encodefs.Auto_generateBoxedEncoder_437914C6)((0, _FormSpec.Shared_PluginDataProperty_$reflection)(), undefined, undefined, undefined)(pluginData))) : conditionValue_1.fields[0])) {
+                                return TransitionStatus_Satisfied();
+                            } else {
+                                return TransitionStatus_Failed();
+                            }
+                    }
+                }
+            }
+        case /* PluginPropertyCondition */ 2:
+            {
+                const propertyKey = condition.fields[1];
+                const fieldKey_2 = condition.fields[0];
+                const evaluator_3 = condition.fields[2];
+                const conditionValue_2 = condition.fields[3];
+                const matchValue_4 = (0, _Map.tryFind)(fieldKey_2, fieldValues);
+                if (matchValue_4 == null) {
+                    return TransitionStatus_Pending((0, _List.singleton)(fieldKey_2.fields[0]));
+                } else {
+                    const actualValueStr_2 = (0, _Option.value)(matchValue_4);
+                    try {
+                        const actualFieldValue_1 = (0, _FormSpec.Shared_FieldValue_Single)(new _FormSpec.Shared_FieldAnswer(fieldKey_2, "", actualValueStr_2));
+                        return evaluateFieldCondition(actualValueStr_2, evaluator_3, conditionValue_2.tag === /* Multiple */ 1 ? (0, _String.join)(",", (0, _Set.toList)(conditionValue_2.fields[0])) : conditionValue_2.tag === /* Matrix */ 2 ? (0, _String.join)(",", (0, _List.map)((tupledArg_1)=>tupledArg_1[1], (0, _Map.toList)(conditionValue_2.fields[0]))) : conditionValue_2.tag === /* PluginData */ 3 ? (pluginData_1 = conditionValue_2.fields[0], (0, _Encodefs.toString)(0, (0, _Encodefs.Auto_generateBoxedEncoder_437914C6)((0, _FormSpec.Shared_PluginDataProperty_$reflection)(), undefined, undefined, undefined)(pluginData_1))) : conditionValue_2.fields[0]) ? TransitionStatus_Satisfied() : TransitionStatus_Failed();
+                    } catch (ex) {
+                        return TransitionStatus_Failed();
+                    }
+                }
+            }
+        default:
+            return TransitionStatus_Satisfied();
+    }
+}
+function findState(stateKey, states) {
+    return (0, _List.tryFind)((s)=>(0, _Util.equals)(s.StateKey, stateKey), states);
+}
+function extractActionsFromState(state) {
+    const matchValue = state.StateType;
+    switch(matchValue.tag){
+        case /* Action */ 2:
+            return (0, _List.singleton)(matchValue.fields[0]);
+        case /* CompoundAction */ 3:
+            return matchValue.fields[0];
+        case /* ConditionalAction */ 4:
+            {
+                const condition = matchValue.fields[0];
+                return (0, _List.append)((0, _List.singleton)(matchValue.fields[1]), (0, _List.ofArray)((0, _Option.toArray)(matchValue.fields[2])));
+            }
+        default:
+            return (0, _List.empty)();
+    }
+}
+function isTerminalState(state) {
+    if (state.StateType.tag === /* Terminal */ 5) {
+        return true;
+    } else {
+        return false;
+    }
+}
+function evaluateAllTransitions(context) {
+    const fieldValues = FieldResolver_extractFieldValues(context.FieldResolver, context.FormData);
+    console.log((0, _Option.some)("[evaluateAllTransitions] Extracted field values:"), fieldValues);
+    console.log((0, _Option.some)("[evaluateAllTransitions] Current states in context:"), context.CurrentStates);
+    console.log((0, _Option.some)("[evaluateAllTransitions] All transitions in pathway:"), context.PathwaySpec.Transitions);
+    const transitionsFromCurrentStates = (0, _List.filter)((t)=>{
+        const isFromCurrentState = (0, _Set.contains)(t.FromState, context.CurrentStates);
+        console.log((0, _Option.some)("[evaluateAllTransitions] Transition from"), t.FromState, "to", t.ToState, "FromCurrentState=", isFromCurrentState);
+        return isFromCurrentState;
+    }, context.PathwaySpec.Transitions);
+    console.log((0, _Option.some)("[evaluateAllTransitions] Transitions from current states:"), transitionsFromCurrentStates);
+    return (0, _List.map)((transition)=>{
+        console.log((0, _Option.some)("[evaluateAllTransitions] Evaluating transition:"), transition.TransitionKey);
+        console.log((0, _Option.some)("[evaluateAllTransitions] Transition condition:"), transition.Condition);
+        const status = evaluateTransitionWithPartialData(context.FieldResolver, context.FormSpec, fieldValues, context.VisitedStates, transition.Condition);
+        console.log((0, _Option.some)("[evaluateAllTransitions] Transition status:"), status);
+        return new MatchedTransition(transition, (0, _Option.defaultArg)(transition.Priority, 999), status);
+    }, transitionsFromCurrentStates);
+}
+function categorizeTransitions(transitions) {
+    return [
+        (0, _List.filter)((t)=>(0, _Util.equals)(t.Status, TransitionStatus_Satisfied()), transitions),
+        (0, _List.filter)((t_1)=>{
+            if (t_1.Status.tag === /* Pending */ 2) {
+                return true;
+            } else {
+                return false;
+            }
+        }, transitions),
+        (0, _List.filter)((t_2)=>(0, _Util.equals)(t_2.Status, TransitionStatus_Failed()), transitions)
+    ];
+}
+function selectTransitionsByMode(mode, activeTransitions) {
+    switch(mode.tag){
+        case /* MultiPathway */ 1:
+            {
+                const matchValue_1 = mode.fields[0].CombinationStrategy;
+                switch(matchValue_1.tag){
+                    case /* NonConflicting */ 1:
+                        return activeTransitions;
+                    case /* Complementary */ 2:
+                        return activeTransitions;
+                    default:
+                        return activeTransitions;
+                }
+            }
+        case /* TriggerBased */ 2:
+            return activeTransitions;
+        default:
+            {
+                const matchValue = mode.fields[0].SelectionStrategy;
+                switch(matchValue.tag){
+                    case /* MostSpecific */ 1:
+                        return (0, _List.ofArray)((0, _Option.toArray)((0, _List.tryHead)((0, _List.sortBy)((m_1)=>m_1.Priority, activeTransitions, {
+                            Compare: _Util.comparePrimitives
+                        }))));
+                    case /* ClinicalSeverity */ 2:
+                        return (0, _List.ofArray)((0, _Option.toArray)((0, _List.tryHead)((0, _List.sortBy)((m_2)=>m_2.Priority, activeTransitions, {
+                            Compare: _Util.comparePrimitives
+                        }))));
+                    default:
+                        return (0, _List.ofArray)((0, _Option.toArray)((0, _List.tryHead)((0, _List.sortBy)((m)=>m.Priority, activeTransitions, {
+                            Compare: _Util.comparePrimitives
+                        }))));
+                }
+            }
+    }
+}
+function calculateProbability(status, totalConditions) {
+    switch(status.tag){
+        case /* Failed */ 1:
+            return 0;
+        case /* Pending */ 2:
+            return (totalConditions - (0, _List.length)(status.fields[0])) / totalConditions;
+        default:
+            return 1;
+    }
+}
+function predictOutcomes(context) {
+    return (0, _List.truncate)(5, (0, _List.sortByDescending)((p)=>p.Probability, (0, _List.choose)((matched)=>{
+        const matchValue = matched.Status;
+        switch(matchValue.tag){
+            case /* Pending */ 2:
+                {
+                    const fields = matchValue.fields[0];
+                    const matchValue_2 = findState(matched.Transition.ToState, context.PathwaySpec.States);
+                    if (matchValue_2 == null) {
+                        return undefined;
+                    } else {
+                        const toStateStr_1 = matched.Transition.ToState.fields[0];
+                        return new PredictedPathway(toStateStr_1, 0.5, fields, extractActionsFromState((0, _Option.value)(matchValue_2)), toStateStr_1);
+                    }
+                }
+            case /* Failed */ 1:
+                return undefined;
+            default:
+                {
+                    const matchValue_1 = findState(matched.Transition.ToState, context.PathwaySpec.States);
+                    if (matchValue_1 == null) {
+                        return undefined;
+                    } else {
+                        const toStateStr = matched.Transition.ToState.fields[0];
+                        return new PredictedPathway(toStateStr, 1, (0, _List.empty)(), extractActionsFromState((0, _Option.value)(matchValue_1)), toStateStr);
+                    }
+                }
+        }
+    }, evaluateAllTransitions(context)), {
+        Compare: _Util.comparePrimitives
+    }));
+}
+function calculateCompletionPercentage(context) {
+    const totalStates = (0, _List.length)(context.PathwaySpec.States);
+    if (totalStates === 0) {
+        return 0;
+    } else {
+        return (0, _Set.FSharpSet__get_Count)(context.VisitedStates) / totalStates * 100;
+    }
+}
+function isExecutionComplete(context) {
+    if ((0, _List.exists)(isTerminalState, (0, _List.choose)((sk)=>findState(sk, context.PathwaySpec.States), (0, _Set.toList)(context.CurrentStates)))) {
+        return true;
+    } else if ((0, _List.isEmpty)(categorizeTransitions(context.ActiveTransitions)[0])) {
+        return !(0, _Set.FSharpSet__get_IsEmpty)(context.CurrentStates);
+    } else {
+        return false;
+    }
+}
+function initializeExecution(formSpec, formData) {
+    const matchValue = formSpec.ClinicalPathway;
+    if (matchValue == null) {
+        throw new Error("No clinical pathway found in form spec");
+    } else {
+        const pathway = (0, _Option.value)(matchValue);
+        const resolver = FieldResolver_createResolver(formSpec);
+        let initialStates;
+        const matchValue_1 = pathway.InitialState;
+        if (matchValue_1 == null) {
+            const statesWithIncoming = (0, _Set.ofList)((0, _List.map)((t)=>t.ToState, pathway.Transitions), {
+                Compare: _Util.compare
+            });
+            const candidates = (0, _List.map)((s_1)=>s_1.StateKey, (0, _List.filter)((s)=>!(0, _Set.contains)(s.StateKey, statesWithIncoming), pathway.States));
+            initialStates = (0, _List.isEmpty)(candidates) ? (0, _Option.defaultArg)((0, _Option.map)((s_2)=>(0, _List.singleton)(s_2.StateKey), (0, _List.tryHead)(pathway.States)), (0, _List.empty)()) : candidates;
+        } else {
+            initialStates = (0, _List.singleton)((0, _Option.value)(matchValue_1));
+        }
+        return new ExecutionContext$1(pathway, formSpec, (0, _Set.ofList)(initialStates, {
+            Compare: _Util.compare
+        }), (0, _Set.ofList)(initialStates, {
+            Compare: _Util.compare
+        }), (0, _Set.empty)({
+            Compare: _Util.compare
+        }), (0, _List.empty)(), (0, _List.empty)(), (0, _List.empty)(), formData, resolver, (0, _List.map)((stateKey)=>new ExecutionLogEntry((0, _Date.now)(), stateKey, "Initialized", "Starting state"), initialStates));
+    }
+}
+function resolveFieldValueSource(valueSource, formSpec, formData) {
+    switch(valueSource.tag){
+        case /* FieldReference */ 1:
+            return (0, _Option.defaultArg)((0, _Map.tryFind)(valueSource.fields[0], FieldResolver_extractFieldValues(FieldResolver_createResolver(formSpec), formData)), "");
+        case /* OptionKey */ 2:
+            {
+                const optionKey = valueSource.fields[0];
+                return (0, _Option.defaultArg)((0, _List.tryPick)((field)=>{
+                    const fieldType = field.FieldType;
+                    return (0, _Option.map)((opt_1)=>opt_1.Description, (0, _List.tryFind)((opt)=>(0, _Util.equals)(opt.OptionKey, optionKey), fieldType.tag === /* SingleChoice */ 13 ? fieldType.fields[0].Options : fieldType.tag === /* MultiChoice */ 15 ? fieldType.fields[0].Options : fieldType.tag === /* CheckboxList */ 16 ? fieldType.fields[0].Options : fieldType.tag === /* Dropdown */ 14 ? fieldType.fields[0].Options : fieldType.tag === /* Radio */ 12 ? fieldType.fields[0].Options : (0, _List.empty)()));
+                }, (0, _List.collect)((step)=>step.Fields, formSpec.Steps)), "");
+            }
+        default:
+            return valueSource.fields[0];
+    }
+}
+function executeSetFieldValueAction(action, formSpec, formData) {
+    let matchValue, condition, fieldValues, fieldType;
+    if (!(matchValue = action.Condition, matchValue == null ? true : (condition = (0, _Option.value)(matchValue), fieldValues = FieldResolver_extractFieldValues(FieldResolver_createResolver(formSpec), formData), evaluateTransitionWithPartialData(FieldResolver_createResolver(formSpec), formSpec, fieldValues, (0, _Set.empty)({
+        Compare: _Util.compare
+    }), condition).tag === /* Satisfied */ 0))) {
+        return formData;
+    } else {
+        const valueToSet = resolveFieldValueSource(action.Value, formSpec, formData);
+        const targetFieldOpt = (0, _List.tryFind)((field)=>(0, _Util.equals)(field.FieldKey, action.TargetField), (0, _List.collect)((step)=>step.Fields, formSpec.Steps));
+        if (targetFieldOpt == null) {
+            return formData;
+        } else {
+            const targetField = (0, _Option.value)(targetFieldOpt);
+            const stepOpt = (0, _List.tryFind)((step_1)=>(0, _List.exists)((f)=>(0, _Util.equals)(f.FieldKey, action.TargetField), step_1.Fields), formSpec.Steps);
+            if (stepOpt == null) {
+                return formData;
+            } else {
+                const stepOrder = new _FormSpec.Values_StepOrder((0, _Option.value)(stepOpt).StepOrder);
+                const fieldAnswer = new _FormSpec.Shared_FieldAnswer(action.TargetField, targetField.Label, valueToSet);
+                return new _FormSpec.Values_DynamicFormResultData$1(formData.ResultFormSpecDetails, (0, _Map.FSharpMap__Add)(formData.ResultSteps, stepOrder, (0, _Map.FSharpMap__Add)((0, _Option.defaultArg)((0, _Map.tryFind)(stepOrder, formData.ResultSteps), (0, _Map.empty)({
+                    Compare: _Util.compare
+                })), action.TargetField, (fieldType = targetField.FieldType, new _FormSpec.Values_FieldDetails$1(targetField.FieldOrder, action.TargetField, targetField.Label, (0, _FormSpec.Shared_FieldValue_Single)(fieldAnswer), targetField.FieldType, (0, _List.map)((opt)=>new _FormSpec.Shared_FieldOption(opt.Description, opt.Value, opt.OptionKey), fieldType.tag === /* SingleChoice */ 13 ? fieldType.fields[0].Options : fieldType.tag === /* MultiChoice */ 15 ? fieldType.fields[0].Options : fieldType.tag === /* CheckboxList */ 16 ? fieldType.fields[0].Options : fieldType.tag === /* Dropdown */ 14 ? fieldType.fields[0].Options : fieldType.tag === /* Radio */ 12 ? fieldType.fields[0].Options : (0, _List.empty)()))))));
+            }
+        }
+    }
+}
+function executeAction(action, formSpec, formData) {
+    if (action.tag === /* SetFieldValue */ 10) {
+        return executeSetFieldValueAction(action.fields[0], formSpec, formData);
+    } else {
+        return formData;
+    }
+}
+function executeActions(actions, formSpec, formData) {
+    return (0, _List.fold)((currentData, action)=>executeAction(action, formSpec, currentData), formData, actions);
+}
+function executeStep(context_mut, maxIterations_mut) {
+    executeStep: while(true){
+        const context = context_mut, maxIterations = maxIterations_mut;
+        if (maxIterations <= 0) {
+            return context;
+        } else {
+            const patternInput = categorizeTransitions(evaluateAllTransitions(context));
+            const pending = patternInput[1];
+            const active = patternInput[0];
+            const selectedTransitions = selectTransitionsByMode(context.PathwaySpec.ExecutionMode, active);
+            if ((0, _List.isEmpty)(selectedTransitions)) {
+                return new ExecutionContext$1(context.PathwaySpec, context.FormSpec, context.CurrentStates, context.VisitedStates, context.CompletedStates, active, pending, context.ExecutedActions, context.FormData, context.FieldResolver, context.ExecutionLog);
+            } else {
+                const newStates = (0, _Set.ofList)((0, _List.map)((t)=>t.Transition.ToState, selectedTransitions), {
+                    Compare: _Util.compare
+                });
+                const newActions = (0, _List.collect)(extractActionsFromState, (0, _List.choose)((sk)=>findState(sk, context.PathwaySpec.States), (0, _Set.toList)(newStates)));
+                const updatedFormData = executeActions(newActions, context.FormSpec, context.FormData);
+                const newLogEntries = (0, _List.map)((t_1)=>{
+                    let arg, arg_1;
+                    return new ExecutionLogEntry((0, _Date.now)(), t_1.Transition.ToState, "Transitioned", (arg = t_1.Transition.FromState.fields[0], arg_1 = t_1.Transition.TransitionKey.fields[0], (0, _String.toText)((0, _String.printf)("From %s via %s"))(arg)(arg_1)));
+                }, selectedTransitions);
+                const updatedContext = new ExecutionContext$1(context.PathwaySpec, context.FormSpec, newStates, (0, _Set.union)(context.VisitedStates, newStates), (0, _Set.union)(context.CompletedStates, context.CurrentStates), active, pending, (0, _List.append)(context.ExecutedActions, newActions), updatedFormData, context.FieldResolver, (0, _List.append)(context.ExecutionLog, newLogEntries));
+                if (isExecutionComplete(updatedContext)) {
+                    return updatedContext;
+                } else {
+                    context_mut = updatedContext;
+                    maxIterations_mut = maxIterations - 1;
+                    continue executeStep;
+                }
+            }
+        }
+        break;
+    }
+}
+function executeIncremental(context, formData) {
+    let previousTransitionKeys, newKeys;
+    const startingAtTerminal = (0, _List.exists)(isTerminalState, (0, _List.choose)((sk)=>findState(sk, context.PathwaySpec.States), (0, _Set.toList)(context.CurrentStates)));
+    const updatedContext = new ExecutionContext$1(context.PathwaySpec, context.FormSpec, context.CurrentStates, context.VisitedStates, context.CompletedStates, context.ActiveTransitions, context.PendingTransitions, context.ExecutedActions, formData, context.FieldResolver, context.ExecutionLog);
+    const newContext = executeStep(updatedContext, 100);
+    return new IncrementalExecutionResult$1(newContext, (0, _List.map)((_arg)=>_arg.fields[0], (0, _Set.toList)((0, _Set.difference)(newContext.CurrentStates, updatedContext.CurrentStates))), (previousTransitionKeys = (0, _Set.ofList)((0, _List.map)((t)=>t.Transition.TransitionKey, updatedContext.ActiveTransitions), {
+        Compare: _Util.compare
+    }), newKeys = (0, _Set.difference)((0, _Set.ofList)((0, _List.map)((t_1)=>t_1.Transition.TransitionKey, newContext.ActiveTransitions), {
+        Compare: _Util.compare
+    }), previousTransitionKeys), (0, _List.map)((t_3)=>t_3.Transition, (0, _List.filter)((t_2)=>(0, _Set.contains)(t_2.Transition.TransitionKey, newKeys), newContext.ActiveTransitions))), predictOutcomes(newContext), calculateCompletionPercentage(newContext), isExecutionComplete(newContext));
+}
+function getVisualizationState(context) {
+    const patternInput = categorizeTransitions(context.ActiveTransitions);
+    const completedTransitions = (0, _List.map)((log_1)=>log_1.Details, (0, _List.filter)((log)=>log.Action === "Transitioned", context.ExecutionLog));
+    return new VisualizationState(context.CurrentStates, context.VisitedStates, (0, _List.map)((t)=>t.Transition.TransitionKey, patternInput[0]), (0, _List.map)((t_1)=>t_1.Transition.TransitionKey, patternInput[1]), completedTransitions, predictOutcomes(context));
+}
+function extractClinicalPlans(context) {
+    return (0, _List.sortBy)((plan)=>plan.Priority, (0, _List.choose)((stateKey)=>{
+        const matchValue = findState(stateKey, context.PathwaySpec.States);
+        let matchResult, state_1;
+        if (matchValue != null) {
+            if (!(0, _List.isEmpty)(extractActionsFromState((0, _Option.value)(matchValue)))) {
+                matchResult = 0;
+                state_1 = (0, _Option.value)(matchValue);
+            } else {
+                matchResult = 1;
+            }
+        } else {
+            matchResult = 1;
+        }
+        switch(matchResult){
+            case 0:
+                {
+                    const stateKeyStr = stateKey.fields[0];
+                    return new ClinicalPlan(stateKeyStr, extractActionsFromState(state_1), stateKeyStr, state_1.StateOrder);
+                }
+            default:
+                return undefined;
+        }
+    }, (0, _Set.toList)(context.CurrentStates)), {
+        Compare: _Util.comparePrimitives
+    });
+}
+class PathwayExecutionResult$1 extends _Types.Record {
+    constructor(PathwayId, StartState, CurrentState, ExecutionMode, SelectedPaths, RejectedPaths, ExecutedActions, VisitedStates, TransitionsUsed, FormData, ExecutionTime, Success, Errors){
+        super();
+        this.PathwayId = PathwayId;
+        this.StartState = StartState;
+        this.CurrentState = CurrentState;
+        this.ExecutionMode = ExecutionMode;
+        this.SelectedPaths = SelectedPaths;
+        this.RejectedPaths = RejectedPaths;
+        this.ExecutedActions = ExecutedActions;
+        this.VisitedStates = VisitedStates;
+        this.TransitionsUsed = TransitionsUsed;
+        this.FormData = FormData;
+        this.ExecutionTime = ExecutionTime;
+        this.Success = Success;
+        this.Errors = Errors;
+    }
+}
+function PathwayExecutionResult$1_$reflection(gen0) {
+    return (0, _Reflection.record_type)("F1.Studio.PathwayExecutor.PathwayExecutionResult`1", [
+        gen0
+    ], PathwayExecutionResult$1, ()=>[
+            [
+                "PathwayId",
+                _Reflection.string_type
+            ],
+            [
+                "StartState",
+                _Reflection.string_type
+            ],
+            [
+                "CurrentState",
+                _Reflection.string_type
+            ],
+            [
+                "ExecutionMode",
+                (0, _FormSpec.ClinicalPathway_PathwayExecutionMode_$reflection)()
+            ],
+            [
+                "SelectedPaths",
+                (0, _Reflection.list_type)(_Reflection.string_type)
+            ],
+            [
+                "RejectedPaths",
+                (0, _Reflection.list_type)((0, _Reflection.tuple_type)(_Reflection.string_type, _Reflection.string_type))
+            ],
+            [
+                "ExecutedActions",
+                (0, _Reflection.list_type)((0, _FormSpec.ClinicalPathway_ActionInfo_$reflection)())
+            ],
+            [
+                "VisitedStates",
+                (0, _Reflection.list_type)(_Reflection.string_type)
+            ],
+            [
+                "TransitionsUsed",
+                (0, _Reflection.list_type)(_Reflection.string_type)
+            ],
+            [
+                "FormData",
+                (0, _FormSpec.Values_DynamicFormResultData$1_$reflection)(gen0)
+            ],
+            [
+                "ExecutionTime",
+                (0, _Reflection.class_type)("System.DateTime")
+            ],
+            [
+                "Success",
+                _Reflection.bool_type
+            ],
+            [
+                "Errors",
+                (0, _Reflection.list_type)(_Reflection.string_type)
+            ]
+        ]);
+} //# sourceMappingURL=PathwayExecutor.ts.map
+
+//# sourceMappingURL=PathwayExecutor.js.map