@f1studio/form-spec 5.0.0-alpha.167 → 5.0.0-alpha.169

package/src/FormSpec.FS/Integrations/CorEMR/CoreMRPathwayMapper.ts

@@ -0,0 +1,926 @@
+import { Helpers_canonicalizeFieldKey, Helpers_generateDeterministicGuidRaw } from "../../Helpers.js";
+import { Action, NonEmpty_toList, NonEmpty$1, GroupChange_$union, ProblemOrder, MedsetOrder, TreatmentOrder, Standing, TaskOrder, Cadence_$union, Trigger, StatedAction, ActionRead_$union, Ref, Action_$union, Join, Join_$union, Priority, Timing_$union, StatedCondition, Condition_$union, ChoiceId, Comparison_$union } from "../../../vye-os-contracts-fs/src/CoreMR/FormTemplate.js";
+import { indexed, append, sort, exists, collect, filter, sortBy, length, ofArray, fold, zip, tail, head as head_1, isEmpty, map as map_1, singleton, FSharpList, empty, choose, tryFind } from "@fable-org/fable-library-js/List.js";
+import { IDisposable, disposeSafe, IEnumerator, getEnumerator, numberHash, stringHash, safeHash, comparePrimitives, equals } from "@fable-org/fable-library-js/Util.js";
+import { ReleaseAvailability$1_$union, TemplateForm, TemplateChoice, TemplateItem } from "./FormTemplateDecoder.js";
+import { defaultArg, bind, map, value, Option } from "@fable-org/fable-library-js/Option.js";
+import { parse, int32 } from "@fable-org/fable-library-js/Int32.js";
+import { decimal } from "@fable-org/fable-library-js/Decimal.js";
+import { ClinicalPathway_PathwayExecutionMode_MultiPathway, ClinicalPathway_MultiPathwayConfig, ClinicalPathway_ConflictResolution_CombineActions, ClinicalPathway_CombinationStrategy_AllMatching, ClinicalPathway_ClinicalPathwaySpec, ClinicalPathway_PathRequirement, ClinicalPathway_ConstraintDefinition, ClinicalPathway_PathwayExecutionMode_TriggerBased, ClinicalPathway_TriggerBasedConfig, ClinicalPathway_TransitionDefinition, Shared_TransitionKey, ClinicalPathway_StateType_Terminal, ClinicalPathway_TerminalInfo, ClinicalPathway_StateDefinition, ClinicalPathway_StateType_Evaluation, ClinicalPathway_EvaluationInfo, Shared_StateKey, ClinicalPathway_StateType_$union, ClinicalPathway_StateType_CompoundAction, ClinicalPathway_StateType_Action, ClinicalPathway_PathwayAction, ClinicalPathway_ActionOrigin_CoreMRTrigger, ClinicalPathway_CoreMRTriggerRef, ClinicalPathway_ActionInfo_Alert, ClinicalPathway_AlertAction, ClinicalPathway_ActionInfo_ChangeGroups, ClinicalPathway_GroupChangeAction, ClinicalPathway_GroupRef, ClinicalPathway_GroupChange_AddToGroups, ClinicalPathway_GroupChange_$union, ClinicalPathway_GroupChange_RemoveFromGroups, ClinicalPathway_ActionInfo_Problem, ClinicalPathway_ProblemAction, ClinicalPathway_ProblemStatus_Active, ClinicalPathway_ActionInfo_Medset, ClinicalPathway_MedsetAction, ClinicalPathway_ActionInfo_Treatment, ClinicalPathway_TreatmentAction, ClinicalPathway_ActionInfo_$union, ClinicalPathway_ActionInfo_Task, ClinicalPathway_TaskAction, ClinicalPathway_Cadence_OnSchedule, ClinicalPathway_StandingSchedule, ClinicalPathway_Cadence_Every, ClinicalPathway_TransitionCondition_Always, ClinicalPathway_TransitionCondition_CompositeCondition, ClinicalPathway_LogicalOp_$union, ClinicalPathway_LogicalOp_And, ClinicalPathway_LogicalOp_Or, ClinicalPathway_TransitionCondition_$union, ClinicalPathway_TransitionCondition_FieldCondition, ClinicalPathway_TransitionCondition_PluginPropertyCondition, Shared_PluginPropertyKey, Shared_ConditionValue_Single, Shared_ConditionValue_Multiple, Shared_ConditionValue_$union, Shared_FieldKey, ClinicalPathway_DueDate_$union, ClinicalPathway_DueDate_AsStated, ClinicalPathway_DueDate_DaysFromNow, ClinicalPathway_DueDate_Tomorrow, ClinicalPathway_DueDate_Today, ClinicalPathway_TaskPriority_$union, ClinicalPathway_TaskPriority_Stated, ClinicalPathway_TaskPriority_Low, ClinicalPathway_TaskPriority_Medium, ClinicalPathway_TaskPriority_High, ClinicalPathway_TriggerTiming_$union, ClinicalPathway_TriggerTiming_OnFormSave, ClinicalPathway_TriggerTiming_OnFormLoad, ClinicalPathway_TriggerTiming_OnFormSubmit, ClinicalPathway_FieldEvaluator_$union, ClinicalPathway_FieldEvaluator_Equals, ClinicalPathway_FieldEvaluator_LessOrEqual, ClinicalPathway_FieldEvaluator_LessThan, ClinicalPathway_FieldEvaluator_GreaterOrEqual, ClinicalPathway_FieldEvaluator_GreaterThan, ClinicalPathway_FieldEvaluator_NotEquals, ClinicalPathway_FieldEvaluator_NotInSet, ClinicalPathway_FieldEvaluator_ContainsAll, ClinicalPathway_FieldEvaluator_InSet } from "../../FormSpec.js";
+import { match } from "@fable-org/fable-library-js/RegExp.js";
+import { FSharpMap__ContainsKey, FSharpMap, tryFind as tryFind_1 } from "@fable-org/fable-library-js/Map.js";
+import { printf, join, substring, isNullOrEmpty, interpolate, toText } from "@fable-org/fable-library-js/String.js";
+import { ofList } from "@fable-org/fable-library-js/Set.js";
+import { List_distinctBy, List_distinct } from "@fable-org/fable-library-js/Seq2.js";
+import { empty as empty_1, singleton as singleton_1, collect as collect_1, append as append_1, delay, toList } from "@fable-org/fable-library-js/Seq.js";
+
+function stableGuid(name: string): string {
+    return Helpers_generateDeterministicGuidRaw(`coremr:item_trigger:${name}`);
+}
+
+function comparisonWord(c: Comparison_$union): string {
+    switch (c.tag) {
+        case /* LessOrEqual */ 1:
+            return "less_equals";
+        case /* Equal */ 2:
+            return "equals";
+        case /* NotEqual */ 3:
+            return "not_equals";
+        case /* GreaterOrEqual */ 4:
+            return "greater_equals";
+        case /* Greater */ 5:
+            return "greater";
+        default:
+            return "less";
+    }
+}
+
+function textsOf(items: FSharpList<TemplateItem>, c: StatedCondition): [string, FSharpList<string>] {
+    const chosen = (ids: FSharpList<ChoiceId>): FSharpList<string> => {
+        const matchValue: Option<TemplateItem> = tryFind<TemplateItem>((i: TemplateItem): boolean => equals(i.ItemId, c.SourceItem), items);
+        if (matchValue != null) {
+            const item: TemplateItem = value(matchValue);
+            return choose<ChoiceId, string>((_arg: ChoiceId): Option<string> => {
+                const id: int32 = _arg.fields[0] | 0;
+                return map<TemplateChoice, string>((ch_1: TemplateChoice): string => ch_1.Text, tryFind<TemplateChoice>((ch: TemplateChoice): boolean => (ch.ChoiceId === id), item.Choices));
+            }, ids);
+        }
+        else {
+            return empty<string>();
+        }
+    };
+    const matchValue_1: Condition_$union = c.Test;
+    switch (matchValue_1.tag) {
+        case /* AllChosen */ 1:
+            return ["all", chosen(matchValue_1.fields[0])] as [string, FSharpList<string>];
+        case /* NoneChosen */ 2:
+            return ["none", chosen(matchValue_1.fields[0])] as [string, FSharpList<string>];
+        case /* VitalIs */ 3: {
+            const threshold: decimal = matchValue_1.fields[2];
+            return [comparisonWord(matchValue_1.fields[1]), singleton(threshold.toString())] as [string, FSharpList<string>];
+        }
+        case /* BooleanIs */ 4:
+            return ["equals", singleton(matchValue_1.fields[0] ? "true" : "false")] as [string, FSharpList<string>];
+        case /* TextCompares */ 5: {
+            const text: string = matchValue_1.fields[1];
+            return [comparisonWord(matchValue_1.fields[0]), singleton(text)] as [string, FSharpList<string>];
+        }
+        case /* UnmodelledCondition */ 6:
+            throw new Error(`CoreMRPathwayMapper: condition \`${matchValue_1.fields[0]} ${matchValue_1.fields[1]}\` is not modelled (${matchValue_1.fields[2]}) — \`refusalFor\` refuses it first`);
+        default:
+            return ["any", chosen(matchValue_1.fields[0])] as [string, FSharpList<string>];
+    }
+}
+
+export function convertOperator(test: Condition_$union, values: FSharpList<string>): ClinicalPathway_FieldEvaluator_$union {
+    const canonValues: FSharpList<string> = map_1<string, string>(Helpers_canonicalizeFieldKey, values);
+    let matchResult: int32, cmp: Comparison_$union;
+    switch (test.tag) {
+        case /* AllChosen */ 1: {
+            matchResult = 1;
+            break;
+        }
+        case /* NoneChosen */ 2: {
+            matchResult = 2;
+            break;
+        }
+        case /* VitalIs */ 3: {
+            matchResult = 3;
+            cmp = test.fields[1];
+            break;
+        }
+        case /* TextCompares */ 5: {
+            matchResult = 3;
+            cmp = test.fields[0];
+            break;
+        }
+        case /* BooleanIs */ 4: {
+            matchResult = 4;
+            break;
+        }
+        case /* UnmodelledCondition */ 6: {
+            matchResult = 5;
+            break;
+        }
+        default:
+            matchResult = 0;
+    }
+    switch (matchResult) {
+        case 0:
+            return ClinicalPathway_FieldEvaluator_InSet(canonValues);
+        case 1:
+            return ClinicalPathway_FieldEvaluator_ContainsAll(canonValues);
+        case 2:
+            return ClinicalPathway_FieldEvaluator_NotInSet(canonValues);
+        case 3: {
+            const _arg: Comparison_$union = cmp!;
+            switch (_arg.tag) {
+                case /* NotEqual */ 3:
+                    return ClinicalPathway_FieldEvaluator_NotEquals();
+                case /* Greater */ 5:
+                    return ClinicalPathway_FieldEvaluator_GreaterThan();
+                case /* GreaterOrEqual */ 4:
+                    return ClinicalPathway_FieldEvaluator_GreaterOrEqual();
+                case /* Less */ 0:
+                    return ClinicalPathway_FieldEvaluator_LessThan();
+                case /* LessOrEqual */ 1:
+                    return ClinicalPathway_FieldEvaluator_LessOrEqual();
+                default:
+                    return ClinicalPathway_FieldEvaluator_Equals();
+            }
+        }
+        case 4:
+            return ClinicalPathway_FieldEvaluator_Equals();
+        default:
+            throw new Error(`CoreMRPathwayMapper: unmodelled condition \`${test.fields[0]} ${test.fields[1]}\` reached the mapper`);
+    }
+}
+
+export function convertTiming(timing: Timing_$union): ClinicalPathway_TriggerTiming_$union {
+    switch (timing.tag) {
+        case /* OnLock */ 1:
+            return ClinicalPathway_TriggerTiming_OnFormSubmit();
+        case /* OnFirstOpen */ 2:
+            return ClinicalPathway_TriggerTiming_OnFormLoad();
+        case /* UnrecognisedTiming */ 3:
+            throw new Error(`CoreMRPathwayMapper: event \`${timing.fields[0]}\` is not modelled — \`refusalFor\` refuses it first`);
+        default:
+            return ClinicalPathway_TriggerTiming_OnFormSave();
+    }
+}
+
+function convertPriority(_arg: Priority): ClinicalPathway_TaskPriority_$union {
+    const p: int32 = _arg.fields[0] | 0;
+    switch (p) {
+        case 1:
+            return ClinicalPathway_TaskPriority_High();
+        case 2:
+            return ClinicalPathway_TaskPriority_Medium();
+        case 3:
+            return ClinicalPathway_TaskPriority_Low();
+        default:
+            return ClinicalPathway_TaskPriority_Stated(p);
+    }
+}
+
+function parseDueDate(stated: string): ClinicalPathway_DueDate_$union {
+    const m: any = match(/^\+\s*(\d+)\s*(day|days|week|weeks)$/gu, stated.trim().toLowerCase());
+    const matchValue: string = stated.trim().toLowerCase();
+    switch (matchValue) {
+        case "today":
+            return ClinicalPathway_DueDate_Today();
+        case "tomorrow":
+            return ClinicalPathway_DueDate_Tomorrow();
+        default:
+            if (m != null) {
+                const n: int32 = parse(m[1] || "", 511, false, 32) | 0;
+                return ClinicalPathway_DueDate_DaysFromNow((m[2] || "").startsWith("week") ? (7 * n) : n);
+            }
+            else {
+                return ClinicalPathway_DueDate_AsStated(stated);
+            }
+    }
+}
+
+function requiredDue(what: string, stated: Option<string>): ClinicalPathway_DueDate_$union {
+    if (stated == null) {
+        throw new Error(`CoreMRPathwayMapper: ${what} states no date — none is invented`);
+    }
+    else {
+        return parseDueDate(value(stated));
+    }
+}
+
+export function convertCondition(items: FSharpList<TemplateItem>, cond: StatedCondition, itemFieldKeyMap: FSharpMap<int32, Shared_FieldKey>): ClinicalPathway_TransitionCondition_$union {
+    let fieldKey: Shared_FieldKey;
+    const matchValue: Option<Shared_FieldKey> = bind<int32, Shared_FieldKey>((item: int32): Option<Shared_FieldKey> => tryFind_1<int32, Shared_FieldKey>(item, itemFieldKeyMap), cond.SourceItem);
+    if (matchValue == null) {
+        throw new Error(toText(interpolate("CoreMRPathwayMapper: condition on item %A%P() is not a field — `nonFieldRefusal` refuses it first", [cond.SourceItem])));
+    }
+    else {
+        fieldKey = value(matchValue);
+    }
+    const values: FSharpList<string> = textsOf(items, cond)[1];
+    const evaluator: ClinicalPathway_FieldEvaluator_$union = convertOperator(cond.Test, values);
+    const canonicalize = Helpers_canonicalizeFieldKey;
+    let condValue: Shared_ConditionValue_$union;
+    const matchValue_1: Condition_$union = cond.Test;
+    switch (matchValue_1.tag) {
+        case /* AnyChosen */ 0:
+        case /* AllChosen */ 1:
+        case /* NoneChosen */ 2: {
+            condValue = Shared_ConditionValue_Multiple(ofList<string>(map_1<string, string>(canonicalize, values), {
+                Compare: comparePrimitives,
+            }));
+            break;
+        }
+        default:
+            condValue = (isEmpty(values) ? Shared_ConditionValue_Single("") : Shared_ConditionValue_Single(canonicalize(head_1(values))));
+    }
+    const matchValue_2: Condition_$union = cond.Test;
+    let matchResult: int32;
+    if (matchValue_2.tag === /* VitalIs */ 3) {
+        switch (matchValue_2.fields[0].tag) {
+            case /* SystolicBP */ 0: {
+                matchResult = 0;
+                break;
+            }
+            case /* DiastolicBP */ 1: {
+                matchResult = 1;
+                break;
+            }
+            default:
+                matchResult = 2;
+        }
+    }
+    else {
+        matchResult = 2;
+    }
+    switch (matchResult) {
+        case 0:
+            return ClinicalPathway_TransitionCondition_PluginPropertyCondition(fieldKey, new Shared_PluginPropertyKey(stableGuid("bp_systolic")), evaluator, condValue);
+        case 1:
+            return ClinicalPathway_TransitionCondition_PluginPropertyCondition(fieldKey, new Shared_PluginPropertyKey(stableGuid("bp_diastolic")), evaluator, condValue);
+        default:
+            return ClinicalPathway_TransitionCondition_FieldCondition(fieldKey, evaluator, condValue);
+    }
+}
+
+/**
+ * Combine a trigger's conditions: the LEFT FOLD of each later condition's OWN join (CTA-033). The head's join is
+ * the release's default and is ignored (10245: head "&&", every later row "||" on all 18 St Johns chains — they
+ * read as OR; the old head-join made them AND). ⭐ A chain with one join throughout is ONE composite (the shape
+ * the pathway always had); a mixed chain nests left to right ((a op b) op c) — 0 at St Johns.
+ * ⛔ An unrecognised join never reaches here: `refusalFor` refuses its template by name.
+ */
+export function combineConditions(items: FSharpList<TemplateItem>, conditions: FSharpList<StatedCondition>, itemFieldKeyMap: FSharpMap<int32, Shared_FieldKey>): ClinicalPathway_TransitionCondition_$union {
+    if (!isEmpty(conditions)) {
+        if (isEmpty(tail(conditions))) {
+            return convertCondition(items, head_1(conditions), itemFieldKeyMap);
+        }
+        else {
+            const ops: FSharpList<ClinicalPathway_LogicalOp_$union> = map_1<StatedCondition, ClinicalPathway_LogicalOp_$union>((c: StatedCondition): ClinicalPathway_LogicalOp_$union => {
+                const matchValue: Option<Join_$union> = c.Join;
+                if (matchValue == null) {
+                    throw new Error("CoreMRPathwayMapper: a later condition states no join — the release cannot say how it combines");
+                }
+                else {
+                    switch (value(matchValue).tag) {
+                        case /* Or */ 1:
+                            return ClinicalPathway_LogicalOp_Or();
+                        case /* UnrecognisedJoin */ 2: {
+                            const j: string = (value(matchValue) as Join<2>).fields[0];
+                            throw new Error(`CoreMRPathwayMapper: join \`${j}\` is not modelled — \`refusalFor\` refuses it first`);
+                        }
+                        default:
+                            return ClinicalPathway_LogicalOp_And();
+                    }
+                }
+            }, tail(conditions));
+            const matchValue_1: FSharpList<ClinicalPathway_LogicalOp_$union> = List_distinct<ClinicalPathway_LogicalOp_$union>(ops, {
+                Equals: equals,
+                GetHashCode: safeHash,
+            });
+            let matchResult: int32, op: ClinicalPathway_LogicalOp_$union;
+            if (!isEmpty(matchValue_1)) {
+                if (isEmpty(tail(matchValue_1))) {
+                    matchResult = 0;
+                    op = head_1(matchValue_1);
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0:
+                    return ClinicalPathway_TransitionCondition_CompositeCondition(op!, map_1<StatedCondition, ClinicalPathway_TransitionCondition_$union>((c_1: StatedCondition): ClinicalPathway_TransitionCondition_$union => convertCondition(items, c_1, itemFieldKeyMap), conditions));
+                default: {
+                    const list_3: FSharpList<[ClinicalPathway_LogicalOp_$union, StatedCondition]> = zip<ClinicalPathway_LogicalOp_$union, StatedCondition>(ops, tail(conditions));
+                    return fold<[ClinicalPathway_LogicalOp_$union, StatedCondition], ClinicalPathway_TransitionCondition_$union>((acc: ClinicalPathway_TransitionCondition_$union, tupledArg: [ClinicalPathway_LogicalOp_$union, StatedCondition]): ClinicalPathway_TransitionCondition_$union => ClinicalPathway_TransitionCondition_CompositeCondition(tupledArg[0], ofArray([acc, convertCondition(items, tupledArg[1], itemFieldKeyMap)])), convertCondition(items, head_1(conditions), itemFieldKeyMap), list_3);
+                }
+            }
+        }
+    }
+    else {
+        return ClinicalPathway_TransitionCondition_Always();
+    }
+}
+
+function kindWord(a: Action_$union): string {
+    switch (a.tag) {
+        case /* Alert */ 2:
+            return "alert";
+        case /* Problem */ 3:
+            return "problem";
+        case /* Medset */ 4:
+            return "medset";
+        case /* StandingOrder */ 1:
+            if (a.fields[1].tag === /* Treatment */ 1) {
+                return "treatment";
+            }
+            else {
+                return "recurring_task";
+            }
+        case /* ChangeGroups */ 5:
+            return "groups";
+        default:
+            return "task";
+    }
+}
+
+function nameOf(r: Ref): string {
+    return defaultArg<string>(r.Name, "");
+}
+
+function modelledActions(t: Trigger): FSharpList<Action_$union> {
+    return map_1<StatedAction, Action_$union>((a: StatedAction): Action_$union => {
+        const matchValue: ActionRead_$union = a.Read;
+        if (matchValue.tag === /* Unmodelled */ 1) {
+            throw new Error(`CoreMRPathwayMapper: action ${a.ActionId} (\`${matchValue.fields[0]}\`) is unmodelled (${matchValue.fields[1]}) — \`refusalFor\` refuses it first`);
+        }
+        else {
+            return matchValue.fields[0];
+        }
+    }, t.Actions);
+}
+
+function standingOf(cadence: Cadence_$union): ClinicalPathway_StandingSchedule {
+    if (cadence.tag === /* Every */ 1) {
+        const until: string = cadence.fields[1];
+        return new ClinicalPathway_StandingSchedule(ClinicalPathway_Cadence_Every(cadence.fields[0], until), parseDueDate(until));
+    }
+    else {
+        const schedule: Ref = cadence.fields[0];
+        return new ClinicalPathway_StandingSchedule(ClinicalPathway_Cadence_OnSchedule(schedule.Id, schedule.Name), map<string, ClinicalPathway_DueDate_$union>(parseDueDate, cadence.fields[1]));
+    }
+}
+
+function taskOf(task: TaskOrder, standing: Option<ClinicalPathway_StandingSchedule>): ClinicalPathway_ActionInfo_$union {
+    return ClinicalPathway_ActionInfo_Task(new ClinicalPathway_TaskAction(task.Category.Id, nameOf(task.Category), task.Description, convertPriority(task.Priority), requiredDue("a task", task.Due), undefined, standing));
+}
+
+export function convertAction(action: Action_$union): ClinicalPathway_ActionInfo_$union {
+    switch (action.tag) {
+        case /* OneOffTask */ 0: {
+            const task: TaskOrder = action.fields[0];
+            return taskOf(task, undefined);
+        }
+        case /* StandingOrder */ 1:
+            if (action.fields[1].tag === /* Treatment */ 1) {
+                const cadence_1: Cadence_$union = action.fields[0];
+                const treatment: TreatmentOrder = (action.fields[1] as Standing<1>).fields[0];
+                return ClinicalPathway_ActionInfo_Treatment(new ClinicalPathway_TreatmentAction(treatment.Treatment.Id, treatment.Treatment.Name, map<Ref, int32>((r: Ref): int32 => r.Id, treatment.Provider), treatment.Instructions, parseDueDate(treatment.Start), standingOf(cadence_1), undefined, undefined, undefined));
+            }
+            else {
+                const cadence: Cadence_$union = action.fields[0];
+                const task_1: TaskOrder = (action.fields[1] as Standing<0>).fields[0];
+                return taskOf(task_1, standingOf(cadence));
+            }
+        case /* Medset */ 4: {
+            const medset: MedsetOrder = action.fields[0];
+            return ClinicalPathway_ActionInfo_Medset(new ClinicalPathway_MedsetAction(medset.Medset.Id, nameOf(medset.Medset), map<Ref, int32>((r_1: Ref): int32 => r_1.Id, medset.Prescriber), map<Ref, int32>((r_2: Ref): int32 => r_2.Id, medset.Pharmacy), requiredDue("a medset", medset.Start)));
+        }
+        case /* Problem */ 3: {
+            const problem: ProblemOrder = action.fields[0];
+            return ClinicalPathway_ActionInfo_Problem(new ClinicalPathway_ProblemAction(problem.Problem.Id, problem.Problem.Name, undefined, undefined, ClinicalPathway_ProblemStatus_Active(), undefined, problem.Chronic, problem.Severity, problem.Inflammation));
+        }
+        case /* ChangeGroups */ 5: {
+            const change: GroupChange_$union = action.fields[0];
+            const patternInput: [ClinicalPathway_GroupChange_$union, NonEmpty$1<Ref>] = (change.tag === /* RemoveFrom */ 1) ? ([ClinicalPathway_GroupChange_RemoveFromGroups(), change.fields[0]] as [ClinicalPathway_GroupChange_$union, NonEmpty$1<Ref>]) : ([ClinicalPathway_GroupChange_AddToGroups(), change.fields[0]] as [ClinicalPathway_GroupChange_$union, NonEmpty$1<Ref>]);
+            return ClinicalPathway_ActionInfo_ChangeGroups(new ClinicalPathway_GroupChangeAction(patternInput[0], map_1<Ref, ClinicalPathway_GroupRef>((r_3: Ref): ClinicalPathway_GroupRef => (new ClinicalPathway_GroupRef(r_3.Id, r_3.Name)), NonEmpty_toList<Ref>(patternInput[1]))));
+        }
+        default: {
+            const category: Ref = action.fields[0];
+            const categoryName: string = nameOf(category);
+            return ClinicalPathway_ActionInfo_Alert(new ClinicalPathway_AlertAction(category.Id, categoryName, categoryName, undefined, undefined));
+        }
+    }
+}
+
+export function generateEvaluationLabel(trigger: Trigger, items: FSharpList<TemplateItem>): string {
+    let item_1: TemplateItem, item_2: TemplateItem;
+    let fieldLabel: string;
+    const matchValue: FSharpList<StatedCondition> = trigger.Conditions;
+    if (!isEmpty(matchValue)) {
+        const head: StatedCondition = head_1(matchValue);
+        const matchValue_1: Option<TemplateItem> = bind<int32, TemplateItem>((id: int32): Option<TemplateItem> => tryFind<TemplateItem>((i: TemplateItem): boolean => (i.ItemId === id), items), head.SourceItem);
+        if (matchValue_1 == null) {
+            throw new Error(toText(interpolate("CoreMRPathwayMapper: trigger %P() reads item %A%P(), not on this form — refused first", [trigger.TriggerId, head.SourceItem])));
+        }
+        else {
+            fieldLabel = (isNullOrEmpty(value(matchValue_1).Text) ? ((item_1 = value(matchValue_1), "(no text)")) : ((item_2 = value(matchValue_1), (item_2.Text.length > 50) ? (substring(item_2.Text, 0, 47) + "...") : item_2.Text)));
+        }
+    }
+    else {
+        throw new Error(`CoreMRPathwayMapper: trigger ${trigger.TriggerId} states no condition — \`liveTriggers\` keeps none such`);
+    }
+    const matchValue_2: FSharpList<StatedCondition> = trigger.Conditions;
+    if (!isEmpty(matchValue_2)) {
+        if (isEmpty(tail(matchValue_2))) {
+            const matchValue_3: [string, FSharpList<string>] = textsOf(items, head_1(matchValue_2));
+            let matchResult: int32, v: string, vals_2: FSharpList<string>, vals_3: FSharpList<string>, v_1: string, v_2: string, v_3: string, v_4: string, v_5: string, v_6: string, vals_4: FSharpList<string>, op: string;
+            switch (matchValue_3[0]) {
+                case "any": {
+                    if (!isEmpty(matchValue_3[1])) {
+                        if (isEmpty(tail(matchValue_3[1]))) {
+                            matchResult = 0;
+                            v = head_1(matchValue_3[1]);
+                        }
+                        else if (length(matchValue_3[1]) <= 3) {
+                            matchResult = 1;
+                            vals_2 = matchValue_3[1];
+                        }
+                        else {
+                            matchResult = 2;
+                            vals_3 = matchValue_3[1];
+                        }
+                    }
+                    else if (length(matchValue_3[1]) <= 3) {
+                        matchResult = 1;
+                        vals_2 = matchValue_3[1];
+                    }
+                    else {
+                        matchResult = 2;
+                        vals_3 = matchValue_3[1];
+                    }
+                    break;
+                }
+                case "equals": {
+                    if (!isEmpty(matchValue_3[1])) {
+                        if (isEmpty(tail(matchValue_3[1]))) {
+                            matchResult = 3;
+                            v_1 = head_1(matchValue_3[1]);
+                        }
+                        else {
+                            matchResult = 10;
+                            op = matchValue_3[0];
+                        }
+                    }
+                    else {
+                        matchResult = 10;
+                        op = matchValue_3[0];
+                    }
+                    break;
+                }
+                case "not_equals": {
+                    if (!isEmpty(matchValue_3[1])) {
+                        if (isEmpty(tail(matchValue_3[1]))) {
+                            matchResult = 4;
+                            v_2 = head_1(matchValue_3[1]);
+                        }
+                        else {
+                            matchResult = 10;
+                            op = matchValue_3[0];
+                        }
+                    }
+                    else {
+                        matchResult = 10;
+                        op = matchValue_3[0];
+                    }
+                    break;
+                }
+                case "greater_equals": {
+                    if (!isEmpty(matchValue_3[1])) {
+                        if (isEmpty(tail(matchValue_3[1]))) {
+                            matchResult = 5;
+                            v_3 = head_1(matchValue_3[1]);
+                        }
+                        else {
+                            matchResult = 10;
+                            op = matchValue_3[0];
+                        }
+                    }
+                    else {
+                        matchResult = 10;
+                        op = matchValue_3[0];
+                    }
+                    break;
+                }
+                case "greater": {
+                    if (!isEmpty(matchValue_3[1])) {
+                        if (isEmpty(tail(matchValue_3[1]))) {
+                            matchResult = 6;
+                            v_4 = head_1(matchValue_3[1]);
+                        }
+                        else {
+                            matchResult = 10;
+                            op = matchValue_3[0];
+                        }
+                    }
+                    else {
+                        matchResult = 10;
+                        op = matchValue_3[0];
+                    }
+                    break;
+                }
+                case "less_equals": {
+                    if (!isEmpty(matchValue_3[1])) {
+                        if (isEmpty(tail(matchValue_3[1]))) {
+                            matchResult = 7;
+                            v_5 = head_1(matchValue_3[1]);
+                        }
+                        else {
+                            matchResult = 10;
+                            op = matchValue_3[0];
+                        }
+                    }
+                    else {
+                        matchResult = 10;
+                        op = matchValue_3[0];
+                    }
+                    break;
+                }
+                case "less": {
+                    if (!isEmpty(matchValue_3[1])) {
+                        if (isEmpty(tail(matchValue_3[1]))) {
+                            matchResult = 8;
+                            v_6 = head_1(matchValue_3[1]);
+                        }
+                        else {
+                            matchResult = 10;
+                            op = matchValue_3[0];
+                        }
+                    }
+                    else {
+                        matchResult = 10;
+                        op = matchValue_3[0];
+                    }
+                    break;
+                }
+                case "all": {
+                    matchResult = 9;
+                    vals_4 = matchValue_3[1];
+                    break;
+                }
+                default: {
+                    matchResult = 10;
+                    op = matchValue_3[0];
+                }
+            }
+            switch (matchResult) {
+                case 0:
+                    return `When ${fieldLabel} = ${v!}`;
+                case 1:
+                    return `When ${fieldLabel} is ${join(" or ", vals_2!)}`;
+                case 2:
+                    return `When ${fieldLabel} is any of ${length(vals_3!)} values`;
+                case 3:
+                    return `When ${fieldLabel} = ${v_1!}`;
+                case 4:
+                    return `When ${fieldLabel} ≠ ${v_2!}`;
+                case 5:
+                    return `When ${fieldLabel} ≥ ${v_3!}`;
+                case 6:
+                    return `When ${fieldLabel} > ${v_4!}`;
+                case 7:
+                    return `When ${fieldLabel} ≤ ${v_5!}`;
+                case 8:
+                    return `When ${fieldLabel} < ${v_6!}`;
+                case 9:
+                    return `When ${fieldLabel} has all of: ${join(", ", vals_4!)}`;
+                default:
+                    return `When ${fieldLabel} ${op!}`;
+            }
+        }
+        else {
+            return `When ${fieldLabel} (${length(matchValue_2)} conditions)`;
+        }
+    }
+    else {
+        throw new Error(`CoreMRPathwayMapper: trigger ${trigger.TriggerId} states no condition`);
+    }
+}
+
+export function generateActionLabel(trigger: Trigger): string {
+    let matchValue_1: Priority;
+    const matchValue: FSharpList<Action_$union> = modelledActions(trigger);
+    if (!isEmpty(matchValue)) {
+        if (isEmpty(tail(matchValue))) {
+            let matchResult: int32, category: Ref, task: TaskOrder, medset: MedsetOrder, task_1: TaskOrder, other: Action_$union;
+            switch (head_1(matchValue).tag) {
+                case /* Alert */ 2: {
+                    matchResult = 0;
+                    category = (head_1(matchValue) as Action<2>).fields[0];
+                    break;
+                }
+                case /* OneOffTask */ 0: {
+                    matchResult = 1;
+                    task = (head_1(matchValue) as Action<0>).fields[0];
+                    break;
+                }
+                case /* Medset */ 4: {
+                    matchResult = 2;
+                    medset = (head_1(matchValue) as Action<4>).fields[0];
+                    break;
+                }
+                case /* Problem */ 3: {
+                    matchResult = 3;
+                    break;
+                }
+                case /* StandingOrder */ 1: {
+                    if ((head_1(matchValue) as Action<1>).fields[1].tag === /* RecurringTask */ 0) {
+                        matchResult = 4;
+                        task_1 = ((head_1(matchValue) as Action<1>).fields[1] as Standing<0>).fields[0];
+                    }
+                    else {
+                        matchResult = 5;
+                        other = head_1(matchValue);
+                    }
+                    break;
+                }
+                default: {
+                    matchResult = 5;
+                    other = head_1(matchValue);
+                }
+            }
+            switch (matchResult) {
+                case 0:
+                    return `Create Alert: ${nameOf(category!)}`;
+                case 1:
+                    return `Create ${(matchValue_1 = task!.Priority, (matchValue_1.fields[0] === 1) ? "High " : ((matchValue_1.fields[0] === 3) ? "Low " : ""))}Task: ${nameOf(task!.Category)}`;
+                case 2:
+                    return `Order Medset: ${nameOf(medset!.Medset)}`;
+                case 3:
+                    return "Add to Problem List";
+                case 4:
+                    return `Schedule: ${nameOf(task_1!.Category)}`;
+                default:
+                    return `Execute: ${kindWord(other!)}`;
+            }
+        }
+        else {
+            const joined: string = join(", ", List_distinct<string>(map_1<Action_$union, string>(kindWord, matchValue), {
+                Equals: (x: string, y: string): boolean => (x === y),
+                GetHashCode: stringHash,
+            }));
+            return `Execute ${length(matchValue)} actions: ${joined}`;
+        }
+    }
+    else {
+        return "No actions";
+    }
+}
+
+function pathwayActions(t: Trigger): FSharpList<ClinicalPathway_PathwayAction> {
+    let sourceItem: int32;
+    const matchValue: FSharpList<StatedCondition> = t.Conditions;
+    if (isEmpty(matchValue)) {
+        throw new Error(`CoreMRPathwayMapper: trigger ${t.TriggerId} states no condition — \`liveTriggers\` keeps none such`);
+    }
+    else if (head_1(matchValue).SourceItem == null) {
+        throw new Error(`CoreMRPathwayMapper: trigger ${t.TriggerId}'s head condition reads no item — \`refusalFor\` refuses it first`);
+    }
+    else {
+        const item: int32 = value(head_1(matchValue).SourceItem) | 0;
+        sourceItem = item;
+    }
+    return map_1<StatedAction, ClinicalPathway_PathwayAction>((a: StatedAction): ClinicalPathway_PathwayAction => {
+        const matchValue_1: ActionRead_$union = a.Read;
+        if (matchValue_1.tag === /* Unmodelled */ 1) {
+            throw new Error(`CoreMRPathwayMapper: action ${a.ActionId} (\`${matchValue_1.fields[0]}\`) is unmodelled (${matchValue_1.fields[1]}) — \`refusalFor\` refuses it first`);
+        }
+        else {
+            return new ClinicalPathway_PathwayAction(convertAction(matchValue_1.fields[0]), ClinicalPathway_ActionOrigin_CoreMRTrigger(new ClinicalPathway_CoreMRTriggerRef(t.TriggerId, a.ActionId, sourceItem)));
+        }
+    }, t.Actions);
+}
+
+function actionStateType(t: Trigger): ClinicalPathway_StateType_$union {
+    const matchValue: FSharpList<ClinicalPathway_PathwayAction> = pathwayActions(t);
+    if (!isEmpty(matchValue)) {
+        if (isEmpty(tail(matchValue))) {
+            return ClinicalPathway_StateType_Action(head_1(matchValue));
+        }
+        else {
+            return ClinicalPathway_StateType_CompoundAction(matchValue);
+        }
+    }
+    else {
+        throw new Error(`CoreMRPathwayMapper: trigger ${t.TriggerId} states no action — \`liveTriggers\` keeps none such`);
+    }
+}
+
+/**
+ * ⭐ `importedAt` is the import's ONE clock read, taken at the edge (f1-api's batch, Studio's tab) and passed IN
+ * (CTA-013): the mapper reads no clock, so the same input gives the same pathway, and a test can pin the instant.
+ */
+export function convertTriggerToPathway(importedAt: Date, trigger: Trigger, items: FSharpList<TemplateItem>, itemFieldKeyMap: FSharpMap<int32, Shared_FieldKey>): ClinicalPathway_ClinicalPathwaySpec {
+    const tid: int32 = trigger.TriggerId | 0;
+    const startKey: Shared_StateKey = new Shared_StateKey(stableGuid(`t${tid}_start`));
+    const evalKey: Shared_StateKey = new Shared_StateKey(stableGuid(`t${tid}_eval`));
+    const actionKey: Shared_StateKey = new Shared_StateKey(stableGuid(`t${tid}_action`));
+    const endKey: Shared_StateKey = new Shared_StateKey(stableGuid(`t${tid}_end`));
+    const evalLabel: string = generateEvaluationLabel(trigger, items);
+    const actionLabel: string = generateActionLabel(trigger);
+    const startState: ClinicalPathway_StateDefinition = new ClinicalPathway_StateDefinition(startKey, "Start", 0, ClinicalPathway_StateType_Evaluation(new ClinicalPathway_EvaluationInfo("", undefined)), undefined);
+    const evalState: ClinicalPathway_StateDefinition = new ClinicalPathway_StateDefinition(evalKey, evalLabel, 1, ClinicalPathway_StateType_Evaluation(new ClinicalPathway_EvaluationInfo("", undefined)), undefined);
+    const actionState: ClinicalPathway_StateDefinition = new ClinicalPathway_StateDefinition(actionKey, actionLabel, 2, actionStateType(trigger), undefined);
+    const endState: ClinicalPathway_StateDefinition = new ClinicalPathway_StateDefinition(endKey, "Complete", 3, ClinicalPathway_StateType_Terminal(new ClinicalPathway_TerminalInfo("Complete", "Trigger evaluation complete", undefined)), undefined);
+    const condition: ClinicalPathway_TransitionCondition_$union = combineConditions(items, trigger.Conditions, itemFieldKeyMap);
+    const transitions: FSharpList<ClinicalPathway_TransitionDefinition> = ofArray([new ClinicalPathway_TransitionDefinition(new Shared_TransitionKey(stableGuid(`t${tid}_start_to_eval`)), startKey, evalKey, ClinicalPathway_TransitionCondition_Always(), undefined), new ClinicalPathway_TransitionDefinition(new Shared_TransitionKey(stableGuid(`t${tid}_eval_to_action`)), evalKey, actionKey, condition, 0), new ClinicalPathway_TransitionDefinition(new Shared_TransitionKey(stableGuid(`t${tid}_action_to_end`)), actionKey, endKey, ClinicalPathway_TransitionCondition_Always(), undefined)]);
+    return new ClinicalPathway_ClinicalPathwaySpec(`item_trigger_${tid}`, `Trigger ${tid}: ${actionLabel}`, "1.0.0", "CoreMR Conduit - Item Trigger", ClinicalPathway_PathwayExecutionMode_TriggerBased(new ClinicalPathway_TriggerBasedConfig(convertTiming(trigger.Timing), true)), startKey, ofArray([startState, evalState, actionState, endState]), transitions, empty<ClinicalPathway_ConstraintDefinition>(), empty<ClinicalPathway_PathRequirement>(), importedAt, undefined, undefined, 1);
+}
+
+/**
+ * The triggers a pathway is built from, in pathway order: each attached to the form items its conditions read
+ * (a source item id > 0 the form carries), in ITEM order then the order conduit states the triggers (by id) —
+ * first attachment wins — keeping only ENABLED triggers that state at least one action.
+ * ⭐ This is the attachment conduit made for the raw rows (`templateOf` → `items[].triggers`), recomputed from
+ * the DOMAIN's own facts. ⚠️ A trigger whose conditions read no item of the form attaches nowhere and fires
+ * nothing, exactly as before.
+ */
+export function liveTriggers(form: TemplateForm, reads: ReleaseAvailability$1_$union<FSharpList<Trigger>>): FSharpList<Trigger> {
+    switch (reads.tag) {
+        case /* Stated */ 0: {
+            const byId: FSharpList<Trigger> = sortBy<Trigger, int32>((t: Trigger): int32 => t.TriggerId, reads.fields[0], {
+                Compare: comparePrimitives,
+            });
+            return filter<Trigger>((t_3: Trigger): boolean => {
+                if (t_3.Enabled) {
+                    return !isEmpty(t_3.Actions);
+                }
+                else {
+                    return false;
+                }
+            }, List_distinctBy<Trigger, int32>((t_2: Trigger): int32 => t_2.TriggerId, collect<TemplateItem, Trigger>((item: TemplateItem): FSharpList<Trigger> => filter<Trigger>((t_1: Trigger): boolean => exists<StatedCondition>((c: StatedCondition): boolean => equals(c.SourceItem, item.ItemId), t_1.Conditions), byId), form.Items), {
+                Equals: (x_1: int32, y_1: int32): boolean => (x_1 === y_1),
+                GetHashCode: numberHash,
+            }));
+        }
+        default:
+            return empty<Trigger>();
+    }
+}
+
+/**
+ * `Some sentence` when `form` must be refused — the sentence names every refused kind it uses, sorted.
+ * ⭐ The refusal is CONDUIT's supply's now (an action it serves `Unmodelled`, CTA-031); this only reads it.
+ * ⚠️ LIVE triggers only, exactly as the pathway reads them: St Johns form 130 carries a `recurring_task` on a
+ * DISABLED trigger and is not refused (CTA-003).
+ * ⚠️ The sentence still names "the 5.5.0+10245 converter" because the storage golden's report freezes it;
+ * rewording it is an intended diff (CTA-033).
+ * ⭐ ENFORCED BY: `VendorScoreTests`/`FormTemplateDomainTests` (FormSpec.FS.Tests) and the golden's 11 refusals.
+ */
+export function refusalFor(form: TemplateForm, reads: ReleaseAvailability$1_$union<FSharpList<Trigger>>): Option<string> {
+    let arg: string, arg_1: string;
+    const live: FSharpList<Trigger> = liveTriggers(form, reads);
+    const kinds: FSharpList<string> = sort<string>(List_distinct<string>(collect<Trigger, string>((t: Trigger): FSharpList<string> => choose<StatedAction, string>((a: StatedAction): Option<string> => {
+        const matchValue: ActionRead_$union = a.Read;
+        if (matchValue.tag === /* Modelled */ 0) {
+            return undefined;
+        }
+        else {
+            const kind: string = matchValue.fields[0];
+            return kind.toLowerCase();
+        }
+    }, t.Actions), live), {
+        Equals: (x: string, y: string): boolean => (x === y),
+        GetHashCode: stringHash,
+    }), {
+        Compare: comparePrimitives,
+    });
+    const conditions: FSharpList<string> = sort<string>(List_distinct<string>(append<string>((reads.tag === /* NotInRelease */ 1) ? empty<string>() : ((reads.tag === /* NotReadYet */ 2) ? empty<string>() : map_1<Trigger, string>((t_3: Trigger): string => (`trigger ${t_3.TriggerId} reads no item`), filter<Trigger>((t_2: Trigger): boolean => exists<StatedCondition>((c: StatedCondition): boolean => (c.SourceItem == null), t_2.Conditions), filter<Trigger>((t_1: Trigger): boolean => {
+        if (t_1.Enabled) {
+            return !isEmpty(t_1.Actions);
+        }
+        else {
+            return false;
+        }
+    }, reads.fields[0])))), collect<Trigger, string>((t_4: Trigger): FSharpList<string> => toList<string>(delay<string>((): Iterable<string> => append_1<string>(collect_1<StatedCondition, Iterable<string>, string>((c_1: StatedCondition): Iterable<string> => {
+        let matchValue_1: Condition_$union;
+        return append_1<string>((matchValue_1 = c_1.Test, (matchValue_1.tag === /* UnmodelledCondition */ 6) ? singleton_1<string>(`${matchValue_1.fields[0]} ${matchValue_1.fields[1]}`) : (empty_1<string>())), delay<string>((): Iterable<string> => {
+            const matchValue_2: Option<Join_$union> = c_1.Join;
+            let matchResult: int32, j: string;
+            if (matchValue_2 != null) {
+                if (value(matchValue_2).tag === /* UnrecognisedJoin */ 2) {
+                    matchResult = 0;
+                    j = (value(matchValue_2) as Join<2>).fields[0];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0:
+                    return singleton_1<string>(`join ${j!}`);
+                default: {
+                    return empty_1<string>();
+                }
+            }
+        }));
+    }, t_4.Conditions), delay<string>((): Iterable<string> => {
+        const matchValue_3: Timing_$union = t_4.Timing;
+        if (matchValue_3.tag === /* UnrecognisedTiming */ 3) {
+            return singleton_1<string>(`event ${matchValue_3.fields[0]}`);
+        }
+        else {
+            return empty_1<string>();
+        }
+    })))), live)), {
+        Equals: (x_2: string, y_2: string): boolean => (x_2 === y_2),
+        GetHashCode: stringHash,
+    }), {
+        Compare: comparePrimitives,
+    });
+    if (isEmpty(kinds)) {
+        if (isEmpty(conditions)) {
+            return undefined;
+        }
+        else {
+            return (arg = join(", ", conditions), toText(printf("refused — its triggers state what the CoreMR trigger domain cannot evaluate yet: %s. Nothing is imported rather than a pathway that cannot be evaluated."))(arg));
+        }
+    }
+    else {
+        return (arg_1 = join(", ", kinds), toText(printf("refused — its triggers use action kinds the 5.5.0+10245 converter does not model faithfully yet: %s. Nothing is imported rather than a pathway with invented actions."))(arg_1));
+    }
+}
+
+/**
+ * ⛔ THROWS the `refusalFor` sentence for a form it must refuse. Its one caller (`CoreMRImportPipeline.runPipeline`)
+ * turns any throw into the import's *not converted* reason, so the sentence is what a clinician reads.
+ */
+export function convertFormTriggersToPathway(importedAt: Date, form: TemplateForm, reads: ReleaseAvailability$1_$union<FSharpList<Trigger>>, itemFieldKeyMap: FSharpMap<int32, Shared_FieldKey>): Option<ClinicalPathway_ClinicalPathwaySpec> {
+    let arg: string;
+    const matchValue: Option<string> = refusalFor(form, reads);
+    if (matchValue == null) {
+    }
+    else {
+        throw new Error(value(matchValue));
+    }
+    const nonField: FSharpList<string> = List_distinct<string>(collect<Trigger, string>((t: Trigger): FSharpList<string> => choose<StatedCondition, string>((c: StatedCondition): Option<string> => {
+        const matchValue_1: Option<int32> = c.SourceItem;
+        let matchResult: int32, item_1: int32;
+        if (matchValue_1 != null) {
+            if (!FSharpMap__ContainsKey(itemFieldKeyMap, value(matchValue_1))) {
+                matchResult = 0;
+                item_1 = value(matchValue_1);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return `trigger ${t.TriggerId} reads item ${item_1!}`;
+            default:
+                return undefined;
+        }
+    }, t.Conditions), liveTriggers(form, reads)), {
+        Equals: (x: string, y: string): boolean => (x === y),
+        GetHashCode: stringHash,
+    });
+    if (isEmpty(nonField)) {
+    }
+    else {
+        throw new Error((arg = join(", ", nonField), toText(printf("refused — its triggers read items that are not fields of this blueprint, so their branches could never fire: %s. Nothing is imported rather than a pathway with branches that can never fire."))(arg)));
+    }
+    const matchValue_2: FSharpList<Trigger> = liveTriggers(form, reads);
+    if (!isEmpty(matchValue_2)) {
+        if (isEmpty(tail(matchValue_2))) {
+            return convertTriggerToPathway(importedAt, head_1(matchValue_2), form.Items, itemFieldKeyMap);
+        }
+        else {
+            const pathwayId = `form_${form.FormId}_pathway`;
+            const startKey: Shared_StateKey = new Shared_StateKey(stableGuid(`${pathwayId}_start`));
+            let allStates: FSharpList<ClinicalPathway_StateDefinition> = singleton(new ClinicalPathway_StateDefinition(startKey, "Start", 0, ClinicalPathway_StateType_Evaluation(new ClinicalPathway_EvaluationInfo("", undefined)), undefined));
+            let allTransitions: FSharpList<ClinicalPathway_TransitionDefinition> = empty<ClinicalPathway_TransitionDefinition>();
+            const enumerator: IEnumerator<[int32, Trigger]> = getEnumerator(indexed<Trigger>(matchValue_2));
+            try {
+                while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                    const forLoopVar: [int32, Trigger] = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const trigger: Trigger = forLoopVar[1];
+                    const idx: int32 = forLoopVar[0] | 0;
+                    const tid: int32 = trigger.TriggerId | 0;
+                    const evalKey: Shared_StateKey = new Shared_StateKey(stableGuid(`${pathwayId}_eval_${tid}`));
+                    const actionKey: Shared_StateKey = new Shared_StateKey(stableGuid(`${pathwayId}_action_${tid}`));
+                    const endKey: Shared_StateKey = new Shared_StateKey(stableGuid(`${pathwayId}_end_${tid}`));
+                    const evalState: ClinicalPathway_StateDefinition = new ClinicalPathway_StateDefinition(evalKey, generateEvaluationLabel(trigger, form.Items), (idx * 3) + 1, ClinicalPathway_StateType_Evaluation(new ClinicalPathway_EvaluationInfo("", undefined)), undefined);
+                    const actionState: ClinicalPathway_StateDefinition = new ClinicalPathway_StateDefinition(actionKey, generateActionLabel(trigger), (idx * 3) + 2, actionStateType(trigger), undefined);
+                    const endState: ClinicalPathway_StateDefinition = new ClinicalPathway_StateDefinition(endKey, "Complete", (idx * 3) + 3, ClinicalPathway_StateType_Terminal(new ClinicalPathway_TerminalInfo("Complete", `Trigger ${tid} complete`, undefined)), undefined);
+                    const condition: ClinicalPathway_TransitionCondition_$union = combineConditions(form.Items, trigger.Conditions, itemFieldKeyMap);
+                    const transitions: FSharpList<ClinicalPathway_TransitionDefinition> = ofArray([new ClinicalPathway_TransitionDefinition(new Shared_TransitionKey(stableGuid(`${pathwayId}_start_to_eval_${tid}`)), startKey, evalKey, ClinicalPathway_TransitionCondition_Always(), idx), new ClinicalPathway_TransitionDefinition(new Shared_TransitionKey(stableGuid(`${pathwayId}_eval_to_action_${tid}`)), evalKey, actionKey, condition, idx), new ClinicalPathway_TransitionDefinition(new Shared_TransitionKey(stableGuid(`${pathwayId}_action_to_end_${tid}`)), actionKey, endKey, ClinicalPathway_TransitionCondition_Always(), undefined)]);
+                    allStates = append(allStates, ofArray([evalState, actionState, endState]));
+                    allTransitions = append(allTransitions, transitions);
+                }
+            }
+            finally {
+                disposeSafe(enumerator as IDisposable);
+            }
+            return new ClinicalPathway_ClinicalPathwaySpec(pathwayId, `${form.Name} - Clinical Pathway`, "1.0.0", "CoreMR Conduit - Unified Item Triggers", ClinicalPathway_PathwayExecutionMode_MultiPathway(new ClinicalPathway_MultiPathwayConfig(ClinicalPathway_CombinationStrategy_AllMatching(), ClinicalPathway_ConflictResolution_CombineActions(), undefined)), startKey, allStates, allTransitions, empty<ClinicalPathway_ConstraintDefinition>(), empty<ClinicalPathway_PathRequirement>(), importedAt, undefined, undefined, 1);
+        }
+    }
+    else {
+        return undefined;
+    }
+}
+
+//# sourceMappingURL=CoreMRPathwayMapper.ts.map