@f1studio/form-spec 5.0.0-alpha.101

package/src/PathwayExecutor.ts

@@ -0,0 +1,1102 @@
+import { FSharpRef, Record, Union } from "@fable-org/fable-library-js/Types.js";
+import { fold, tryPick, sortByDescending, truncate, length, sortBy, tryHead, filter, ofArray as ofArray_1, append, empty, tryFind as tryFind_1, head, tail, isEmpty, choose, concat, forAll, singleton, exists, collect, map, FSharpList } from "@fable-org/fable-library-js/List.js";
+import { tuple_type, bool_type, float64_type, lambda_type, class_type, record_type, int32_type, union_type, list_type, string_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { ClinicalPathway_PathwayExecutionMode_$reflection, ClinicalPathway_SetFieldValueAction, ClinicalPathway_FieldValueSource_$union, ClinicalPathway_PathwayExecutionMode_$union, ClinicalPathway_SelectionStrategy_$union, ClinicalPathway_CombinationStrategy_$union, ClinicalPathway_StateType_$union, ClinicalPathway_StateDefinition, Shared_PluginPropertyKey, Shared_FieldOption, Spec_FieldType_$union, Shared_FieldOptionKey, ClinicalPathway_TransitionCondition_$union, ClinicalPathway_LogicalOp_$union, ClinicalPathway_StateEvaluator_$union, Shared_FieldValue_Single, Shared_ConditionValue_$union, ClinicalPathway_FieldEvaluator_$union, Values_StepOrder, Shared_PluginDataProperty, Shared_FieldValue_$union, Values_FieldDetails$1, Shared_PluginDataProperty_$reflection, Shared_MatrixItemKey, Shared_FieldAnswer, Spec_FormStep$1, Spec_FormField$1, Shared_TransitionKey_$reflection, Shared_TransitionKey, Shared_FieldKey_$reflection, Values_DynamicFormResultData$1_$reflection, ClinicalPathway_ActionInfo_$reflection, Spec_FormSpec$1_$reflection, ClinicalPathway_ClinicalPathwaySpec_$reflection, Shared_FieldKey, Values_DynamicFormResultData$1, ClinicalPathway_ActionInfo_$union, Spec_FormSpec$1, ClinicalPathway_ClinicalPathwaySpec, Shared_StateKey_$reflection, Shared_StateKey, ClinicalPathway_TransitionDefinition_$reflection, ClinicalPathway_TransitionDefinition } from "./FormSpec.js";
+import { uint8, float64, int32 } from "@fable-org/fable-library-js/Int32.js";
+import { equals, compare, comparePrimitives, stringHash, IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { difference, union, empty as empty_1, FSharpSet__get_IsEmpty, FSharpSet__get_Count, contains, ofList as ofList_1, isSubset, ofArray, map as map_2, toList, FSharpSet } from "@fable-org/fable-library-js/Set.js";
+import { map as map_3, setItem, iterateIndexed, fill } from "@fable-org/fable-library-js/Array.js";
+import { getBytesInt32 } from "@fable-org/fable-library-js/BitConverter.js";
+import { arrayToGuid } from "@fable-org/fable-library-js/Guid.js";
+import { empty as empty_2, FSharpMap__Add, toSeq, toList as toList_1, ofSeq, tryFind, FSharpMap, ofList } from "@fable-org/fable-library-js/Map.js";
+import { defaultArg, toArray, some, map as map_4, bind, value as value_3, Option } from "@fable-org/fable-library-js/Option.js";
+import { map as map_1, collect as collect_1 } from "@fable-org/fable-library-js/Seq.js";
+import { printf, toText, isNullOrWhiteSpace, join } from "@fable-org/fable-library-js/String.js";
+import { Auto_generateBoxedEncoder_437914C6, toString } from "./fable_modules/Thoth.Json.10.4.1/Encode.fs.js";
+import { tryParse } from "@fable-org/fable-library-js/Double.js";
+import { create, isMatch } from "@fable-org/fable-library-js/RegExp.js";
+import { now } from "@fable-org/fable-library-js/Date.js";
+
+export type TransitionStatus_$union = 
+    | TransitionStatus<0>
+    | TransitionStatus<1>
+    | TransitionStatus<2>
+
+export type TransitionStatus_$cases = {
+    0: ["Satisfied", []],
+    1: ["Failed", []],
+    2: ["Pending", [FSharpList<string>]]
+}
+
+export function TransitionStatus_Satisfied() {
+    return new TransitionStatus<0>(0, []);
+}
+
+export function TransitionStatus_Failed() {
+    return new TransitionStatus<1>(1, []);
+}
+
+export function TransitionStatus_Pending(missingFields: FSharpList<string>) {
+    return new TransitionStatus<2>(2, [missingFields]);
+}
+
+export class TransitionStatus<Tag extends keyof TransitionStatus_$cases> extends Union<Tag, TransitionStatus_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: TransitionStatus_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Satisfied", "Failed", "Pending"];
+    }
+}
+
+export function TransitionStatus_$reflection(): TypeInfo {
+    return union_type("F1.Studio.PathwayExecutor.TransitionStatus", [], TransitionStatus, () => [[], [], [["missingFields", list_type(string_type)]]]);
+}
+
+export class MatchedTransition extends Record implements IEquatable<MatchedTransition>, IComparable<MatchedTransition> {
+    readonly Transition: ClinicalPathway_TransitionDefinition;
+    readonly Priority: int32;
+    readonly Status: TransitionStatus_$union;
+    constructor(Transition: ClinicalPathway_TransitionDefinition, Priority: int32, Status: TransitionStatus_$union) {
+        super();
+        this.Transition = Transition;
+        this.Priority = (Priority | 0);
+        this.Status = Status;
+    }
+}
+
+export function MatchedTransition_$reflection(): TypeInfo {
+    return record_type("F1.Studio.PathwayExecutor.MatchedTransition", [], MatchedTransition, () => [["Transition", ClinicalPathway_TransitionDefinition_$reflection()], ["Priority", int32_type], ["Status", TransitionStatus_$reflection()]]);
+}
+
+export class ExecutionLogEntry extends Record implements IEquatable<ExecutionLogEntry>, IComparable<ExecutionLogEntry> {
+    readonly Timestamp: Date;
+    readonly StateKey: Shared_StateKey;
+    readonly Action: string;
+    readonly Details: string;
+    constructor(Timestamp: Date, StateKey: Shared_StateKey, Action: string, Details: string) {
+        super();
+        this.Timestamp = Timestamp;
+        this.StateKey = StateKey;
+        this.Action = Action;
+        this.Details = Details;
+    }
+}
+
+export function ExecutionLogEntry_$reflection(): TypeInfo {
+    return record_type("F1.Studio.PathwayExecutor.ExecutionLogEntry", [], ExecutionLogEntry, () => [["Timestamp", class_type("System.DateTime")], ["StateKey", Shared_StateKey_$reflection()], ["Action", string_type], ["Details", string_type]]);
+}
+
+export class ExecutionContext$1<FieldType> extends Record {
+    readonly PathwaySpec: ClinicalPathway_ClinicalPathwaySpec;
+    readonly FormSpec: Spec_FormSpec$1<FieldType>;
+    readonly CurrentStates: FSharpSet<Shared_StateKey>;
+    readonly VisitedStates: FSharpSet<Shared_StateKey>;
+    readonly CompletedStates: FSharpSet<Shared_StateKey>;
+    readonly ActiveTransitions: FSharpList<MatchedTransition>;
+    readonly PendingTransitions: FSharpList<MatchedTransition>;
+    readonly ExecutedActions: FSharpList<ClinicalPathway_ActionInfo_$union>;
+    readonly FormData: Values_DynamicFormResultData$1<FieldType>;
+    readonly FieldResolver: ((arg0: string) => Shared_FieldKey);
+    readonly ExecutionLog: FSharpList<ExecutionLogEntry>;
+    constructor(PathwaySpec: ClinicalPathway_ClinicalPathwaySpec, FormSpec: Spec_FormSpec$1<FieldType>, CurrentStates: FSharpSet<Shared_StateKey>, VisitedStates: FSharpSet<Shared_StateKey>, CompletedStates: FSharpSet<Shared_StateKey>, ActiveTransitions: FSharpList<MatchedTransition>, PendingTransitions: FSharpList<MatchedTransition>, ExecutedActions: FSharpList<ClinicalPathway_ActionInfo_$union>, FormData: Values_DynamicFormResultData$1<FieldType>, FieldResolver: ((arg0: string) => Shared_FieldKey), ExecutionLog: FSharpList<ExecutionLogEntry>) {
+        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;
+    }
+}
+
+export function ExecutionContext$1_$reflection(gen0: TypeInfo): TypeInfo {
+    return record_type("F1.Studio.PathwayExecutor.ExecutionContext`1", [gen0], ExecutionContext$1, () => [["PathwaySpec", ClinicalPathway_ClinicalPathwaySpec_$reflection()], ["FormSpec", Spec_FormSpec$1_$reflection(gen0)], ["CurrentStates", class_type("Microsoft.FSharp.Collections.FSharpSet`1", [Shared_StateKey_$reflection()])], ["VisitedStates", class_type("Microsoft.FSharp.Collections.FSharpSet`1", [Shared_StateKey_$reflection()])], ["CompletedStates", class_type("Microsoft.FSharp.Collections.FSharpSet`1", [Shared_StateKey_$reflection()])], ["ActiveTransitions", list_type(MatchedTransition_$reflection())], ["PendingTransitions", list_type(MatchedTransition_$reflection())], ["ExecutedActions", list_type(ClinicalPathway_ActionInfo_$reflection())], ["FormData", Values_DynamicFormResultData$1_$reflection(gen0)], ["FieldResolver", lambda_type(string_type, Shared_FieldKey_$reflection())], ["ExecutionLog", list_type(ExecutionLogEntry_$reflection())]]);
+}
+
+export class PredictedPathway extends Record implements IEquatable<PredictedPathway>, IComparable<PredictedPathway> {
+    readonly PathwayId: string;
+    readonly Probability: float64;
+    readonly RequiredFields: FSharpList<string>;
+    readonly ExpectedActions: FSharpList<ClinicalPathway_ActionInfo_$union>;
+    readonly TargetState: string;
+    constructor(PathwayId: string, Probability: float64, RequiredFields: FSharpList<string>, ExpectedActions: FSharpList<ClinicalPathway_ActionInfo_$union>, TargetState: string) {
+        super();
+        this.PathwayId = PathwayId;
+        this.Probability = Probability;
+        this.RequiredFields = RequiredFields;
+        this.ExpectedActions = ExpectedActions;
+        this.TargetState = TargetState;
+    }
+}
+
+export function PredictedPathway_$reflection(): TypeInfo {
+    return record_type("F1.Studio.PathwayExecutor.PredictedPathway", [], PredictedPathway, () => [["PathwayId", string_type], ["Probability", float64_type], ["RequiredFields", list_type(string_type)], ["ExpectedActions", list_type(ClinicalPathway_ActionInfo_$reflection())], ["TargetState", string_type]]);
+}
+
+export class IncrementalExecutionResult$1<FieldType> extends Record {
+    readonly Context: ExecutionContext$1<FieldType>;
+    readonly NewlyActivatedStates: FSharpList<string>;
+    readonly NewlyActiveTransitions: FSharpList<ClinicalPathway_TransitionDefinition>;
+    readonly PredictedOutcomes: FSharpList<PredictedPathway>;
+    readonly CompletionPercentage: float64;
+    readonly IsComplete: boolean;
+    constructor(Context: ExecutionContext$1<FieldType>, NewlyActivatedStates: FSharpList<string>, NewlyActiveTransitions: FSharpList<ClinicalPathway_TransitionDefinition>, PredictedOutcomes: FSharpList<PredictedPathway>, CompletionPercentage: float64, IsComplete: boolean) {
+        super();
+        this.Context = Context;
+        this.NewlyActivatedStates = NewlyActivatedStates;
+        this.NewlyActiveTransitions = NewlyActiveTransitions;
+        this.PredictedOutcomes = PredictedOutcomes;
+        this.CompletionPercentage = CompletionPercentage;
+        this.IsComplete = IsComplete;
+    }
+}
+
+export function IncrementalExecutionResult$1_$reflection(gen0: TypeInfo): TypeInfo {
+    return record_type("F1.Studio.PathwayExecutor.IncrementalExecutionResult`1", [gen0], IncrementalExecutionResult$1, () => [["Context", ExecutionContext$1_$reflection(gen0)], ["NewlyActivatedStates", list_type(string_type)], ["NewlyActiveTransitions", list_type(ClinicalPathway_TransitionDefinition_$reflection())], ["PredictedOutcomes", list_type(PredictedPathway_$reflection())], ["CompletionPercentage", float64_type], ["IsComplete", bool_type]]);
+}
+
+export class ClinicalPlan extends Record implements IEquatable<ClinicalPlan>, IComparable<ClinicalPlan> {
+    readonly PlanId: string;
+    readonly Actions: FSharpList<ClinicalPathway_ActionInfo_$union>;
+    readonly TargetState: string;
+    readonly Priority: int32;
+    constructor(PlanId: string, Actions: FSharpList<ClinicalPathway_ActionInfo_$union>, TargetState: string, Priority: int32) {
+        super();
+        this.PlanId = PlanId;
+        this.Actions = Actions;
+        this.TargetState = TargetState;
+        this.Priority = (Priority | 0);
+    }
+}
+
+export function ClinicalPlan_$reflection(): TypeInfo {
+    return record_type("F1.Studio.PathwayExecutor.ClinicalPlan", [], ClinicalPlan, () => [["PlanId", string_type], ["Actions", list_type(ClinicalPathway_ActionInfo_$reflection())], ["TargetState", string_type], ["Priority", int32_type]]);
+}
+
+export class VisualizationState extends Record implements IEquatable<VisualizationState>, IComparable<VisualizationState> {
+    readonly CurrentStates: FSharpSet<Shared_StateKey>;
+    readonly VisitedStates: FSharpSet<Shared_StateKey>;
+    readonly ActiveTransitions: FSharpList<Shared_TransitionKey>;
+    readonly PendingTransitions: FSharpList<Shared_TransitionKey>;
+    readonly CompletedTransitions: FSharpList<string>;
+    readonly PredictedOutcomes: FSharpList<PredictedPathway>;
+    constructor(CurrentStates: FSharpSet<Shared_StateKey>, VisitedStates: FSharpSet<Shared_StateKey>, ActiveTransitions: FSharpList<Shared_TransitionKey>, PendingTransitions: FSharpList<Shared_TransitionKey>, CompletedTransitions: FSharpList<string>, PredictedOutcomes: FSharpList<PredictedPathway>) {
+        super();
+        this.CurrentStates = CurrentStates;
+        this.VisitedStates = VisitedStates;
+        this.ActiveTransitions = ActiveTransitions;
+        this.PendingTransitions = PendingTransitions;
+        this.CompletedTransitions = CompletedTransitions;
+        this.PredictedOutcomes = PredictedOutcomes;
+    }
+}
+
+export function VisualizationState_$reflection(): TypeInfo {
+    return record_type("F1.Studio.PathwayExecutor.VisualizationState", [], VisualizationState, () => [["CurrentStates", class_type("Microsoft.FSharp.Collections.FSharpSet`1", [Shared_StateKey_$reflection()])], ["VisitedStates", class_type("Microsoft.FSharp.Collections.FSharpSet`1", [Shared_StateKey_$reflection()])], ["ActiveTransitions", list_type(Shared_TransitionKey_$reflection())], ["PendingTransitions", list_type(Shared_TransitionKey_$reflection())], ["CompletedTransitions", list_type(string_type)], ["PredictedOutcomes", list_type(PredictedPathway_$reflection())]]);
+}
+
+/**
+ * Generate deterministic GUID from field label
+ */
+export function FieldResolver_generateFieldKey(fieldName: string): Shared_FieldKey {
+    const hash: int32 = stringHash(fieldName) | 0;
+    const bytes: uint8[] = fill(new Array(16), 0, 16, 0);
+    iterateIndexed<uint8>((i: int32, b: uint8): void => {
+        if (i < 4) {
+            setItem(bytes, i, b);
+        }
+    }, Array.from(getBytesInt32(hash)));
+    iterateIndexed<uint8>((i_1: int32, b_1: uint8): void => {
+        if (i_1 < 4) {
+            setItem(bytes, i_1 + 4, b_1);
+        }
+    }, Array.from(getBytesInt32(hash >> 1)));
+    iterateIndexed<uint8>((i_2: int32, b_2: uint8): void => {
+        if (i_2 < 4) {
+            setItem(bytes, i_2 + 8, b_2);
+        }
+    }, Array.from(getBytesInt32(hash >> 2)));
+    iterateIndexed<uint8>((i_3: int32, b_3: uint8): void => {
+        if (i_3 < 4) {
+            setItem(bytes, i_3 + 12, b_3);
+        }
+    }, Array.from(getBytesInt32(hash >> 3)));
+    return new Shared_FieldKey(arrayToGuid(bytes));
+}
+
+/**
+ * Create resolver that maps pathway field references to FieldKeys
+ */
+export function FieldResolver_createResolver<FieldType>(formSpec: Spec_FormSpec$1<FieldType>): ((arg0: string) => Shared_FieldKey) {
+    const labelToFieldKey: FSharpMap<string, Shared_FieldKey> = ofList<string, Shared_FieldKey>(map<Spec_FormField$1<FieldType>, [string, Shared_FieldKey]>((field: Spec_FormField$1<FieldType>): [string, Shared_FieldKey] => ([field.Label.toLocaleLowerCase().trim(), field.FieldKey] as [string, Shared_FieldKey]), collect<Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>>((step: Spec_FormStep$1<FieldType>): FSharpList<Spec_FormField$1<FieldType>> => step.Fields, formSpec.Steps)), {
+        Compare: comparePrimitives,
+    });
+    return (fieldReference: string): Shared_FieldKey => {
+        const matchValue: Option<Shared_FieldKey> = tryFind<string, Shared_FieldKey>(fieldReference.toLocaleLowerCase().trim(), labelToFieldKey);
+        return (matchValue == null) ? FieldResolver_generateFieldKey(fieldReference) : value_3(matchValue);
+    };
+}
+
+/**
+ * Extract field values from form data using resolver
+ */
+export function FieldResolver_extractFieldValues<FieldType>(resolver: ((arg0: string) => Shared_FieldKey), formData: Values_DynamicFormResultData$1<FieldType>): FSharpMap<Shared_FieldKey, string> {
+    return ofSeq<Shared_FieldKey, string>(collect_1<[Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<FieldType>>], Iterable<[Shared_FieldKey, string]>, [Shared_FieldKey, string]>((tupledArg: [Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<FieldType>>]): Iterable<[Shared_FieldKey, string]> => map_1<[Shared_FieldKey, Values_FieldDetails$1<FieldType>], [Shared_FieldKey, string]>((tupledArg_1: [Shared_FieldKey, Values_FieldDetails$1<FieldType>]): [Shared_FieldKey, string] => {
+        let matchValue: Shared_FieldValue_$union, pluginData: FSharpList<Shared_PluginDataProperty>;
+        return [tupledArg_1[0], (matchValue = tupledArg_1[1].FieldValue, (matchValue.tag === /* Multiple */ 1) ? join(",", toList<string>(map_2<Shared_FieldAnswer, string>((a: Shared_FieldAnswer): string => a.Value, matchValue.fields[0], {
+            Compare: comparePrimitives,
+        }))) : ((matchValue.tag === /* Matrix */ 2) ? join(",", map<[Shared_MatrixItemKey, string], string>((tupledArg_2: [Shared_MatrixItemKey, string]): string => tupledArg_2[1], toList_1<Shared_MatrixItemKey, string>(matchValue.fields[0].Values))) : ((matchValue.tag === /* PluginData */ 3) ? ((pluginData = matchValue.fields[0], toString(0, Auto_generateBoxedEncoder_437914C6(list_type(Shared_PluginDataProperty_$reflection()), undefined, undefined, undefined)(pluginData)))) : matchValue.fields[0].Value)))] as [Shared_FieldKey, string];
+    }, toSeq<Shared_FieldKey, Values_FieldDetails$1<FieldType>>(tupledArg[1])), toSeq<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<FieldType>>>(formData.ResultSteps)), {
+        Compare: compare,
+    });
+}
+
+/**
+ * Evaluate a field condition with a specific evaluator (string-based, kept for backward compatibility)
+ */
+export function evaluateFieldCondition(actualValue: string, evaluator: ClinicalPathway_FieldEvaluator_$union, expectedValue: string): boolean {
+    switch (evaluator.tag) {
+        case /* NotEquals */ 1:
+            return actualValue.trim().toLocaleLowerCase() !== expectedValue.trim().toLocaleLowerCase();
+        case /* GreaterThan */ 5: {
+            let matchValue: [boolean, float64];
+            let outArg = 0;
+            matchValue = ([tryParse(actualValue, new FSharpRef<float64>((): float64 => outArg, (v: float64): void => {
+                outArg = v;
+            })), outArg] as [boolean, float64]);
+            let matchValue_1: [boolean, float64];
+            let outArg_1 = 0;
+            matchValue_1 = ([tryParse(expectedValue, new FSharpRef<float64>((): float64 => outArg_1, (v_1: float64): void => {
+                outArg_1 = v_1;
+            })), outArg_1] as [boolean, float64]);
+            let matchResult: int32;
+            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: [boolean, float64];
+            let outArg_2 = 0;
+            matchValue_3 = ([tryParse(actualValue, new FSharpRef<float64>((): float64 => outArg_2, (v_2: float64): void => {
+                outArg_2 = v_2;
+            })), outArg_2] as [boolean, float64]);
+            let matchValue_4: [boolean, float64];
+            let outArg_3 = 0;
+            matchValue_4 = ([tryParse(expectedValue, new FSharpRef<float64>((): float64 => outArg_3, (v_3: float64): void => {
+                outArg_3 = v_3;
+            })), outArg_3] as [boolean, float64]);
+            let matchResult_1: int32;
+            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: [boolean, float64];
+            let outArg_4 = 0;
+            matchValue_6 = ([tryParse(actualValue, new FSharpRef<float64>((): float64 => outArg_4, (v_4: float64): void => {
+                outArg_4 = v_4;
+            })), outArg_4] as [boolean, float64]);
+            let matchValue_7: [boolean, float64];
+            let outArg_5 = 0;
+            matchValue_7 = ([tryParse(expectedValue, new FSharpRef<float64>((): float64 => outArg_5, (v_5: float64): void => {
+                outArg_5 = v_5;
+            })), outArg_5] as [boolean, float64]);
+            let matchResult_2: int32;
+            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: [boolean, float64];
+            let outArg_6 = 0;
+            matchValue_9 = ([tryParse(actualValue, new FSharpRef<float64>((): float64 => outArg_6, (v_6: float64): void => {
+                outArg_6 = v_6;
+            })), outArg_6] as [boolean, float64]);
+            let matchValue_10: [boolean, float64];
+            let outArg_7 = 0;
+            matchValue_10 = ([tryParse(expectedValue, new FSharpRef<float64>((): float64 => outArg_7, (v_7: float64): void => {
+                outArg_7 = v_7;
+            })), outArg_7] as [boolean, float64]);
+            let matchResult_3: int32;
+            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 (!isNullOrWhiteSpace(actualValue) && (actualValue.toLocaleLowerCase() !== "false")) {
+                return actualValue.toLocaleLowerCase() !== "no";
+            }
+            else {
+                return false;
+            }
+        case /* IsAbsent */ 11:
+            if (isNullOrWhiteSpace(actualValue) ? true : (actualValue.toLocaleLowerCase() === "false")) {
+                return true;
+            }
+            else {
+                return actualValue.toLocaleLowerCase() === "no";
+            }
+        case /* MatchesPattern */ 12:
+            return isMatch(create(evaluator.fields[0]), actualValue);
+        case /* InRange */ 13: {
+            const minVal: int32 = evaluator.fields[0] | 0;
+            const maxVal: int32 = evaluator.fields[1] | 0;
+            let matchValue_12: [boolean, float64];
+            let outArg_8 = 0;
+            matchValue_12 = ([tryParse(actualValue, new FSharpRef<float64>((): float64 => outArg_8, (v_8: float64): void => {
+                outArg_8 = v_8;
+            })), outArg_8] as [boolean, float64]);
+            if (matchValue_12[0]) {
+                const actual_4: float64 = matchValue_12[1];
+                if (actual_4 >= minVal) {
+                    return actual_4 <= maxVal;
+                }
+                else {
+                    return false;
+                }
+            }
+            else {
+                return false;
+            }
+        }
+        case /* InSet */ 2:
+            return exists<string>((v_9: string): boolean => (v_9.trim().toLocaleLowerCase() === actualValue.trim().toLocaleLowerCase()), evaluator.fields[0]);
+        case /* NotInSet */ 3:
+            return !exists<string>((v_10: string): boolean => (v_10.trim().toLocaleLowerCase() === actualValue.trim().toLocaleLowerCase()), evaluator.fields[0]);
+        case /* ContainsAll */ 4: {
+            const values_2: FSharpList<string> = evaluator.fields[0];
+            const actualParts: FSharpSet<string> = ofArray<string>(map_3<string, string>((s: string): string => s.trim().toLocaleLowerCase(), actualValue.split(",")), {
+                Compare: comparePrimitives,
+            });
+            return isSubset<string>(ofList_1<string>(map<string, string>((s_1: string): string => s_1.trim().toLocaleLowerCase(), values_2), {
+                Compare: comparePrimitives,
+            }), actualParts);
+        }
+        default:
+            return actualValue.trim().toLocaleLowerCase() === expectedValue.trim().toLocaleLowerCase();
+    }
+}
+
+/**
+ * Evaluate a field condition with ConditionValue (type-aware comparison)
+ */
+export function evaluateFieldConditionWithConditionValue(actualFieldValue: Shared_FieldValue_$union, evaluator: ClinicalPathway_FieldEvaluator_$union, expectedConditionValue: Shared_ConditionValue_$union): boolean {
+    let pluginData: FSharpList<Shared_PluginDataProperty>, pluginData_1: Shared_PluginDataProperty;
+    return evaluateFieldCondition((actualFieldValue.tag === /* Multiple */ 1) ? join(",", toList<string>(map_2<Shared_FieldAnswer, string>((a: Shared_FieldAnswer): string => a.Value, actualFieldValue.fields[0], {
+        Compare: comparePrimitives,
+    }))) : ((actualFieldValue.tag === /* Matrix */ 2) ? join(",", map<[Shared_MatrixItemKey, string], string>((tupledArg: [Shared_MatrixItemKey, string]): string => tupledArg[1], toList_1<Shared_MatrixItemKey, string>(actualFieldValue.fields[0].Values))) : ((actualFieldValue.tag === /* PluginData */ 3) ? ((pluginData = actualFieldValue.fields[0], toString(0, Auto_generateBoxedEncoder_437914C6(list_type(Shared_PluginDataProperty_$reflection()), undefined, undefined, undefined)(pluginData)))) : actualFieldValue.fields[0].Value)), evaluator, (expectedConditionValue.tag === /* Multiple */ 1) ? join(",", toList<string>(expectedConditionValue.fields[0])) : ((expectedConditionValue.tag === /* Matrix */ 2) ? join(",", map<[Shared_MatrixItemKey, string], string>((tupledArg_1: [Shared_MatrixItemKey, string]): string => tupledArg_1[1], toList_1<Shared_MatrixItemKey, string>(expectedConditionValue.fields[0]))) : ((expectedConditionValue.tag === /* PluginData */ 3) ? ((pluginData_1 = expectedConditionValue.fields[0], toString(0, Auto_generateBoxedEncoder_437914C6(Shared_PluginDataProperty_$reflection(), undefined, undefined, undefined)(pluginData_1)))) : expectedConditionValue.fields[0])));
+}
+
+/**
+ * Recursively evaluate a transition condition with partial data support
+ */
+export function evaluateTransitionWithPartialData<FieldType>(resolver: ((arg0: string) => Shared_FieldKey), formSpec: Option<Spec_FormSpec$1<FieldType>>, fieldValues: FSharpMap<Shared_FieldKey, string>, visitedStates: FSharpSet<Shared_StateKey>, condition: ClinicalPathway_TransitionCondition_$union): TransitionStatus_$union {
+    let pluginData: Shared_PluginDataProperty, pluginData_1: Shared_PluginDataProperty;
+    switch (condition.tag) {
+        case /* FieldCondition */ 0: {
+            const fieldKey: Shared_FieldKey = condition.fields[0];
+            const evaluator: ClinicalPathway_FieldEvaluator_$union = condition.fields[1];
+            const conditionValue: Shared_ConditionValue_$union = condition.fields[2];
+            const matchValue: Option<string> = tryFind<Shared_FieldKey, string>(fieldKey, fieldValues);
+            if (matchValue == null) {
+                return TransitionStatus_Pending(singleton(fieldKey.fields[0]));
+            }
+            else if (evaluateFieldConditionWithConditionValue(Shared_FieldValue_Single(new Shared_FieldAnswer(fieldKey, "", value_3(matchValue))), evaluator, conditionValue)) {
+                return TransitionStatus_Satisfied();
+            }
+            else {
+                return TransitionStatus_Failed();
+            }
+        }
+        case /* StateCondition */ 3: {
+            const evaluator_1: ClinicalPathway_StateEvaluator_$union = condition.fields[1];
+            const stateVisited: boolean = contains<Shared_StateKey>(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: ClinicalPathway_LogicalOp_$union = condition.fields[0];
+            const conditions: FSharpList<ClinicalPathway_TransitionCondition_$union> = condition.fields[1];
+            switch (logicalOp.tag) {
+                case /* Or */ 1: {
+                    const results_1: FSharpList<TransitionStatus_$union> = map<ClinicalPathway_TransitionCondition_$union, TransitionStatus_$union>((condition_2: ClinicalPathway_TransitionCondition_$union): TransitionStatus_$union => evaluateTransitionWithPartialData<FieldType>(resolver, formSpec, fieldValues, visitedStates, condition_2), conditions);
+                    if (exists<TransitionStatus_$union>((r_3: TransitionStatus_$union): boolean => equals(r_3, TransitionStatus_Satisfied()), results_1)) {
+                        return TransitionStatus_Satisfied();
+                    }
+                    else if (forAll<TransitionStatus_$union>((r_4: TransitionStatus_$union): boolean => equals(r_4, TransitionStatus_Failed()), results_1)) {
+                        return TransitionStatus_Failed();
+                    }
+                    else {
+                        return TransitionStatus_Pending(concat<string>(choose<TransitionStatus_$union, FSharpList<string>>((r_5: TransitionStatus_$union): Option<FSharpList<string>> => {
+                            if (r_5.tag === /* Pending */ 2) {
+                                return r_5.fields[0];
+                            }
+                            else {
+                                return undefined;
+                            }
+                        }, results_1)));
+                    }
+                }
+                case /* Not */ 2: {
+                    let matchResult: int32, cond: ClinicalPathway_TransitionCondition_$union;
+                    if (!isEmpty(conditions)) {
+                        if (isEmpty(tail(conditions))) {
+                            matchResult = 0;
+                            cond = head(conditions);
+                        }
+                        else {
+                            matchResult = 1;
+                        }
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                    switch (matchResult) {
+                        case 0: {
+                            const matchValue_1: TransitionStatus_$union = evaluateTransitionWithPartialData<FieldType>(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: FSharpList<TransitionStatus_$union> = map<ClinicalPathway_TransitionCondition_$union, TransitionStatus_$union>((condition_1: ClinicalPathway_TransitionCondition_$union): TransitionStatus_$union => evaluateTransitionWithPartialData<FieldType>(resolver, formSpec, fieldValues, visitedStates, condition_1), conditions);
+                    if (exists<TransitionStatus_$union>((r: TransitionStatus_$union): boolean => equals(r, TransitionStatus_Failed()), results)) {
+                        return TransitionStatus_Failed();
+                    }
+                    else if (forAll<TransitionStatus_$union>((r_1: TransitionStatus_$union): boolean => equals(r_1, TransitionStatus_Satisfied()), results)) {
+                        return TransitionStatus_Satisfied();
+                    }
+                    else {
+                        return TransitionStatus_Pending(concat<string>(choose<TransitionStatus_$union, FSharpList<string>>((r_2: TransitionStatus_$union): Option<FSharpList<string>> => {
+                            if (r_2.tag === /* Pending */ 2) {
+                                return r_2.fields[0];
+                            }
+                            else {
+                                return undefined;
+                            }
+                        }, results)));
+                    }
+                }
+            }
+        }
+        case /* TestResultCondition */ 5: {
+            const result: string = condition.fields[1];
+            return TransitionStatus_Pending(singleton(condition.fields[0]));
+        }
+        case /* FieldOptionCondition */ 1: {
+            const optionKey: Shared_FieldOptionKey = condition.fields[2];
+            const matrixItemKey: Option<Shared_MatrixItemKey> = condition.fields[1];
+            const fieldKey_1: Shared_FieldKey = condition.fields[0];
+            const evaluator_2: ClinicalPathway_FieldEvaluator_$union = condition.fields[3];
+            const conditionValue_1: Shared_ConditionValue_$union = condition.fields[4];
+            const optionValueOpt: Option<string> = (formSpec == null) ? undefined : bind<Spec_FormField$1<FieldType>, string>((field_1: Spec_FormField$1<FieldType>): Option<string> => {
+                const fieldType = field_1.FieldType as Spec_FieldType_$union;
+                return map_4<Shared_FieldOption, string>((opt_1: Shared_FieldOption): string => opt_1.Value, tryFind_1<Shared_FieldOption>((opt: Shared_FieldOption): boolean => 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 : empty<Shared_FieldOption>()))))));
+            }, tryFind_1<Spec_FormField$1<FieldType>>((field: Spec_FormField$1<FieldType>): boolean => equals(field.FieldKey, fieldKey_1), collect<Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>>((step: Spec_FormStep$1<FieldType>): FSharpList<Spec_FormField$1<FieldType>> => step.Fields, value_3(formSpec).Steps)));
+            const matchValue_2: Option<string> = tryFind<Shared_FieldKey, string>(fieldKey_1, fieldValues);
+            if (optionValueOpt == null) {
+                const guid_1: string = optionKey.fields[0];
+                console.error(some("[evaluateTransition] FieldOptionCondition: Could not find option in formSpec for optionKey:"), guid_1);
+                return TransitionStatus_Failed();
+            }
+            else if (matchValue_2 == null) {
+                return TransitionStatus_Pending(singleton(fieldKey_1.fields[0]));
+            }
+            else {
+                const actualValueStr_1: string = value_3(matchValue_2);
+                const optionValue: string = value_3(optionValueOpt);
+                const actualValues: FSharpSet<string> = ofArray<string>(map_3<string, string>((s: string): string => s.trim().toLocaleLowerCase(), actualValueStr_1.split(",")), {
+                    Compare: comparePrimitives,
+                });
+                const containsOption: boolean = contains<string>(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) ? join(",", toList<string>(conditionValue_1.fields[0])) : ((conditionValue_1.tag === /* Matrix */ 2) ? join(",", map<[Shared_MatrixItemKey, string], string>((tupledArg: [Shared_MatrixItemKey, string]): string => tupledArg[1], toList_1<Shared_MatrixItemKey, string>(conditionValue_1.fields[0]))) : ((conditionValue_1.tag === /* PluginData */ 3) ? ((pluginData = conditionValue_1.fields[0], toString(0, Auto_generateBoxedEncoder_437914C6(Shared_PluginDataProperty_$reflection(), undefined, undefined, undefined)(pluginData)))) : conditionValue_1.fields[0])))) {
+                            return TransitionStatus_Satisfied();
+                        }
+                        else {
+                            return TransitionStatus_Failed();
+                        }
+                }
+            }
+        }
+        case /* PluginPropertyCondition */ 2: {
+            const propertyKey: Shared_PluginPropertyKey = condition.fields[1];
+            const fieldKey_2: Shared_FieldKey = condition.fields[0];
+            const evaluator_3: ClinicalPathway_FieldEvaluator_$union = condition.fields[2];
+            const conditionValue_2: Shared_ConditionValue_$union = condition.fields[3];
+            const matchValue_4: Option<string> = tryFind<Shared_FieldKey, string>(fieldKey_2, fieldValues);
+            if (matchValue_4 == null) {
+                return TransitionStatus_Pending(singleton(fieldKey_2.fields[0]));
+            }
+            else {
+                const actualValueStr_2: string = value_3(matchValue_4);
+                try {
+                    const actualFieldValue_1: Shared_FieldValue_$union = Shared_FieldValue_Single(new Shared_FieldAnswer(fieldKey_2, "", actualValueStr_2));
+                    return evaluateFieldCondition(actualValueStr_2, evaluator_3, (conditionValue_2.tag === /* Multiple */ 1) ? join(",", toList<string>(conditionValue_2.fields[0])) : ((conditionValue_2.tag === /* Matrix */ 2) ? join(",", map<[Shared_MatrixItemKey, string], string>((tupledArg_1: [Shared_MatrixItemKey, string]): string => tupledArg_1[1], toList_1<Shared_MatrixItemKey, string>(conditionValue_2.fields[0]))) : ((conditionValue_2.tag === /* PluginData */ 3) ? ((pluginData_1 = conditionValue_2.fields[0], toString(0, Auto_generateBoxedEncoder_437914C6(Shared_PluginDataProperty_$reflection(), undefined, undefined, undefined)(pluginData_1)))) : conditionValue_2.fields[0]))) ? TransitionStatus_Satisfied() : TransitionStatus_Failed();
+                }
+                catch (ex: any) {
+                    return TransitionStatus_Failed();
+                }
+            }
+        }
+        default:
+            return TransitionStatus_Satisfied();
+    }
+}
+
+/**
+ * Find a state by key
+ */
+export function findState(stateKey: Shared_StateKey, states: FSharpList<ClinicalPathway_StateDefinition>): Option<ClinicalPathway_StateDefinition> {
+    return tryFind_1<ClinicalPathway_StateDefinition>((s: ClinicalPathway_StateDefinition): boolean => equals(s.StateKey, stateKey), states);
+}
+
+/**
+ * Extract actions from state
+ */
+export function extractActionsFromState(state: ClinicalPathway_StateDefinition): FSharpList<ClinicalPathway_ActionInfo_$union> {
+    const matchValue: ClinicalPathway_StateType_$union = state.StateType;
+    switch (matchValue.tag) {
+        case /* Action */ 2:
+            return singleton(matchValue.fields[0]);
+        case /* CompoundAction */ 3:
+            return matchValue.fields[0];
+        case /* ConditionalAction */ 4: {
+            const condition: ClinicalPathway_TransitionCondition_$union = matchValue.fields[0];
+            return append(singleton(matchValue.fields[1]), ofArray_1(toArray<ClinicalPathway_ActionInfo_$union>(matchValue.fields[2])));
+        }
+        default:
+            return empty<ClinicalPathway_ActionInfo_$union>();
+    }
+}
+
+/**
+ * Check if a state is terminal
+ */
+export function isTerminalState(state: ClinicalPathway_StateDefinition): boolean {
+    if (state.StateType.tag === /* Terminal */ 5) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+
+/**
+ * Evaluate all transitions from current states
+ */
+export function evaluateAllTransitions<FieldType>(context: ExecutionContext$1<FieldType>): FSharpList<MatchedTransition> {
+    const fieldValues: FSharpMap<Shared_FieldKey, string> = FieldResolver_extractFieldValues<FieldType>(context.FieldResolver, context.FormData);
+    console.log(some("[evaluateAllTransitions] Extracted field values:"), fieldValues);
+    console.log(some("[evaluateAllTransitions] Current states in context:"), context.CurrentStates);
+    console.log(some("[evaluateAllTransitions] All transitions in pathway:"), context.PathwaySpec.Transitions);
+    const transitionsFromCurrentStates: FSharpList<ClinicalPathway_TransitionDefinition> = filter<ClinicalPathway_TransitionDefinition>((t: ClinicalPathway_TransitionDefinition): boolean => {
+        const isFromCurrentState: boolean = contains<Shared_StateKey>(t.FromState, context.CurrentStates);
+        console.log(some("[evaluateAllTransitions] Transition from"), t.FromState, "to", t.ToState, "FromCurrentState=", isFromCurrentState);
+        return isFromCurrentState;
+    }, context.PathwaySpec.Transitions);
+    console.log(some("[evaluateAllTransitions] Transitions from current states:"), transitionsFromCurrentStates);
+    return map<ClinicalPathway_TransitionDefinition, MatchedTransition>((transition: ClinicalPathway_TransitionDefinition): MatchedTransition => {
+        console.log(some("[evaluateAllTransitions] Evaluating transition:"), transition.TransitionKey);
+        console.log(some("[evaluateAllTransitions] Transition condition:"), transition.Condition);
+        const status: TransitionStatus_$union = evaluateTransitionWithPartialData<FieldType>(context.FieldResolver, context.FormSpec, fieldValues, context.VisitedStates, transition.Condition);
+        console.log(some("[evaluateAllTransitions] Transition status:"), status);
+        return new MatchedTransition(transition, defaultArg(transition.Priority, 999), status);
+    }, transitionsFromCurrentStates);
+}
+
+/**
+ * Separate matched transitions into active, pending, and failed
+ */
+export function categorizeTransitions(transitions: FSharpList<MatchedTransition>): [FSharpList<MatchedTransition>, FSharpList<MatchedTransition>, FSharpList<MatchedTransition>] {
+    return [filter<MatchedTransition>((t: MatchedTransition): boolean => equals(t.Status, TransitionStatus_Satisfied()), transitions), filter<MatchedTransition>((t_1: MatchedTransition): boolean => {
+        if (t_1.Status.tag === /* Pending */ 2) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }, transitions), filter<MatchedTransition>((t_2: MatchedTransition): boolean => equals(t_2.Status, TransitionStatus_Failed()), transitions)] as [FSharpList<MatchedTransition>, FSharpList<MatchedTransition>, FSharpList<MatchedTransition>];
+}
+
+/**
+ * Apply execution mode strategy to select transitions
+ */
+export function selectTransitionsByMode(mode: ClinicalPathway_PathwayExecutionMode_$union, activeTransitions: FSharpList<MatchedTransition>): FSharpList<MatchedTransition> {
+    switch (mode.tag) {
+        case /* MultiPathway */ 1: {
+            const matchValue_1: ClinicalPathway_CombinationStrategy_$union = 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: ClinicalPathway_SelectionStrategy_$union = mode.fields[0].SelectionStrategy;
+            switch (matchValue.tag) {
+                case /* MostSpecific */ 1:
+                    return ofArray_1(toArray<MatchedTransition>(tryHead<MatchedTransition>(sortBy<MatchedTransition, int32>((m_1: MatchedTransition): int32 => m_1.Priority, activeTransitions, {
+                        Compare: comparePrimitives,
+                    }))));
+                case /* ClinicalSeverity */ 2:
+                    return ofArray_1(toArray<MatchedTransition>(tryHead<MatchedTransition>(sortBy<MatchedTransition, int32>((m_2: MatchedTransition): int32 => m_2.Priority, activeTransitions, {
+                        Compare: comparePrimitives,
+                    }))));
+                default:
+                    return ofArray_1(toArray<MatchedTransition>(tryHead<MatchedTransition>(sortBy<MatchedTransition, int32>((m: MatchedTransition): int32 => m.Priority, activeTransitions, {
+                        Compare: comparePrimitives,
+                    }))));
+            }
+        }
+    }
+}
+
+/**
+ * Calculate probability based on satisfied conditions and pending fields
+ */
+export function calculateProbability(status: TransitionStatus_$union, totalConditions: int32): float64 {
+    switch (status.tag) {
+        case /* Failed */ 1:
+            return 0;
+        case /* Pending */ 2:
+            return (totalConditions - length(status.fields[0])) / totalConditions;
+        default:
+            return 1;
+    }
+}
+
+/**
+ * Predict possible outcomes based on current form state
+ */
+export function predictOutcomes<FieldType>(context: ExecutionContext$1<FieldType>): FSharpList<PredictedPathway> {
+    return truncate<PredictedPathway>(5, sortByDescending<PredictedPathway, float64>((p: PredictedPathway): float64 => p.Probability, choose<MatchedTransition, PredictedPathway>((matched: MatchedTransition): Option<PredictedPathway> => {
+        const matchValue: TransitionStatus_$union = matched.Status;
+        switch (matchValue.tag) {
+            case /* Pending */ 2: {
+                const fields: FSharpList<string> = matchValue.fields[0];
+                const matchValue_2: Option<ClinicalPathway_StateDefinition> = findState(matched.Transition.ToState, context.PathwaySpec.States);
+                if (matchValue_2 == null) {
+                    return undefined;
+                }
+                else {
+                    const toStateStr_1: string = matched.Transition.ToState.fields[0];
+                    return new PredictedPathway(toStateStr_1, 0.5, fields, extractActionsFromState(value_3(matchValue_2)), toStateStr_1);
+                }
+            }
+            case /* Failed */ 1:
+                return undefined;
+            default: {
+                const matchValue_1: Option<ClinicalPathway_StateDefinition> = findState(matched.Transition.ToState, context.PathwaySpec.States);
+                if (matchValue_1 == null) {
+                    return undefined;
+                }
+                else {
+                    const toStateStr: string = matched.Transition.ToState.fields[0];
+                    return new PredictedPathway(toStateStr, 1, empty<string>(), extractActionsFromState(value_3(matchValue_1)), toStateStr);
+                }
+            }
+        }
+    }, evaluateAllTransitions<FieldType>(context)), {
+        Compare: comparePrimitives,
+    }));
+}
+
+/**
+ * Calculate completion percentage based on states visited and actions executed
+ */
+export function calculateCompletionPercentage<FieldType>(context: ExecutionContext$1<FieldType>): float64 {
+    const totalStates: float64 = length(context.PathwaySpec.States);
+    if (totalStates === 0) {
+        return 0;
+    }
+    else {
+        return (FSharpSet__get_Count(context.VisitedStates) / totalStates) * 100;
+    }
+}
+
+/**
+ * Check if pathway execution is complete
+ */
+export function isExecutionComplete<FieldType>(context: ExecutionContext$1<FieldType>): boolean {
+    if (exists<ClinicalPathway_StateDefinition>(isTerminalState, choose<Shared_StateKey, ClinicalPathway_StateDefinition>((sk: Shared_StateKey): Option<ClinicalPathway_StateDefinition> => findState(sk, context.PathwaySpec.States), toList<Shared_StateKey>(context.CurrentStates)))) {
+        return true;
+    }
+    else if (isEmpty(categorizeTransitions(context.ActiveTransitions)[0])) {
+        return !FSharpSet__get_IsEmpty(context.CurrentStates);
+    }
+    else {
+        return false;
+    }
+}
+
+/**
+ * Initialize execution context from scratch
+ */
+export function initializeExecution<FieldType>(formSpec: Spec_FormSpec$1<FieldType>, formData: Values_DynamicFormResultData$1<FieldType>): ExecutionContext$1<FieldType> {
+    const matchValue: Option<ClinicalPathway_ClinicalPathwaySpec> = formSpec.ClinicalPathway;
+    if (matchValue == null) {
+        throw new Error("No clinical pathway found in form spec");
+    }
+    else {
+        const pathway: ClinicalPathway_ClinicalPathwaySpec = value_3(matchValue);
+        const resolver: ((arg0: string) => Shared_FieldKey) = FieldResolver_createResolver<FieldType>(formSpec);
+        let initialStates: FSharpList<Shared_StateKey>;
+        const matchValue_1: Option<Shared_StateKey> = pathway.InitialState;
+        if (matchValue_1 == null) {
+            const statesWithIncoming: FSharpSet<Shared_StateKey> = ofList_1<Shared_StateKey>(map<ClinicalPathway_TransitionDefinition, Shared_StateKey>((t: ClinicalPathway_TransitionDefinition): Shared_StateKey => t.ToState, pathway.Transitions), {
+                Compare: compare,
+            });
+            const candidates: FSharpList<Shared_StateKey> = map<ClinicalPathway_StateDefinition, Shared_StateKey>((s_1: ClinicalPathway_StateDefinition): Shared_StateKey => s_1.StateKey, filter<ClinicalPathway_StateDefinition>((s: ClinicalPathway_StateDefinition): boolean => !contains<Shared_StateKey>(s.StateKey, statesWithIncoming), pathway.States));
+            initialStates = (isEmpty(candidates) ? defaultArg(map_4<ClinicalPathway_StateDefinition, FSharpList<Shared_StateKey>>((s_2: ClinicalPathway_StateDefinition): FSharpList<Shared_StateKey> => singleton(s_2.StateKey), tryHead<ClinicalPathway_StateDefinition>(pathway.States)), empty<Shared_StateKey>()) : candidates);
+        }
+        else {
+            initialStates = singleton(value_3(matchValue_1));
+        }
+        return new ExecutionContext$1(pathway, formSpec, ofList_1<Shared_StateKey>(initialStates, {
+            Compare: compare,
+        }), ofList_1<Shared_StateKey>(initialStates, {
+            Compare: compare,
+        }), empty_1<Shared_StateKey>({
+            Compare: compare,
+        }), empty<MatchedTransition>(), empty<MatchedTransition>(), empty<ClinicalPathway_ActionInfo_$union>(), formData, resolver, map<Shared_StateKey, ExecutionLogEntry>((stateKey: Shared_StateKey): ExecutionLogEntry => (new ExecutionLogEntry(now(), stateKey, "Initialized", "Starting state")), initialStates));
+    }
+}
+
+/**
+ * Resolve field value source to actual string value
+ */
+export function resolveFieldValueSource<FieldType>(valueSource: ClinicalPathway_FieldValueSource_$union, formSpec: Spec_FormSpec$1<FieldType>, formData: Values_DynamicFormResultData$1<FieldType>): string {
+    switch (valueSource.tag) {
+        case /* FieldReference */ 1:
+            return defaultArg(tryFind<Shared_FieldKey, string>(valueSource.fields[0], FieldResolver_extractFieldValues<FieldType>(FieldResolver_createResolver<FieldType>(formSpec), formData)), "");
+        case /* OptionKey */ 2: {
+            const optionKey: Shared_FieldOptionKey = valueSource.fields[0];
+            return defaultArg(tryPick<Spec_FormField$1<FieldType>, string>((field: Spec_FormField$1<FieldType>): Option<string> => {
+                const fieldType = field.FieldType as Spec_FieldType_$union;
+                return map_4<Shared_FieldOption, string>((opt_1: Shared_FieldOption): string => opt_1.Description, tryFind_1<Shared_FieldOption>((opt: Shared_FieldOption): boolean => 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 : empty<Shared_FieldOption>()))))));
+            }, collect<Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>>((step: Spec_FormStep$1<FieldType>): FSharpList<Spec_FormField$1<FieldType>> => step.Fields, formSpec.Steps)), "");
+        }
+        default:
+            return valueSource.fields[0];
+    }
+}
+
+/**
+ * Execute SetFieldValue action and update form data
+ */
+export function executeSetFieldValueAction<FieldType>(action: ClinicalPathway_SetFieldValueAction, formSpec: Spec_FormSpec$1<FieldType>, formData: Values_DynamicFormResultData$1<FieldType>): Values_DynamicFormResultData$1<FieldType> {
+    let matchValue: Option<ClinicalPathway_TransitionCondition_$union>, condition: ClinicalPathway_TransitionCondition_$union, fieldValues: FSharpMap<Shared_FieldKey, string>, fieldType: Spec_FieldType_$union;
+    if (!((matchValue = action.Condition, (matchValue == null) ? true : ((condition = value_3(matchValue), (fieldValues = FieldResolver_extractFieldValues<FieldType>(FieldResolver_createResolver<FieldType>(formSpec), formData), evaluateTransitionWithPartialData<FieldType>(FieldResolver_createResolver<FieldType>(formSpec), formSpec, fieldValues, empty_1<Shared_StateKey>({
+        Compare: compare,
+    }), condition).tag === /* Satisfied */ 0)))))) {
+        return formData;
+    }
+    else {
+        const valueToSet: string = resolveFieldValueSource<FieldType>(action.Value, formSpec, formData);
+        const targetFieldOpt: Option<Spec_FormField$1<FieldType>> = tryFind_1<Spec_FormField$1<FieldType>>((field: Spec_FormField$1<FieldType>): boolean => equals(field.FieldKey, action.TargetField), collect<Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>>((step: Spec_FormStep$1<FieldType>): FSharpList<Spec_FormField$1<FieldType>> => step.Fields, formSpec.Steps));
+        if (targetFieldOpt == null) {
+            return formData;
+        }
+        else {
+            const targetField: Spec_FormField$1<FieldType> = value_3(targetFieldOpt);
+            const stepOpt: Option<Spec_FormStep$1<FieldType>> = tryFind_1<Spec_FormStep$1<FieldType>>((step_1: Spec_FormStep$1<FieldType>): boolean => exists<Spec_FormField$1<FieldType>>((f: Spec_FormField$1<FieldType>): boolean => equals(f.FieldKey, action.TargetField), step_1.Fields), formSpec.Steps);
+            if (stepOpt == null) {
+                return formData;
+            }
+            else {
+                const stepOrder: Values_StepOrder = new Values_StepOrder(value_3(stepOpt).StepOrder);
+                const fieldAnswer: Shared_FieldAnswer = new Shared_FieldAnswer(action.TargetField, targetField.Label, valueToSet);
+                return new Values_DynamicFormResultData$1(formData.ResultFormSpecDetails, FSharpMap__Add(formData.ResultSteps, stepOrder, FSharpMap__Add(defaultArg(tryFind<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<FieldType>>>(stepOrder, formData.ResultSteps), empty_2<Shared_FieldKey, Values_FieldDetails$1<FieldType>>({
+                    Compare: compare,
+                })), action.TargetField, (fieldType = (targetField.FieldType as Spec_FieldType_$union), new Values_FieldDetails$1(targetField.FieldOrder, action.TargetField, targetField.Label, Shared_FieldValue_Single(fieldAnswer), targetField.FieldType, map<Shared_FieldOption, Shared_FieldOption>((opt: Shared_FieldOption): Shared_FieldOption => (new 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 : empty<Shared_FieldOption>()))))))))));
+            }
+        }
+    }
+}
+
+/**
+ * Execute an action and return updated form data
+ */
+export function executeAction<FieldType>(action: ClinicalPathway_ActionInfo_$union, formSpec: Spec_FormSpec$1<FieldType>, formData: Values_DynamicFormResultData$1<FieldType>): Values_DynamicFormResultData$1<FieldType> {
+    if (action.tag === /* SetFieldValue */ 10) {
+        return executeSetFieldValueAction<FieldType>(action.fields[0], formSpec, formData);
+    }
+    else {
+        return formData;
+    }
+}
+
+/**
+ * Execute all actions from a list and return updated form data
+ */
+export function executeActions<FieldType>(actions: FSharpList<ClinicalPathway_ActionInfo_$union>, formSpec: Spec_FormSpec$1<FieldType>, formData: Values_DynamicFormResultData$1<FieldType>): Values_DynamicFormResultData$1<FieldType> {
+    return fold<ClinicalPathway_ActionInfo_$union, Values_DynamicFormResultData$1<FieldType>>((currentData: Values_DynamicFormResultData$1<FieldType>, action: ClinicalPathway_ActionInfo_$union): Values_DynamicFormResultData$1<FieldType> => executeAction<FieldType>(action, formSpec, currentData), formData, actions);
+}
+
+/**
+ * Execute one step of the pathway (incremental execution)
+ */
+export function executeStep<FieldType>(context_mut: ExecutionContext$1<FieldType>, maxIterations_mut: int32): ExecutionContext$1<FieldType> {
+    executeStep:
+    while (true) {
+        const context: ExecutionContext$1<FieldType> = context_mut, maxIterations: int32 = maxIterations_mut;
+        if (maxIterations <= 0) {
+            return context;
+        }
+        else {
+            const patternInput: [FSharpList<MatchedTransition>, FSharpList<MatchedTransition>, FSharpList<MatchedTransition>] = categorizeTransitions(evaluateAllTransitions<FieldType>(context));
+            const pending: FSharpList<MatchedTransition> = patternInput[1];
+            const active: FSharpList<MatchedTransition> = patternInput[0];
+            const selectedTransitions: FSharpList<MatchedTransition> = selectTransitionsByMode(context.PathwaySpec.ExecutionMode, active);
+            if (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: FSharpSet<Shared_StateKey> = ofList_1<Shared_StateKey>(map<MatchedTransition, Shared_StateKey>((t: MatchedTransition): Shared_StateKey => t.Transition.ToState, selectedTransitions), {
+                    Compare: compare,
+                });
+                const newActions: FSharpList<ClinicalPathway_ActionInfo_$union> = collect<ClinicalPathway_StateDefinition, ClinicalPathway_ActionInfo_$union>(extractActionsFromState, choose<Shared_StateKey, ClinicalPathway_StateDefinition>((sk: Shared_StateKey): Option<ClinicalPathway_StateDefinition> => findState(sk, context.PathwaySpec.States), toList<Shared_StateKey>(newStates)));
+                const updatedFormData: Values_DynamicFormResultData$1<FieldType> = executeActions<FieldType>(newActions, context.FormSpec, context.FormData);
+                const newLogEntries: FSharpList<ExecutionLogEntry> = map<MatchedTransition, ExecutionLogEntry>((t_1: MatchedTransition): ExecutionLogEntry => {
+                    let arg: string, arg_1: string;
+                    return new ExecutionLogEntry(now(), t_1.Transition.ToState, "Transitioned", (arg = t_1.Transition.FromState.fields[0], (arg_1 = t_1.Transition.TransitionKey.fields[0], toText(printf("From %s via %s"))(arg)(arg_1))));
+                }, selectedTransitions);
+                const updatedContext: ExecutionContext$1<FieldType> = new ExecutionContext$1(context.PathwaySpec, context.FormSpec, newStates, union<Shared_StateKey>(context.VisitedStates, newStates), union<Shared_StateKey>(context.CompletedStates, context.CurrentStates), active, pending, append(context.ExecutedActions, newActions), updatedFormData, context.FieldResolver, append(context.ExecutionLog, newLogEntries));
+                if (isExecutionComplete<FieldType>(updatedContext)) {
+                    return updatedContext;
+                }
+                else {
+                    context_mut = updatedContext;
+                    maxIterations_mut = (maxIterations - 1);
+                    continue executeStep;
+                }
+            }
+        }
+        break;
+    }
+}
+
+/**
+ * Process incremental updates as form fills
+ */
+export function executeIncremental<FieldType>(context: ExecutionContext$1<FieldType>, formData: Values_DynamicFormResultData$1<FieldType>): IncrementalExecutionResult$1<FieldType> {
+    let previousTransitionKeys: FSharpSet<Shared_TransitionKey>, newKeys: FSharpSet<Shared_TransitionKey>;
+    const startingAtTerminal: boolean = exists<ClinicalPathway_StateDefinition>(isTerminalState, choose<Shared_StateKey, ClinicalPathway_StateDefinition>((sk: Shared_StateKey): Option<ClinicalPathway_StateDefinition> => findState(sk, context.PathwaySpec.States), toList<Shared_StateKey>(context.CurrentStates)));
+    const updatedContext: ExecutionContext$1<FieldType> = 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: ExecutionContext$1<FieldType> = executeStep<FieldType>(updatedContext, 100);
+    return new IncrementalExecutionResult$1(newContext, map<Shared_StateKey, string>((_arg: Shared_StateKey): string => _arg.fields[0], toList<Shared_StateKey>(difference<Shared_StateKey>(newContext.CurrentStates, updatedContext.CurrentStates))), (previousTransitionKeys = ofList_1<Shared_TransitionKey>(map<MatchedTransition, Shared_TransitionKey>((t: MatchedTransition): Shared_TransitionKey => t.Transition.TransitionKey, updatedContext.ActiveTransitions), {
+        Compare: compare,
+    }), (newKeys = difference<Shared_TransitionKey>(ofList_1<Shared_TransitionKey>(map<MatchedTransition, Shared_TransitionKey>((t_1: MatchedTransition): Shared_TransitionKey => t_1.Transition.TransitionKey, newContext.ActiveTransitions), {
+        Compare: compare,
+    }), previousTransitionKeys), map<MatchedTransition, ClinicalPathway_TransitionDefinition>((t_3: MatchedTransition): ClinicalPathway_TransitionDefinition => t_3.Transition, filter<MatchedTransition>((t_2: MatchedTransition): boolean => contains<Shared_TransitionKey>(t_2.Transition.TransitionKey, newKeys), newContext.ActiveTransitions)))), predictOutcomes<FieldType>(newContext), calculateCompletionPercentage<FieldType>(newContext), isExecutionComplete<FieldType>(newContext));
+}
+
+/**
+ * Get visualization state from execution context
+ */
+export function getVisualizationState<FieldType>(context: ExecutionContext$1<FieldType>): VisualizationState {
+    const patternInput: [FSharpList<MatchedTransition>, FSharpList<MatchedTransition>, FSharpList<MatchedTransition>] = categorizeTransitions(context.ActiveTransitions);
+    const completedTransitions: FSharpList<string> = map<ExecutionLogEntry, string>((log_1: ExecutionLogEntry): string => log_1.Details, filter<ExecutionLogEntry>((log: ExecutionLogEntry): boolean => (log.Action === "Transitioned"), context.ExecutionLog));
+    return new VisualizationState(context.CurrentStates, context.VisitedStates, map<MatchedTransition, Shared_TransitionKey>((t: MatchedTransition): Shared_TransitionKey => t.Transition.TransitionKey, patternInput[0]), map<MatchedTransition, Shared_TransitionKey>((t_1: MatchedTransition): Shared_TransitionKey => t_1.Transition.TransitionKey, patternInput[1]), completedTransitions, predictOutcomes<FieldType>(context));
+}
+
+/**
+ * Extract final clinical plans from execution context
+ */
+export function extractClinicalPlans<FieldType>(context: ExecutionContext$1<FieldType>): FSharpList<ClinicalPlan> {
+    return sortBy<ClinicalPlan, int32>((plan: ClinicalPlan): int32 => plan.Priority, choose<Shared_StateKey, ClinicalPlan>((stateKey: Shared_StateKey): Option<ClinicalPlan> => {
+        const matchValue: Option<ClinicalPathway_StateDefinition> = findState(stateKey, context.PathwaySpec.States);
+        let matchResult: int32, state_1: ClinicalPathway_StateDefinition;
+        if (matchValue != null) {
+            if (!isEmpty(extractActionsFromState(value_3(matchValue)))) {
+                matchResult = 0;
+                state_1 = value_3(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0: {
+                const stateKeyStr: string = stateKey.fields[0];
+                return new ClinicalPlan(stateKeyStr, extractActionsFromState(state_1!), stateKeyStr, state_1!.StateOrder);
+            }
+            default:
+                return undefined;
+        }
+    }, toList<Shared_StateKey>(context.CurrentStates)), {
+        Compare: comparePrimitives,
+    });
+}
+
+export class PathwayExecutionResult$1<FieldType> extends Record implements IEquatable<PathwayExecutionResult$1<FieldType>>, IComparable<PathwayExecutionResult$1<FieldType>> {
+    readonly PathwayId: string;
+    readonly StartState: string;
+    readonly CurrentState: string;
+    readonly ExecutionMode: ClinicalPathway_PathwayExecutionMode_$union;
+    readonly SelectedPaths: FSharpList<string>;
+    readonly RejectedPaths: FSharpList<[string, string]>;
+    readonly ExecutedActions: FSharpList<ClinicalPathway_ActionInfo_$union>;
+    readonly VisitedStates: FSharpList<string>;
+    readonly TransitionsUsed: FSharpList<string>;
+    readonly FormData: Values_DynamicFormResultData$1<FieldType>;
+    readonly ExecutionTime: Date;
+    readonly Success: boolean;
+    readonly Errors: FSharpList<string>;
+    constructor(PathwayId: string, StartState: string, CurrentState: string, ExecutionMode: ClinicalPathway_PathwayExecutionMode_$union, SelectedPaths: FSharpList<string>, RejectedPaths: FSharpList<[string, string]>, ExecutedActions: FSharpList<ClinicalPathway_ActionInfo_$union>, VisitedStates: FSharpList<string>, TransitionsUsed: FSharpList<string>, FormData: Values_DynamicFormResultData$1<FieldType>, ExecutionTime: Date, Success: boolean, Errors: FSharpList<string>) {
+        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;
+    }
+}
+
+export function PathwayExecutionResult$1_$reflection(gen0: TypeInfo): TypeInfo {
+    return record_type("F1.Studio.PathwayExecutor.PathwayExecutionResult`1", [gen0], PathwayExecutionResult$1, () => [["PathwayId", string_type], ["StartState", string_type], ["CurrentState", string_type], ["ExecutionMode", ClinicalPathway_PathwayExecutionMode_$reflection()], ["SelectedPaths", list_type(string_type)], ["RejectedPaths", list_type(tuple_type(string_type, string_type))], ["ExecutedActions", list_type(ClinicalPathway_ActionInfo_$reflection())], ["VisitedStates", list_type(string_type)], ["TransitionsUsed", list_type(string_type)], ["FormData", Values_DynamicFormResultData$1_$reflection(gen0)], ["ExecutionTime", class_type("System.DateTime")], ["Success", bool_type], ["Errors", list_type(string_type)]]);
+}
+
+//# sourceMappingURL=PathwayExecutor.ts.map