@f1studio/form-spec 5.0.0-alpha.102 → 5.0.0-alpha.104

package/src/PathwayExecutor.ts

@@ -1,20 +1,23 @@
 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 { fold, findIndex, tryPick, sortByDescending, truncate, length, sortBy, tryHead, filter as filter_1, ofArray as ofArray_1, append, empty, head, tail, concat, singleton, forAll, exists, collect, map, sumBy, sum, isEmpty, choose, tryFind, 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 { 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_FieldOptionKey, ClinicalPathway_TransitionCondition_$union, ClinicalPathway_LogicalOp_$union, ClinicalPathway_StateEvaluator_$union, Shared_FieldValue_Single, Shared_ConditionValue_$union, Shared_MatrixAnswer, ClinicalPathway_FieldEvaluator_$union, Shared_PluginDataProperty, Shared_PluginDataProperty_$reflection, Spec_Score, Spec_ScoreRange, Spec_FormStep$1, Spec_FormField$1, Shared_FieldValue_$union, Shared_MatrixItemKey, Shared_FieldAnswer, Shared_FieldOption, Spec_FieldType, Shared_TransitionKey_$reflection, Shared_TransitionKey, Shared_FieldKey_$reflection, ClinicalPathway_ActionInfo_$reflection, Spec_FormSpec$1_$reflection, Spec_FieldType_$reflection, ClinicalPathway_ClinicalPathwaySpec_$reflection, Shared_FieldKey, ClinicalPathway_ActionInfo_$union, Spec_FieldType_$union, Spec_FormSpec$1, ClinicalPathway_ClinicalPathwaySpec, Shared_StateKey_$reflection, Shared_StateKey, ClinicalPathway_TransitionDefinition_$reflection, ClinicalPathway_TransitionDefinition } from "./FormSpec.js";
+import { tryParse as tryParse_1, uint8, float64, int32 } from "@fable-org/fable-library-js/Int32.js";
+import { uncurry2, int32ToString, 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_1, toList, FSharpSet } from "@fable-org/fable-library-js/Set.js";
+import { toArray, filter, map as map_3, defaultArg, value as value_3, bind, Option } from "@fable-org/fable-library-js/Option.js";
+import { tryFind as tryFind_1, FSharpMap, ofList, toList as toList_1 } from "@fable-org/fable-library-js/Map.js";
+import { updateField, getFieldDetails, FieldDetails$1, fieldToDetails } from "./FormSpecValues.js";
+import { choose as choose_1, sum as sum_1, map as map_2, 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 { printf, toText, isNullOrEmpty, 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 { Auto_generateBoxedDecoder_Z6670B51, fromString } from "./fable_modules/Thoth.Json.10.4.1/Decode.fs.js";
+import { FSharpResult$2_$union } from "@fable-org/fable-library-js/Result.js";
+import { PluginValueRegistry_tryGet, IPluginValueConverter } from "./PluginInterface.js";
 import { now } from "@fable-org/fable-library-js/Date.js";
 
 export type TransitionStatus_$union = 
@@ -87,19 +90,18 @@ 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 {
+export class ExecutionContext extends Record {
     readonly PathwaySpec: ClinicalPathway_ClinicalPathwaySpec;
-    readonly FormSpec: Spec_FormSpec$1<FieldType>;
+    readonly FormSpec: Spec_FormSpec$1<Spec_FieldType_$union>;
     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>) {
+    constructor(PathwaySpec: ClinicalPathway_ClinicalPathwaySpec, FormSpec: Spec_FormSpec$1<Spec_FieldType_$union>, CurrentStates: FSharpSet<Shared_StateKey>, VisitedStates: FSharpSet<Shared_StateKey>, CompletedStates: FSharpSet<Shared_StateKey>, ActiveTransitions: FSharpList<MatchedTransition>, PendingTransitions: FSharpList<MatchedTransition>, ExecutedActions: FSharpList<ClinicalPathway_ActionInfo_$union>, FieldResolver: ((arg0: string) => Shared_FieldKey), ExecutionLog: FSharpList<ExecutionLogEntry>) {
         super();
         this.PathwaySpec = PathwaySpec;
         this.FormSpec = FormSpec;
@@ -109,14 +111,13 @@ export class ExecutionContext$1<FieldType> extends Record {
         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 function ExecutionContext_$reflection(): TypeInfo {
+    return record_type("F1.Studio.PathwayExecutor.ExecutionContext", [], ExecutionContext, () => [["PathwaySpec", ClinicalPathway_ClinicalPathwaySpec_$reflection()], ["FormSpec", Spec_FormSpec$1_$reflection(Spec_FieldType_$reflection())], ["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())], ["FieldResolver", lambda_type(string_type, Shared_FieldKey_$reflection())], ["ExecutionLog", list_type(ExecutionLogEntry_$reflection())]]);
 }
 
 export class PredictedPathway extends Record implements IEquatable<PredictedPathway>, IComparable<PredictedPathway> {
@@ -139,14 +140,14 @@ 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>;
+export class IncrementalExecutionResult extends Record {
+    readonly Context: ExecutionContext;
     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) {
+    constructor(Context: ExecutionContext, NewlyActivatedStates: FSharpList<string>, NewlyActiveTransitions: FSharpList<ClinicalPathway_TransitionDefinition>, PredictedOutcomes: FSharpList<PredictedPathway>, CompletionPercentage: float64, IsComplete: boolean) {
         super();
         this.Context = Context;
         this.NewlyActivatedStates = NewlyActivatedStates;
@@ -157,8 +158,8 @@ export class IncrementalExecutionResult$1<FieldType> extends Record {
     }
 }
 
-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 function IncrementalExecutionResult_$reflection(): TypeInfo {
+    return record_type("F1.Studio.PathwayExecutor.IncrementalExecutionResult", [], IncrementalExecutionResult, () => [["Context", ExecutionContext_$reflection()], ["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> {
@@ -201,6 +202,124 @@ 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())]]);
 }
 
+/**
+ * Extract options from a field type (single source of truth for scoring)
+ * This is THE ONLY place where we extract scoring information from fields
+ */
+export function ScoreCalculator_extractFieldOptions<FieldType>(fieldType: FieldType): Option<FSharpList<Shared_FieldOption>> {
+    const matchValue: any = fieldType;
+    if (matchValue instanceof Spec_FieldType) {
+        const ft = matchValue as Spec_FieldType_$union;
+        switch (ft.tag) {
+            case /* Radio */ 12:
+                return ft.fields[0].Options;
+            case /* SingleChoice */ 13:
+                return ft.fields[0].Options;
+            case /* Dropdown */ 14:
+                return ft.fields[0].Options;
+            case /* TextAutoComplete */ 18:
+                return ft.fields[0].Options;
+            case /* MultiChoice */ 15:
+                return ft.fields[0].Options;
+            case /* CheckboxList */ 16:
+                return ft.fields[0].Options;
+            case /* TagList */ 17:
+                return ft.fields[0].Options;
+            case /* Matrix */ 19:
+                return ft.fields[0].Options;
+            default:
+                return undefined;
+        }
+    }
+    else {
+        return undefined;
+    }
+}
+
+/**
+ * Calculate score for a field value given its options
+ */
+export function ScoreCalculator_calculateFieldValueScore(options: FSharpList<Shared_FieldOption>, fieldValue: Shared_FieldValue_$union): Option<int32> {
+    switch (fieldValue.tag) {
+        case /* Single */ 0: {
+            const answer: Shared_FieldAnswer = fieldValue.fields[0];
+            return bind<Shared_FieldOption, int32>((opt_1: Shared_FieldOption): Option<int32> => opt_1.Score, tryFind<Shared_FieldOption>((opt: Shared_FieldOption): boolean => (opt.Value === answer.Value), options));
+        }
+        case /* Multiple */ 1: {
+            const _arg: FSharpList<int32> = choose<Shared_FieldAnswer, int32>((answer_1: Shared_FieldAnswer): Option<int32> => bind<Shared_FieldOption, int32>((opt_3: Shared_FieldOption): Option<int32> => opt_3.Score, tryFind<Shared_FieldOption>((opt_2: Shared_FieldOption): boolean => (opt_2.Value === answer_1.Value), options)), toList<Shared_FieldAnswer>(fieldValue.fields[0]));
+            if (isEmpty(_arg)) {
+                return undefined;
+            }
+            else {
+                return sum<int32>(_arg, {
+                    GetZero: (): int32 => 0,
+                    Add: (x: int32, y: int32): int32 => (x + y),
+                });
+            }
+        }
+        case /* Matrix */ 2: {
+            const _arg_2: FSharpList<int32> = choose<[Shared_MatrixItemKey, string], int32>((tupledArg: [Shared_MatrixItemKey, string]): Option<int32> => bind<Shared_FieldOption, int32>((opt_5: Shared_FieldOption): Option<int32> => opt_5.Score, tryFind<Shared_FieldOption>((opt_4: Shared_FieldOption): boolean => (opt_4.Value === tupledArg[1]), options)), toList_1<Shared_MatrixItemKey, string>(fieldValue.fields[0].Values));
+            if (isEmpty(_arg_2)) {
+                return undefined;
+            }
+            else {
+                return sum<int32>(_arg_2, {
+                    GetZero: (): int32 => 0,
+                    Add: (x_1: int32, y_1: int32): int32 => (x_1 + y_1),
+                });
+            }
+        }
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Calculate score for a single field
+ */
+export function ScoreCalculator_calculateFieldScore<FieldType>(field: Spec_FormField$1<FieldType>, fieldValue: Shared_FieldValue_$union): Option<int32> {
+    return bind<FSharpList<Shared_FieldOption>, int32>((options: FSharpList<Shared_FieldOption>): Option<int32> => ScoreCalculator_calculateFieldValueScore(options, fieldValue), ScoreCalculator_extractFieldOptions<FieldType>(field.FieldType));
+}
+
+/**
+ * Calculate total score for a form step (reads from FormSpec step fields)
+ */
+export function ScoreCalculator_calculateStepScore(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>, step: Spec_FormStep$1<Spec_FieldType_$union>): int32 {
+    return sum<int32>(choose<Spec_FormField$1<Spec_FieldType_$union>, int32>((field: Spec_FormField$1<Spec_FieldType_$union>): Option<int32> => ScoreCalculator_calculateFieldScore<Spec_FieldType_$union>(field, fieldToDetails(field).FieldValue), step.Fields), {
+        GetZero: (): int32 => 0,
+        Add: (x: int32, y: int32): int32 => (x + y),
+    });
+}
+
+/**
+ * Calculate total score for entire form (reads from FormSpec)
+ */
+export function ScoreCalculator_calculateTotalScore(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): int32 {
+    return sumBy<Spec_FormStep$1<Spec_FieldType_$union>, int32>((step: Spec_FormStep$1<Spec_FieldType_$union>): int32 => ScoreCalculator_calculateStepScore(formSpec, step), formSpec.Steps, {
+        GetZero: (): int32 => 0,
+        Add: (x: int32, y: int32): int32 => (x + y),
+    });
+}
+
+/**
+ * Get score range for a given score value
+ */
+export function ScoreCalculator_getScoreRange(score: Option<Spec_Score>, value: int32): Option<Spec_ScoreRange> {
+    if (score != null) {
+        return tryFind<Spec_ScoreRange>((range: Spec_ScoreRange): boolean => {
+            if (value >= range.Min) {
+                return value <= range.Max;
+            }
+            else {
+                return false;
+            }
+        }, value_3(score).ScoreRanges);
+    }
+    else {
+        return undefined;
+    }
+}
+
 /**
  * Generate deterministic GUID from field label
  */
@@ -233,26 +352,26 @@ export function FieldResolver_generateFieldKey(fieldName: string): Shared_FieldK
 /**
  * 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)), {
+export function FieldResolver_createResolver(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): ((arg0: string) => Shared_FieldKey) {
+    const labelToFieldKey: FSharpMap<string, Shared_FieldKey> = ofList<string, Shared_FieldKey>(map<Spec_FormField$1<Spec_FieldType_$union>, [string, Shared_FieldKey]>((field: Spec_FormField$1<Spec_FieldType_$union>): [string, Shared_FieldKey] => ([field.Label.toLocaleLowerCase().trim(), field.FieldKey] as [string, Shared_FieldKey]), collect<Spec_FormStep$1<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>>((step: Spec_FormStep$1<Spec_FieldType_$union>): FSharpList<Spec_FormField$1<Spec_FieldType_$union>> => step.Fields, formSpec.Steps)), {
         Compare: comparePrimitives,
     });
     return (fieldReference: string): Shared_FieldKey => {
-        const matchValue: Option<Shared_FieldKey> = tryFind<string, Shared_FieldKey>(fieldReference.toLocaleLowerCase().trim(), labelToFieldKey);
+        const matchValue: Option<Shared_FieldKey> = tryFind_1<string, Shared_FieldKey>(fieldReference.toLocaleLowerCase().trim(), labelToFieldKey);
         return (matchValue == null) ? FieldResolver_generateFieldKey(fieldReference) : value_3(matchValue);
     };
 }
 
 /**
- * Extract field values from form data using resolver
+ * Extract field values from form spec (reads from FormSpec)
  */
-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] => {
+export function FieldResolver_extractFieldValues(resolver: ((arg0: string) => Shared_FieldKey), formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): FSharpMap<Shared_FieldKey, string> {
+    return ofList<Shared_FieldKey, string>(collect<Spec_FormStep$1<Spec_FieldType_$union>, [Shared_FieldKey, string]>((step: Spec_FormStep$1<Spec_FieldType_$union>): FSharpList<[Shared_FieldKey, string]> => map<Spec_FormField$1<Spec_FieldType_$union>, [Shared_FieldKey, string]>((field: Spec_FormField$1<Spec_FieldType_$union>): [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], {
+        return [field.FieldKey, (matchValue = fieldToDetails(field).FieldValue, (matchValue.tag === /* Multiple */ 1) ? join(",", toList<string>(map_1<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)), {
+        }))) : ((matchValue.tag === /* Matrix */ 2) ? join(",", map<[Shared_MatrixItemKey, string], string>((tupledArg: [Shared_MatrixItemKey, string]): string => tupledArg[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];
+    }, step.Fields), formSpec.Steps), {
         Compare: compare,
     });
 }
@@ -407,7 +526,7 @@ export function evaluateFieldCondition(actualValue: string, evaluator: ClinicalP
             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 => {
+            matchValue_12 = ([tryParse(actualValue.trim(), new FSharpRef<float64>((): float64 => outArg_8, (v_8: float64): void => {
                 outArg_8 = v_8;
             })), outArg_8] as [boolean, float64]);
             if (matchValue_12[0]) {
@@ -429,7 +548,7 @@ export function evaluateFieldCondition(actualValue: string, evaluator: ClinicalP
             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(",")), {
+            const actualParts: FSharpSet<string> = ofArray<string>(map_2<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), {
@@ -441,38 +560,175 @@ export function evaluateFieldCondition(actualValue: string, evaluator: ClinicalP
     }
 }
 
+/**
+ * Evaluate Matrix condition: check specific item(s) in the matrix (e.g. PHQ-9 item 9 = suicidal ideation)
+ * ConditionValue.Matrix [[itemKey, expectedVal]] means "item should have this value"
+ * For NotEquals: trigger when item value ≠ expected (e.g. item 9 ≠ "0" → suicidal ideation endorsed)
+ */
+export function evaluateMatrixItemCondition(actualMatrix: Shared_MatrixAnswer, evaluator: ClinicalPathway_FieldEvaluator_$union, expectedMatrix: FSharpMap<Shared_MatrixItemKey, string>): boolean {
+    const entries: FSharpList<[Shared_MatrixItemKey, string]> = toList_1<Shared_MatrixItemKey, string>(expectedMatrix);
+    if (isEmpty(entries)) {
+        return false;
+    }
+    else {
+        const allMatch: boolean = forAll<[Shared_MatrixItemKey, string]>((tupledArg: [Shared_MatrixItemKey, string]): boolean => {
+            const expectedVal: string = tupledArg[1];
+            const actualVal: string = defaultArg(tryFind_1<Shared_MatrixItemKey, string>(tupledArg[0], actualMatrix.Values), "0");
+            switch (evaluator.tag) {
+                case /* Equals */ 0:
+                    return actualVal.trim().toLocaleLowerCase() === expectedVal.trim().toLocaleLowerCase();
+                case /* NotEquals */ 1:
+                    return actualVal.trim().toLocaleLowerCase() !== expectedVal.trim().toLocaleLowerCase();
+                default:
+                    return evaluateFieldCondition(actualVal, evaluator, expectedVal);
+            }
+        }, entries);
+        switch (evaluator.tag) {
+            case /* Equals */ 0:
+                return allMatch;
+            case /* NotEquals */ 1:
+                return allMatch;
+            default:
+                return allMatch;
+        }
+    }
+}
+
 /**
  * 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])));
+    let matchResult: int32, actualMatrix: Shared_MatrixAnswer, expectedMatrix: FSharpMap<Shared_MatrixItemKey, string>;
+    if (actualFieldValue.tag === /* Matrix */ 2) {
+        if (expectedConditionValue.tag === /* Matrix */ 2) {
+            matchResult = 0;
+            actualMatrix = actualFieldValue.fields[0];
+            expectedMatrix = expectedConditionValue.fields[0];
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return evaluateMatrixItemCondition(actualMatrix!, evaluator, expectedMatrix!);
+        default:
+            return evaluateFieldCondition((actualFieldValue.tag === /* Multiple */ 1) ? join(",", toList<string>(map_1<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;
+export function evaluateTransitionWithPartialData(resolver: ((arg0: string) => Shared_FieldKey), formSpec: Option<Spec_FormSpec$1<Spec_FieldType_$union>>, fieldValues: FSharpMap<Shared_FieldKey, string>, visitedStates: FSharpSet<Shared_StateKey>, formSpecForScores: Option<Spec_FormSpec$1<Spec_FieldType_$union>>, condition: ClinicalPathway_TransitionCondition_$union): TransitionStatus_$union {
+    let score: int32, data_1: Spec_FormSpec$1<Spec_FieldType_$union>, score_2: int32, pluginData: 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]));
+            if (evaluator.tag === /* InRange */ 13) {
+                const minVal: int32 = evaluator.fields[0] | 0;
+                const maxVal: int32 = evaluator.fields[1] | 0;
+                let matchResult: int32, data: Spec_FormSpec$1<Spec_FieldType_$union>, spec: Spec_FormSpec$1<Spec_FieldType_$union>;
+                if (formSpec != null) {
+                    if (formSpecForScores != null) {
+                        matchResult = 0;
+                        data = value_3(formSpecForScores);
+                        spec = value_3(formSpec);
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+                switch (matchResult) {
+                    case 0: {
+                        const fieldScoreOpt: Option<int32> = bind<Spec_FormField$1<Spec_FieldType_$union>, int32>((field_1: Spec_FormField$1<Spec_FieldType_$union>): Option<int32> => bind<FieldDetails$1<Spec_FieldType_$union>, int32>((details: FieldDetails$1<Spec_FieldType_$union>): Option<int32> => ScoreCalculator_calculateFieldScore<Spec_FieldType_$union>(field_1, details.FieldValue), getFieldDetails(data!, fieldKey)), tryFind<Spec_FormField$1<Spec_FieldType_$union>>((field: Spec_FormField$1<Spec_FieldType_$union>): boolean => equals(field.FieldKey, fieldKey), collect<Spec_FormStep$1<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>>((step: Spec_FormStep$1<Spec_FieldType_$union>): FSharpList<Spec_FormField$1<Spec_FieldType_$union>> => step.Fields, spec!.Steps)));
+                        if (fieldScoreOpt == null) {
+                            return TransitionStatus_Pending(singleton(fieldKey.fields[0]));
+                        }
+                        else if ((score = (value_3(fieldScoreOpt) | 0), (score >= minVal) && (score <= maxVal))) {
+                            const score_1: int32 = value_3(fieldScoreOpt) | 0;
+                            return TransitionStatus_Satisfied();
+                        }
+                        else {
+                            return TransitionStatus_Failed();
+                        }
+                    }
+                    default:
+                        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 {
+                const actualFieldValueOpt: Option<Shared_FieldValue_$union> = (conditionValue.tag === /* Matrix */ 2) ? ((formSpecForScores != null) ? ((data_1 = value_3(formSpecForScores), map_3<FieldDetails$1<Spec_FieldType_$union>, Shared_FieldValue_$union>((details_1: FieldDetails$1<Spec_FieldType_$union>): Shared_FieldValue_$union => details_1.FieldValue, getFieldDetails(data_1, fieldKey)))) : undefined) : undefined;
+                if (actualFieldValueOpt == null) {
+                    const matchValue_2: Option<string> = tryFind_1<Shared_FieldKey, string>(fieldKey, fieldValues);
+                    if (matchValue_2 == null) {
+                        return TransitionStatus_Pending(singleton(fieldKey.fields[0]));
+                    }
+                    else if (evaluateFieldConditionWithConditionValue(Shared_FieldValue_Single(new Shared_FieldAnswer(fieldKey, "", value_3(matchValue_2))), evaluator, conditionValue)) {
+                        return TransitionStatus_Satisfied();
+                    }
+                    else {
+                        return TransitionStatus_Failed();
+                    }
+                }
+                else if (evaluateFieldConditionWithConditionValue(value_3(actualFieldValueOpt), evaluator, conditionValue)) {
+                    return TransitionStatus_Satisfied();
+                }
+                else {
+                    return TransitionStatus_Failed();
+                }
+            }
+        }
+        case /* ScoreInRange */ 3: {
+            const minScore: int32 = condition.fields[0] | 0;
+            const maxScore: int32 = condition.fields[1] | 0;
+            if (formSpecForScores != null) {
+                const totalScore: int32 = ScoreCalculator_calculateTotalScore(value_3(formSpecForScores)) | 0;
+                if ((totalScore >= minScore) && (totalScore <= maxScore)) {
+                    return TransitionStatus_Satisfied();
+                }
+                else {
+                    return TransitionStatus_Failed();
+                }
             }
             else {
-                return TransitionStatus_Failed();
+                return TransitionStatus_Pending(singleton("form_score"));
+            }
+        }
+        case /* FieldScoreInRange */ 4: {
+            const minScore_1: int32 = condition.fields[1] | 0;
+            const maxScore_1: int32 = condition.fields[2] | 0;
+            const fieldKey_1: Shared_FieldKey = condition.fields[0];
+            if (formSpecForScores != null) {
+                const spec_2: Spec_FormSpec$1<Spec_FieldType_$union> = value_3(formSpecForScores);
+                const fieldScoreOpt_1: Option<int32> = bind<Spec_FormField$1<Spec_FieldType_$union>, int32>((field_3: Spec_FormField$1<Spec_FieldType_$union>): Option<int32> => bind<FieldDetails$1<Spec_FieldType_$union>, int32>((details_2: FieldDetails$1<Spec_FieldType_$union>): Option<int32> => ScoreCalculator_calculateFieldScore<Spec_FieldType_$union>(field_3, details_2.FieldValue), getFieldDetails(spec_2, fieldKey_1)), tryFind<Spec_FormField$1<Spec_FieldType_$union>>((field_2: Spec_FormField$1<Spec_FieldType_$union>): boolean => equals(field_2.FieldKey, fieldKey_1), collect<Spec_FormStep$1<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>>((step_1: Spec_FormStep$1<Spec_FieldType_$union>): FSharpList<Spec_FormField$1<Spec_FieldType_$union>> => step_1.Fields, spec_2.Steps)));
+                if (fieldScoreOpt_1 == null) {
+                    return TransitionStatus_Pending(singleton(fieldKey_1.fields[0]));
+                }
+                else if ((score_2 = (value_3(fieldScoreOpt_1) | 0), (score_2 >= minScore_1) && (score_2 <= maxScore_1))) {
+                    const score_3: int32 = value_3(fieldScoreOpt_1) | 0;
+                    return TransitionStatus_Satisfied();
+                }
+                else {
+                    return TransitionStatus_Failed();
+                }
+            }
+            else {
+                return TransitionStatus_Pending(singleton(fieldKey_1.fields[0]));
             }
         }
-        case /* StateCondition */ 3: {
+        case /* StateCondition */ 5: {
             const evaluator_1: ClinicalPathway_StateEvaluator_$union = condition.fields[1];
             const stateVisited: boolean = contains<Shared_StateKey>(condition.fields[0], visitedStates);
             switch (evaluator_1.tag) {
@@ -501,12 +757,12 @@ export function evaluateTransitionWithPartialData<FieldType>(resolver: ((arg0: s
                     }
             }
         }
-        case /* CompositeCondition */ 4: {
+        case /* CompositeCondition */ 6: {
             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);
+                    const results_1: FSharpList<TransitionStatus_$union> = map<ClinicalPathway_TransitionCondition_$union, TransitionStatus_$union>((condition_2: ClinicalPathway_TransitionCondition_$union): TransitionStatus_$union => evaluateTransitionWithPartialData(resolver, formSpec, fieldValues, visitedStates, formSpecForScores, condition_2), conditions);
                     if (exists<TransitionStatus_$union>((r_3: TransitionStatus_$union): boolean => equals(r_3, TransitionStatus_Satisfied()), results_1)) {
                         return TransitionStatus_Satisfied();
                     }
@@ -525,27 +781,27 @@ export function evaluateTransitionWithPartialData<FieldType>(resolver: ((arg0: s
                     }
                 }
                 case /* Not */ 2: {
-                    let matchResult: int32, cond: ClinicalPathway_TransitionCondition_$union;
+                    let matchResult_1: int32, cond: ClinicalPathway_TransitionCondition_$union;
                     if (!isEmpty(conditions)) {
                         if (isEmpty(tail(conditions))) {
-                            matchResult = 0;
+                            matchResult_1 = 0;
                             cond = head(conditions);
                         }
                         else {
-                            matchResult = 1;
+                            matchResult_1 = 1;
                         }
                     }
                     else {
-                        matchResult = 1;
+                        matchResult_1 = 1;
                     }
-                    switch (matchResult) {
+                    switch (matchResult_1) {
                         case 0: {
-                            const matchValue_1: TransitionStatus_$union = evaluateTransitionWithPartialData<FieldType>(resolver, formSpec, fieldValues, visitedStates, cond!);
-                            switch (matchValue_1.tag) {
+                            const matchValue_3: TransitionStatus_$union = evaluateTransitionWithPartialData(resolver, formSpec, fieldValues, visitedStates, formSpecForScores, cond!);
+                            switch (matchValue_3.tag) {
                                 case /* Failed */ 1:
                                     return TransitionStatus_Satisfied();
                                 case /* Pending */ 2:
-                                    return TransitionStatus_Pending(matchValue_1.fields[0]);
+                                    return TransitionStatus_Pending(matchValue_3.fields[0]);
                                 default:
                                     return TransitionStatus_Failed();
                             }
@@ -555,7 +811,7 @@ export function evaluateTransitionWithPartialData<FieldType>(resolver: ((arg0: s
                     }
                 }
                 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);
+                    const results: FSharpList<TransitionStatus_$union> = map<ClinicalPathway_TransitionCondition_$union, TransitionStatus_$union>((condition_1: ClinicalPathway_TransitionCondition_$union): TransitionStatus_$union => evaluateTransitionWithPartialData(resolver, formSpec, fieldValues, visitedStates, formSpecForScores, condition_1), conditions);
                     if (exists<TransitionStatus_$union>((r: TransitionStatus_$union): boolean => equals(r, TransitionStatus_Failed()), results)) {
                         return TransitionStatus_Failed();
                     }
@@ -575,33 +831,31 @@ export function evaluateTransitionWithPartialData<FieldType>(resolver: ((arg0: s
                 }
             }
         }
-        case /* TestResultCondition */ 5: {
+        case /* TestResultCondition */ 7: {
             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 fieldKey_2: 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);
+            const optionValueOpt: Option<string> = (formSpec == null) ? undefined : bind<Spec_FormField$1<Spec_FieldType_$union>, string>((field_5: Spec_FormField$1<Spec_FieldType_$union>): Option<string> => {
+                const fieldType = field_5.FieldType as Spec_FieldType_$union;
+                return map_3<Shared_FieldOption, string>((opt_1: Shared_FieldOption): string => opt_1.Value, tryFind<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<Spec_FormField$1<Spec_FieldType_$union>>((field_4: Spec_FormField$1<Spec_FieldType_$union>): boolean => equals(field_4.FieldKey, fieldKey_2), collect<Spec_FormStep$1<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>>((step_2: Spec_FormStep$1<Spec_FieldType_$union>): FSharpList<Spec_FormField$1<Spec_FieldType_$union>> => step_2.Fields, value_3(formSpec).Steps)));
+            const matchValue_4: Option<string> = tryFind_1<Shared_FieldKey, string>(fieldKey_2, 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 if (matchValue_4 == null) {
+                return TransitionStatus_Pending(singleton(fieldKey_2.fields[0]));
             }
             else {
-                const actualValueStr_1: string = value_3(matchValue_2);
+                const actualValueStr_1: string = value_3(matchValue_4);
                 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(",")), {
+                const actualValues: FSharpSet<string> = ofArray<string>(map_2<string, string>((s: string): string => s.trim().toLocaleLowerCase(), actualValueStr_1.split(",")), {
                     Compare: comparePrimitives,
                 });
                 const containsOption: boolean = contains<string>(optionValue.trim().toLocaleLowerCase(), actualValues);
@@ -646,18 +900,56 @@ export function evaluateTransitionWithPartialData<FieldType>(resolver: ((arg0: s
         }
         case /* PluginPropertyCondition */ 2: {
             const propertyKey: Shared_PluginPropertyKey = condition.fields[1];
-            const fieldKey_2: Shared_FieldKey = condition.fields[0];
+            const fieldKey_3: 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]));
+            const matchValue_6: Option<string> = tryFind_1<Shared_FieldKey, string>(fieldKey_3, fieldValues);
+            if (matchValue_6 == null) {
+                return TransitionStatus_Pending(singleton(fieldKey_3.fields[0]));
             }
             else {
-                const actualValueStr_2: string = value_3(matchValue_4);
+                const actualValueStr_2: string = value_3(matchValue_6);
                 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();
+                    const pluginIdOpt: Option<string> = filter<string>((id: string): boolean => !isNullOrEmpty(id), bind<Spec_FormSpec$1<Spec_FieldType_$union>, string>((spec_4: Spec_FormSpec$1<Spec_FieldType_$union>): Option<string> => map_3<Spec_FormField$1<Spec_FieldType_$union>, string>((f_1: Spec_FormField$1<Spec_FieldType_$union>): string => {
+                        const ft = f_1.FieldType as Spec_FieldType_$union;
+                        switch (ft.tag) {
+                            case /* PluginField */ 22:
+                                return ft.fields[0].PluginId;
+                            case /* Matrix */ 19:
+                                return "Fable.Form.Simple.Bulma.Fields.LikertField";
+                            default:
+                                return "";
+                        }
+                    }, tryFind<Spec_FormField$1<Spec_FieldType_$union>>((f: Spec_FormField$1<Spec_FieldType_$union>): boolean => equals(f.FieldKey, fieldKey_3), collect<Spec_FormStep$1<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>>((s_1: Spec_FormStep$1<Spec_FieldType_$union>): FSharpList<Spec_FormField$1<Spec_FieldType_$union>> => s_1.Fields, spec_4.Steps))), formSpec));
+                    return evaluateFieldCondition((pluginIdOpt == null) ? actualValueStr_2 : defaultArg(bind<IPluginValueConverter, string>((converter: IPluginValueConverter): Option<string> => map_3<Shared_PluginDataProperty, string>((propMeta: Shared_PluginDataProperty): string => {
+                        if (propMeta.Name === "TotalScore") {
+                            return int32ToString(sum_1<int32>(choose_1<string, int32>((s_2: string): Option<int32> => {
+                                let matchValue_7: [boolean, int32];
+                                let outArg = 0;
+                                matchValue_7 = ([tryParse_1(s_2.trim(), 511, false, 32, new FSharpRef<int32>((): int32 => outArg, (v_2: int32): void => {
+                                    outArg = (v_2 | 0);
+                                })), outArg] as [boolean, int32]);
+                                if (matchValue_7[0]) {
+                                    return matchValue_7[1];
+                                }
+                                else {
+                                    return undefined;
+                                }
+                            }, actualValueStr_2.split(",")), {
+                                GetZero: (): int32 => 0,
+                                Add: (x_1: int32, y_1: int32): int32 => (x_1 + y_1),
+                            }));
+                        }
+                        else {
+                            const matchValue_8: FSharpResult$2_$union<FSharpList<Shared_PluginDataProperty>, string> = fromString<FSharpList<Shared_PluginDataProperty>>(uncurry2(Auto_generateBoxedDecoder_Z6670B51(list_type(Shared_PluginDataProperty_$reflection()), undefined, undefined)), actualValueStr_2);
+                            if (matchValue_8.tag === /* Error */ 1) {
+                                return actualValueStr_2;
+                            }
+                            else {
+                                return defaultArg(map_3<Shared_PluginDataProperty, string>((p_1: Shared_PluginDataProperty): string => p_1.Value, tryFind<Shared_PluginDataProperty>((p: Shared_PluginDataProperty): boolean => equals(p.PropertyKey, propertyKey), matchValue_8.fields[0])), actualValueStr_2);
+                            }
+                        }
+                    }, converter.GetPropertyMetadataByKey(propertyKey)), PluginValueRegistry_tryGet(value_3(pluginIdOpt))), 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) ? "" : conditionValue_2.fields[0]))) ? TransitionStatus_Satisfied() : TransitionStatus_Failed();
                 }
                 catch (ex: any) {
                     return TransitionStatus_Failed();
@@ -673,7 +965,7 @@ export function evaluateTransitionWithPartialData<FieldType>(resolver: ((arg0: s
  * 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);
+    return tryFind<ClinicalPathway_StateDefinition>((s: ClinicalPathway_StateDefinition): boolean => equals(s.StateKey, stateKey), states);
 }
 
 /**
@@ -710,38 +1002,26 @@ export function isTerminalState(state: ClinicalPathway_StateDefinition): boolean
 /**
  * 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);
+export function evaluateAllTransitions<FieldType>(context: ExecutionContext): FSharpList<MatchedTransition> {
+    const fieldValues: FSharpMap<Shared_FieldKey, string> = FieldResolver_extractFieldValues(context.FieldResolver, context.FormSpec);
     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);
+        const status: TransitionStatus_$union = evaluateTransitionWithPartialData(context.FieldResolver, context.FormSpec, fieldValues, context.VisitedStates, context.FormSpec, transition.Condition);
         return new MatchedTransition(transition, defaultArg(transition.Priority, 999), status);
-    }, transitionsFromCurrentStates);
+    }, filter_1<ClinicalPathway_TransitionDefinition>((t: ClinicalPathway_TransitionDefinition): boolean => contains<Shared_StateKey>(t.FromState, context.CurrentStates), context.PathwaySpec.Transitions));
 }
 
 /**
  * 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 => {
+    return [filter_1<MatchedTransition>((t: MatchedTransition): boolean => equals(t.Status, TransitionStatus_Satisfied()), transitions), filter_1<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>];
+    }, transitions), filter_1<MatchedTransition>((t_2: MatchedTransition): boolean => equals(t_2.Status, TransitionStatus_Failed()), transitions)] as [FSharpList<MatchedTransition>, FSharpList<MatchedTransition>, FSharpList<MatchedTransition>];
 }
 
 /**
@@ -799,7 +1079,7 @@ export function calculateProbability(status: TransitionStatus_$union, totalCondi
 /**
  * Predict possible outcomes based on current form state
  */
-export function predictOutcomes<FieldType>(context: ExecutionContext$1<FieldType>): FSharpList<PredictedPathway> {
+export function predictOutcomes(context: ExecutionContext): 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) {
@@ -827,7 +1107,7 @@ export function predictOutcomes<FieldType>(context: ExecutionContext$1<FieldType
                 }
             }
         }
-    }, evaluateAllTransitions<FieldType>(context)), {
+    }, evaluateAllTransitions<any>(context)), {
         Compare: comparePrimitives,
     }));
 }
@@ -835,7 +1115,7 @@ export function predictOutcomes<FieldType>(context: ExecutionContext$1<FieldType
 /**
  * Calculate completion percentage based on states visited and actions executed
  */
-export function calculateCompletionPercentage<FieldType>(context: ExecutionContext$1<FieldType>): float64 {
+export function calculateCompletionPercentage(context: ExecutionContext): float64 {
     const totalStates: float64 = length(context.PathwaySpec.States);
     if (totalStates === 0) {
         return 0;
@@ -848,7 +1128,7 @@ export function calculateCompletionPercentage<FieldType>(context: ExecutionConte
 /**
  * Check if pathway execution is complete
  */
-export function isExecutionComplete<FieldType>(context: ExecutionContext$1<FieldType>): boolean {
+export function isExecutionComplete(context: ExecutionContext): 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;
     }
@@ -863,49 +1143,49 @@ export function isExecutionComplete<FieldType>(context: ExecutionContext$1<Field
 /**
  * Initialize execution context from scratch
  */
-export function initializeExecution<FieldType>(formSpec: Spec_FormSpec$1<FieldType>, formData: Values_DynamicFormResultData$1<FieldType>): ExecutionContext$1<FieldType> {
+export function initializeExecution(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): ExecutionContext {
     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);
+        const resolver: ((arg0: string) => Shared_FieldKey) = FieldResolver_createResolver(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);
+            const candidates: FSharpList<Shared_StateKey> = map<ClinicalPathway_StateDefinition, Shared_StateKey>((s_1: ClinicalPathway_StateDefinition): Shared_StateKey => s_1.StateKey, filter_1<ClinicalPathway_StateDefinition>((s: ClinicalPathway_StateDefinition): boolean => !contains<Shared_StateKey>(s.StateKey, statesWithIncoming), pathway.States));
+            initialStates = (isEmpty(candidates) ? defaultArg(map_3<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, {
+        return new ExecutionContext(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));
+        }), empty<MatchedTransition>(), empty<MatchedTransition>(), empty<ClinicalPathway_ActionInfo_$union>(), 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 {
+export function resolveFieldValueSource(valueSource: ClinicalPathway_FieldValueSource_$union, formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): string {
     switch (valueSource.tag) {
         case /* FieldReference */ 1:
-            return defaultArg(tryFind<Shared_FieldKey, string>(valueSource.fields[0], FieldResolver_extractFieldValues<FieldType>(FieldResolver_createResolver<FieldType>(formSpec), formData)), "");
+            return defaultArg(tryFind_1<Shared_FieldKey, string>(valueSource.fields[0], FieldResolver_extractFieldValues(FieldResolver_createResolver(formSpec), formSpec)), "");
         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> => {
+            return defaultArg(tryPick<Spec_FormField$1<Spec_FieldType_$union>, string>((field: Spec_FormField$1<Spec_FieldType_$union>): 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)), "");
+                return map_3<Shared_FieldOption, string>((opt_1: Shared_FieldOption): string => opt_1.Description, tryFind<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<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>>((step: Spec_FormStep$1<Spec_FieldType_$union>): FSharpList<Spec_FormField$1<Spec_FieldType_$union>> => step.Fields, formSpec.Steps)), "");
         }
         default:
             return valueSource.fields[0];
@@ -913,87 +1193,84 @@ export function resolveFieldValueSource<FieldType>(valueSource: ClinicalPathway_
 }
 
 /**
- * Execute SetFieldValue action and update form data
+ * Execute SetFieldValue action and update form spec
  */
-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>({
+export function executeSetFieldValueAction(action: ClinicalPathway_SetFieldValueAction, formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): Spec_FormSpec$1<Spec_FieldType_$union> {
+    let matchValue: Option<ClinicalPathway_TransitionCondition_$union>, condition: ClinicalPathway_TransitionCondition_$union, fieldValues: FSharpMap<Shared_FieldKey, string>;
+    if (!((matchValue = action.Condition, (matchValue == null) ? true : ((condition = value_3(matchValue), (fieldValues = FieldResolver_extractFieldValues(FieldResolver_createResolver(formSpec), formSpec), evaluateTransitionWithPartialData(FieldResolver_createResolver(formSpec), formSpec, fieldValues, empty_1<Shared_StateKey>({
         Compare: compare,
-    }), condition).tag === /* Satisfied */ 0)))))) {
-        return formData;
+    }), formSpec, condition).tag === /* Satisfied */ 0)))))) {
+        return formSpec;
     }
     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));
+        const valueToSet: string = resolveFieldValueSource(action.Value, formSpec);
+        const targetFieldOpt: Option<Spec_FormField$1<Spec_FieldType_$union>> = tryFind<Spec_FormField$1<Spec_FieldType_$union>>((field: Spec_FormField$1<Spec_FieldType_$union>): boolean => equals(field.FieldKey, action.TargetField), collect<Spec_FormStep$1<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>>((step: Spec_FormStep$1<Spec_FieldType_$union>): FSharpList<Spec_FormField$1<Spec_FieldType_$union>> => step.Fields, formSpec.Steps));
         if (targetFieldOpt == null) {
-            return formData;
+            return formSpec;
         }
         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);
+            const targetField: Spec_FormField$1<Spec_FieldType_$union> = value_3(targetFieldOpt);
+            const stepOpt: Option<Spec_FormStep$1<Spec_FieldType_$union>> = tryFind<Spec_FormStep$1<Spec_FieldType_$union>>((step_1: Spec_FormStep$1<Spec_FieldType_$union>): boolean => exists<Spec_FormField$1<Spec_FieldType_$union>>((f: Spec_FormField$1<Spec_FieldType_$union>): boolean => equals(f.FieldKey, action.TargetField), step_1.Fields), formSpec.Steps);
             if (stepOpt == null) {
-                return formData;
+                return formSpec;
             }
             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>()))))))))));
+                const step_2: Spec_FormStep$1<Spec_FieldType_$union> = value_3(stepOpt);
+                return updateField<Spec_FieldType_$union>(formSpec, action.TargetField, Shared_FieldValue_Single(new Shared_FieldAnswer(action.TargetField, targetField.Label, valueToSet)), findIndex<Spec_FormStep$1<Spec_FieldType_$union>>((s: Spec_FormStep$1<Spec_FieldType_$union>): boolean => (s.StepOrder === step_2.StepOrder), formSpec.Steps));
             }
         }
     }
 }
 
 /**
- * Execute an action and return updated form data
+ * Execute an action and return updated form spec
  */
-export function executeAction<FieldType>(action: ClinicalPathway_ActionInfo_$union, formSpec: Spec_FormSpec$1<FieldType>, formData: Values_DynamicFormResultData$1<FieldType>): Values_DynamicFormResultData$1<FieldType> {
+export function executeAction(action: ClinicalPathway_ActionInfo_$union, formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): Spec_FormSpec$1<Spec_FieldType_$union> {
     if (action.tag === /* SetFieldValue */ 10) {
-        return executeSetFieldValueAction<FieldType>(action.fields[0], formSpec, formData);
+        return executeSetFieldValueAction(action.fields[0], formSpec);
     }
     else {
-        return formData;
+        return formSpec;
     }
 }
 
 /**
- * Execute all actions from a list and return updated form data
+ * Execute all actions from a list and return updated form spec
  */
-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);
+export function executeActions(actions: FSharpList<ClinicalPathway_ActionInfo_$union>, formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): Spec_FormSpec$1<Spec_FieldType_$union> {
+    return fold<ClinicalPathway_ActionInfo_$union, Spec_FormSpec$1<Spec_FieldType_$union>>((currentSpec: Spec_FormSpec$1<Spec_FieldType_$union>, action: ClinicalPathway_ActionInfo_$union): Spec_FormSpec$1<Spec_FieldType_$union> => executeAction(action, currentSpec), formSpec, actions);
 }
 
 /**
  * Execute one step of the pathway (incremental execution)
  */
-export function executeStep<FieldType>(context_mut: ExecutionContext$1<FieldType>, maxIterations_mut: int32): ExecutionContext$1<FieldType> {
+export function executeStep(context_mut: ExecutionContext, maxIterations_mut: int32): ExecutionContext {
     executeStep:
     while (true) {
-        const context: ExecutionContext$1<FieldType> = context_mut, maxIterations: int32 = maxIterations_mut;
+        const context: ExecutionContext = 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 patternInput: [FSharpList<MatchedTransition>, FSharpList<MatchedTransition>, FSharpList<MatchedTransition>] = categorizeTransitions(evaluateAllTransitions<any>(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);
+                return new ExecutionContext(context.PathwaySpec, context.FormSpec, context.CurrentStates, context.VisitedStates, context.CompletedStates, active, pending, context.ExecutedActions, 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 updatedFormSpec: Spec_FormSpec$1<Spec_FieldType_$union> = executeActions(newActions, context.FormSpec);
                 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)) {
+                const updatedContext: ExecutionContext = new ExecutionContext(context.PathwaySpec, updatedFormSpec, newStates, union<Shared_StateKey>(context.VisitedStates, newStates), union<Shared_StateKey>(context.CompletedStates, context.CurrentStates), active, pending, append(context.ExecutedActions, newActions), context.FieldResolver, append(context.ExecutionLog, newLogEntries));
+                if (isExecutionComplete(updatedContext)) {
                     return updatedContext;
                 }
                 else {
@@ -1010,31 +1287,31 @@ export function executeStep<FieldType>(context_mut: ExecutionContext$1<FieldType
 /**
  * Process incremental updates as form fills
  */
-export function executeIncremental<FieldType>(context: ExecutionContext$1<FieldType>, formData: Values_DynamicFormResultData$1<FieldType>): IncrementalExecutionResult$1<FieldType> {
+export function executeIncremental(context: ExecutionContext, formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): IncrementalExecutionResult {
     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), {
+    const updatedContext: ExecutionContext = new ExecutionContext(context.PathwaySpec, formSpec, context.CurrentStates, context.VisitedStates, context.CompletedStates, context.ActiveTransitions, context.PendingTransitions, context.ExecutedActions, context.FieldResolver, context.ExecutionLog);
+    const newContext: ExecutionContext = executeStep(updatedContext, 100);
+    return new IncrementalExecutionResult(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));
+    }), previousTransitionKeys), map<MatchedTransition, ClinicalPathway_TransitionDefinition>((t_3: MatchedTransition): ClinicalPathway_TransitionDefinition => t_3.Transition, filter_1<MatchedTransition>((t_2: MatchedTransition): boolean => contains<Shared_TransitionKey>(t_2.Transition.TransitionKey, newKeys), newContext.ActiveTransitions)))), predictOutcomes(newContext), calculateCompletionPercentage(newContext), isExecutionComplete(newContext));
 }
 
 /**
  * Get visualization state from execution context
  */
-export function getVisualizationState<FieldType>(context: ExecutionContext$1<FieldType>): VisualizationState {
+export function getVisualizationState(context: ExecutionContext): 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));
+    const completedTransitions: FSharpList<string> = map<ExecutionLogEntry, string>((log_1: ExecutionLogEntry): string => log_1.Details, filter_1<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(context));
 }
 
 /**
  * Extract final clinical plans from execution context
  */
-export function extractClinicalPlans<FieldType>(context: ExecutionContext$1<FieldType>): FSharpList<ClinicalPlan> {
+export function extractClinicalPlans(context: ExecutionContext): 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;
@@ -1073,11 +1350,11 @@ export class PathwayExecutionResult$1<FieldType> extends Record implements IEqua
     readonly ExecutedActions: FSharpList<ClinicalPathway_ActionInfo_$union>;
     readonly VisitedStates: FSharpList<string>;
     readonly TransitionsUsed: FSharpList<string>;
-    readonly FormData: Values_DynamicFormResultData$1<FieldType>;
+    readonly FormSpec: Spec_FormSpec$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>) {
+    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>, FormSpec: Spec_FormSpec$1<FieldType>, ExecutionTime: Date, Success: boolean, Errors: FSharpList<string>) {
         super();
         this.PathwayId = PathwayId;
         this.StartState = StartState;
@@ -1088,7 +1365,7 @@ export class PathwayExecutionResult$1<FieldType> extends Record implements IEqua
         this.ExecutedActions = ExecutedActions;
         this.VisitedStates = VisitedStates;
         this.TransitionsUsed = TransitionsUsed;
-        this.FormData = FormData;
+        this.FormSpec = FormSpec;
         this.ExecutionTime = ExecutionTime;
         this.Success = Success;
         this.Errors = Errors;
@@ -1096,7 +1373,7 @@ export class PathwayExecutionResult$1<FieldType> extends Record implements IEqua
 }
 
 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)]]);
+    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)], ["FormSpec", Spec_FormSpec$1_$reflection(gen0)], ["ExecutionTime", class_type("System.DateTime")], ["Success", bool_type], ["Errors", list_type(string_type)]]);
 }
 
 //# sourceMappingURL=PathwayExecutor.ts.map