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

package/src/FormSpec.FS/Integrations/Adapters/CorEMR/CoreMRImporterAnalysis.ts

@@ -0,0 +1,1059 @@
+import { FSharpRef, Union, Record } from "@fable-org/fable-library-js/Types.js";
+import { float64, int32 } from "@fable-org/fable-library-js/Int32.js";
+import { TriggerCondition, ReleaseAvailability_describe, ReleaseAvailability_statedTrue, TriggerAction, ItemTrigger, ReleaseAvailability_readList, TemplateItem, InstrumentMapEntry, TemplateForm_$reflection, TriggerStats_$reflection, ReleaseAvailability$1_$reflection, ScoringCatalog_$reflection, TemplateStats_$reflection, CoreEmrInfo_$reflection, TemplateForm, TriggerStats, ScoringCatalog, ReleaseAvailability$1_$union, TemplateStats, CoreEmrInfo } from "../../CorEMR/FormTemplateDecoder.js";
+import { map as map_2, find, tryFind, empty as empty_1, ofList, toList, FSharpMap } from "@fable-org/fable-library-js/Map.js";
+import { round, int64ToString, equals, int32ToString, defaultOf, numberHash, arrayHash, equalArrays, stringHash, comparePrimitives, IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { getUnionFields, name as name_2, tuple_type, float64_type, list_type, bool_type, option_type, union_type, record_type, class_type, string_type, int32_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { FSharpResult$2_Error, FSharpResult$2_$union, FSharpResult$2_Ok } from "@fable-org/fable-library-js/Result.js";
+import { ServedFacts, runPipeline, instrumentsOfScoring } from "./CoreMRImportPipeline.js";
+import { bind, orElse, defaultArg, value as value_3, map as map_1, Option } from "@fable-org/fable-library-js/Option.js";
+import { map2, append, tryHead, find as find_1, zip, tryFind as tryFind_1, truncate, choose, empty, isEmpty, ofArray, exists, sortBy, length, sumBy, filter, sortByDescending, collect, map, FSharpList } from "@fable-org/fable-library-js/List.js";
+import { Spec_FormStep$1, Spec_FormField$1, Shared_FieldKey, ClinicalPathway_TransitionCondition_$union, ClinicalPathway_LogicalOp_$union, Shared_ConditionValue_$union, ClinicalPathway_FieldEvaluator_$union, ClinicalPathway_ActionInfo_$union, Spec_FormSpec$1_$reflection, Spec_FieldType_$reflection, Spec_FieldType_$union, Spec_FormSpec$1 } from "../../../FormSpec.js";
+import { List_distinctBy, List_groupBy, List_countBy } from "@fable-org/fable-library-js/Seq2.js";
+import { tryGetValue } from "@fable-org/fable-library-js/MapUtil.js";
+import { split, isNullOrEmpty, join, compare } from "@fable-org/fable-library-js/String.js";
+import { toList as toList_1 } from "@fable-org/fable-library-js/Set.js";
+import { ActionRead_$union, StatedAction, StatedCondition, Trigger } from "../../../../vye-os-contracts-fs/src/CoreMR/FormTemplate.js";
+import { convertAction, convertCondition } from "../../CorEMR/CoreMRPathwayMapper.js";
+import { ElementTypeInfo, getElementTypeInfo } from "./CorEMRElementTypeMap.js";
+import { CoreMRChoiceAnchor, CoreMRStepMap, CoreMRFieldAnchor, CoreMRSourceMap } from "./CoreMRSourceMap.js";
+import { item } from "@fable-org/fable-library-js/Array.js";
+import { max, min } from "@fable-org/fable-library-js/Double.js";
+import { empty as empty_2, singleton, append as append_1, delay, toList as toList_2 } from "@fable-org/fable-library-js/Seq.js";
+import { Auto_generateBoxedEncoder_437914C6, toString } from "../../../../Thoth.Json/packages/Thoth.Json/Encode.js";
+import { ImportOrigin } from "../../../Provenance.js";
+
+export class LandingSource extends Record implements IEquatable<LandingSource>, IComparable<LandingSource> {
+    readonly Version: int32;
+    readonly GeneratedAt: string;
+    readonly GeneratedFrom: string;
+    readonly CoreEmr: CoreEmrInfo;
+    readonly Stats: TemplateStats;
+    readonly Scoring: ReleaseAvailability$1_$union<ScoringCatalog>;
+    readonly Triggers: ReleaseAvailability$1_$union<TriggerStats>;
+    readonly Forms: FSharpMap<string, TemplateForm>;
+    constructor(Version: int32, GeneratedAt: string, GeneratedFrom: string, CoreEmr: CoreEmrInfo, Stats: TemplateStats, Scoring: ReleaseAvailability$1_$union<ScoringCatalog>, Triggers: ReleaseAvailability$1_$union<TriggerStats>, Forms: FSharpMap<string, TemplateForm>) {
+        super();
+        this.Version = (Version | 0);
+        this.GeneratedAt = GeneratedAt;
+        this.GeneratedFrom = GeneratedFrom;
+        this.CoreEmr = CoreEmr;
+        this.Stats = Stats;
+        this.Scoring = Scoring;
+        this.Triggers = Triggers;
+        this.Forms = Forms;
+    }
+}
+
+export function LandingSource_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.LandingSource", [], LandingSource, () => [["Version", int32_type], ["GeneratedAt", string_type], ["GeneratedFrom", string_type], ["CoreEmr", CoreEmrInfo_$reflection()], ["Stats", TemplateStats_$reflection()], ["Scoring", ReleaseAvailability$1_$reflection(ScoringCatalog_$reflection())], ["Triggers", ReleaseAvailability$1_$reflection(TriggerStats_$reflection())], ["Forms", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, TemplateForm_$reflection()])]]);
+}
+
+function ok<$a, $b>(v: $a): FSharpResult$2_$union<$a, $b> {
+    return FSharpResult$2_Ok<$a, $b>(v);
+}
+
+function err<$a, $b>(v: $a): FSharpResult$2_$union<$b, $a> {
+    return FSharpResult$2_Error<$b, $a>(v);
+}
+
+function instrumentsOf(m: LandingSource): FSharpMap<string, InstrumentMapEntry> {
+    return instrumentsOfScoring(m.Scoring);
+}
+
+export type TemplateStatus_$union = 
+    | TemplateStatus<0>
+    | TemplateStatus<1>
+    | TemplateStatus<2>
+    | TemplateStatus<3>
+    | TemplateStatus<4>
+
+export type TemplateStatus_$cases = {
+    0: ["Ready", []],
+    1: ["Issues", []],
+    2: ["Drift", []],
+    3: ["Blocked", []],
+    4: ["New", []]
+}
+
+export function TemplateStatus_Ready() {
+    return new TemplateStatus<0>(0, []);
+}
+
+export function TemplateStatus_Issues() {
+    return new TemplateStatus<1>(1, []);
+}
+
+export function TemplateStatus_Drift() {
+    return new TemplateStatus<2>(2, []);
+}
+
+export function TemplateStatus_Blocked() {
+    return new TemplateStatus<3>(3, []);
+}
+
+export function TemplateStatus_New() {
+    return new TemplateStatus<4>(4, []);
+}
+
+export class TemplateStatus<Tag extends keyof TemplateStatus_$cases> extends Union<Tag, TemplateStatus_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: TemplateStatus_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Ready", "Issues", "Drift", "Blocked", "New"];
+    }
+}
+
+export function TemplateStatus_$reflection(): TypeInfo {
+    return union_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.TemplateStatus", [], TemplateStatus, () => [[], [], [], [], []]);
+}
+
+export type FieldMappingStatus_$union = 
+    | FieldMappingStatus<0>
+    | FieldMappingStatus<1>
+
+export type FieldMappingStatus_$cases = {
+    0: ["Mapped", []],
+    1: ["Unsupported", []]
+}
+
+export function FieldMappingStatus_Mapped() {
+    return new FieldMappingStatus<0>(0, []);
+}
+
+export function FieldMappingStatus_Unsupported() {
+    return new FieldMappingStatus<1>(1, []);
+}
+
+export class FieldMappingStatus<Tag extends keyof FieldMappingStatus_$cases> extends Union<Tag, FieldMappingStatus_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: FieldMappingStatus_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Mapped", "Unsupported"];
+    }
+}
+
+export function FieldMappingStatus_$reflection(): TypeInfo {
+    return union_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.FieldMappingStatus", [], FieldMappingStatus, () => [[], []]);
+}
+
+export type TriggerStatus_$union = 
+    | TriggerStatus<0>
+    | TriggerStatus<1>
+    | TriggerStatus<2>
+    | TriggerStatus<3>
+
+export type TriggerStatus_$cases = {
+    0: ["Equivalent", []],
+    1: ["Partial", []],
+    2: ["Failed", []],
+    3: ["Pending", []]
+}
+
+export function TriggerStatus_Equivalent() {
+    return new TriggerStatus<0>(0, []);
+}
+
+export function TriggerStatus_Partial() {
+    return new TriggerStatus<1>(1, []);
+}
+
+export function TriggerStatus_Failed() {
+    return new TriggerStatus<2>(2, []);
+}
+
+export function TriggerStatus_Pending() {
+    return new TriggerStatus<3>(3, []);
+}
+
+export class TriggerStatus<Tag extends keyof TriggerStatus_$cases> extends Union<Tag, TriggerStatus_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: TriggerStatus_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Equivalent", "Partial", "Failed", "Pending"];
+    }
+}
+
+export function TriggerStatus_$reflection(): TypeInfo {
+    return union_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.TriggerStatus", [], TriggerStatus, () => [[], [], [], []]);
+}
+
+export type EquivalenceStatus_$union = 
+    | EquivalenceStatus<0>
+    | EquivalenceStatus<1>
+    | EquivalenceStatus<2>
+
+export type EquivalenceStatus_$cases = {
+    0: ["EquivEquivalent", []],
+    1: ["EquivMismatch", []],
+    2: ["EquivMissing", []]
+}
+
+export function EquivalenceStatus_EquivEquivalent() {
+    return new EquivalenceStatus<0>(0, []);
+}
+
+export function EquivalenceStatus_EquivMismatch() {
+    return new EquivalenceStatus<1>(1, []);
+}
+
+export function EquivalenceStatus_EquivMissing() {
+    return new EquivalenceStatus<2>(2, []);
+}
+
+export class EquivalenceStatus<Tag extends keyof EquivalenceStatus_$cases> extends Union<Tag, EquivalenceStatus_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: EquivalenceStatus_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["EquivEquivalent", "EquivMismatch", "EquivMissing"];
+    }
+}
+
+export function EquivalenceStatus_$reflection(): TypeInfo {
+    return union_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.EquivalenceStatus", [], EquivalenceStatus, () => [[], [], []]);
+}
+
+export class Manifest extends Record implements IEquatable<Manifest>, IComparable<Manifest> {
+    readonly Source: string;
+    readonly GeneratedAt: string;
+    readonly Version: string;
+    readonly CoreEmrApp: string;
+    readonly CoreEmrSchema: string;
+    readonly SchemaRev: string;
+    readonly Forms: int32;
+    readonly WithCodes: int32;
+    readonly WithScoring: int32;
+    readonly InstrumentTotal: int32;
+    readonly InstrumentCurrent: int32;
+    readonly InstrumentArchived: int32;
+    readonly ScoringFrom: Option<string>;
+    readonly TriggersFrom: Option<string>;
+    constructor(Source: string, GeneratedAt: string, Version: string, CoreEmrApp: string, CoreEmrSchema: string, SchemaRev: string, Forms: int32, WithCodes: int32, WithScoring: int32, InstrumentTotal: int32, InstrumentCurrent: int32, InstrumentArchived: int32, ScoringFrom: Option<string>, TriggersFrom: Option<string>) {
+        super();
+        this.Source = Source;
+        this.GeneratedAt = GeneratedAt;
+        this.Version = Version;
+        this.CoreEmrApp = CoreEmrApp;
+        this.CoreEmrSchema = CoreEmrSchema;
+        this.SchemaRev = SchemaRev;
+        this.Forms = (Forms | 0);
+        this.WithCodes = (WithCodes | 0);
+        this.WithScoring = (WithScoring | 0);
+        this.InstrumentTotal = (InstrumentTotal | 0);
+        this.InstrumentCurrent = (InstrumentCurrent | 0);
+        this.InstrumentArchived = (InstrumentArchived | 0);
+        this.ScoringFrom = ScoringFrom;
+        this.TriggersFrom = TriggersFrom;
+    }
+}
+
+export function Manifest_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.Manifest", [], Manifest, () => [["Source", string_type], ["GeneratedAt", string_type], ["Version", string_type], ["CoreEmrApp", string_type], ["CoreEmrSchema", string_type], ["SchemaRev", string_type], ["Forms", int32_type], ["WithCodes", int32_type], ["WithScoring", int32_type], ["InstrumentTotal", int32_type], ["InstrumentCurrent", int32_type], ["InstrumentArchived", int32_type], ["ScoringFrom", option_type(string_type)], ["TriggersFrom", option_type(string_type)]]);
+}
+
+export class TemplateListItem extends Record implements IEquatable<TemplateListItem>, IComparable<TemplateListItem> {
+    readonly TemplateId: string;
+    readonly TemplateCode: string;
+    readonly TemplateName: string;
+    readonly Classification: Option<string>;
+    readonly FieldCount: int32;
+    readonly TriggerCount: int32;
+    readonly HasScoring: boolean;
+    readonly HasBlueprintCode: boolean;
+    readonly HasInstrumentMapping: boolean;
+    readonly IsIntake: boolean;
+    readonly EncounterTypes: FSharpList<string>;
+    readonly IssueCount: int32;
+    readonly Instrument: Option<string>;
+    readonly LastImported: Option<string>;
+    constructor(TemplateId: string, TemplateCode: string, TemplateName: string, Classification: Option<string>, FieldCount: int32, TriggerCount: int32, HasScoring: boolean, HasBlueprintCode: boolean, HasInstrumentMapping: boolean, IsIntake: boolean, EncounterTypes: FSharpList<string>, IssueCount: int32, Instrument: Option<string>, LastImported: Option<string>) {
+        super();
+        this.TemplateId = TemplateId;
+        this.TemplateCode = TemplateCode;
+        this.TemplateName = TemplateName;
+        this.Classification = Classification;
+        this.FieldCount = (FieldCount | 0);
+        this.TriggerCount = (TriggerCount | 0);
+        this.HasScoring = HasScoring;
+        this.HasBlueprintCode = HasBlueprintCode;
+        this.HasInstrumentMapping = HasInstrumentMapping;
+        this.IsIntake = IsIntake;
+        this.EncounterTypes = EncounterTypes;
+        this.IssueCount = (IssueCount | 0);
+        this.Instrument = Instrument;
+        this.LastImported = LastImported;
+    }
+}
+
+export function TemplateListItem_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.TemplateListItem", [], TemplateListItem, () => [["TemplateId", string_type], ["TemplateCode", string_type], ["TemplateName", string_type], ["Classification", option_type(string_type)], ["FieldCount", int32_type], ["TriggerCount", int32_type], ["HasScoring", bool_type], ["HasBlueprintCode", bool_type], ["HasInstrumentMapping", bool_type], ["IsIntake", bool_type], ["EncounterTypes", list_type(string_type)], ["IssueCount", int32_type], ["Instrument", option_type(string_type)], ["LastImported", option_type(string_type)]]);
+}
+
+export class ConditionEquivalence extends Record implements IEquatable<ConditionEquivalence>, IComparable<ConditionEquivalence> {
+    readonly CoreEmrCondition: string;
+    readonly F1Condition: string;
+    readonly Status: EquivalenceStatus_$union;
+    constructor(CoreEmrCondition: string, F1Condition: string, Status: EquivalenceStatus_$union) {
+        super();
+        this.CoreEmrCondition = CoreEmrCondition;
+        this.F1Condition = F1Condition;
+        this.Status = Status;
+    }
+}
+
+export function ConditionEquivalence_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.ConditionEquivalence", [], ConditionEquivalence, () => [["CoreEmrCondition", string_type], ["F1Condition", string_type], ["Status", EquivalenceStatus_$reflection()]]);
+}
+
+export class ActionEquivalence extends Record implements IEquatable<ActionEquivalence>, IComparable<ActionEquivalence> {
+    readonly CoreEmrAction: string;
+    readonly F1Action: string;
+    readonly Status: EquivalenceStatus_$union;
+    constructor(CoreEmrAction: string, F1Action: string, Status: EquivalenceStatus_$union) {
+        super();
+        this.CoreEmrAction = CoreEmrAction;
+        this.F1Action = F1Action;
+        this.Status = Status;
+    }
+}
+
+export function ActionEquivalence_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.ActionEquivalence", [], ActionEquivalence, () => [["CoreEmrAction", string_type], ["F1Action", string_type], ["Status", EquivalenceStatus_$reflection()]]);
+}
+
+export class TriggerMapping extends Record implements IEquatable<TriggerMapping>, IComparable<TriggerMapping> {
+    readonly TriggerId: int32;
+    readonly Event: string;
+    readonly ConditionCount: int32;
+    readonly ActionCount: int32;
+    readonly TransitionName: string;
+    readonly TransitionFrom: string;
+    readonly TransitionTo: string;
+    readonly Status: TriggerStatus_$union;
+    readonly Conditions: FSharpList<ConditionEquivalence>;
+    readonly Actions: FSharpList<ActionEquivalence>;
+    constructor(TriggerId: int32, Event$: string, ConditionCount: int32, ActionCount: int32, TransitionName: string, TransitionFrom: string, TransitionTo: string, Status: TriggerStatus_$union, Conditions: FSharpList<ConditionEquivalence>, Actions: FSharpList<ActionEquivalence>) {
+        super();
+        this.TriggerId = (TriggerId | 0);
+        this.Event = Event$;
+        this.ConditionCount = (ConditionCount | 0);
+        this.ActionCount = (ActionCount | 0);
+        this.TransitionName = TransitionName;
+        this.TransitionFrom = TransitionFrom;
+        this.TransitionTo = TransitionTo;
+        this.Status = Status;
+        this.Conditions = Conditions;
+        this.Actions = Actions;
+    }
+}
+
+export function TriggerMapping_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.TriggerMapping", [], TriggerMapping, () => [["TriggerId", int32_type], ["Event", string_type], ["ConditionCount", int32_type], ["ActionCount", int32_type], ["TransitionName", string_type], ["TransitionFrom", string_type], ["TransitionTo", string_type], ["Status", TriggerStatus_$reflection()], ["Conditions", list_type(ConditionEquivalence_$reflection())], ["Actions", list_type(ActionEquivalence_$reflection())]]);
+}
+
+export class FieldMapping extends Record implements IEquatable<FieldMapping>, IComparable<FieldMapping> {
+    readonly FieldId: string;
+    readonly ItemId: int32;
+    readonly Order: int32;
+    readonly Label: Option<string>;
+    readonly F1Type: string;
+    readonly CoreEmrType: int32;
+    readonly CoreEmrTypeName: string;
+    readonly ChoiceScores: string;
+    readonly Code: Option<string>;
+    readonly Required: boolean;
+    readonly Options: int32;
+    readonly ScoreSignal: string;
+    readonly MappingNotes: string;
+    readonly Status: FieldMappingStatus_$union;
+    readonly Triggers: FSharpList<TriggerMapping>;
+    constructor(FieldId: string, ItemId: int32, Order: int32, Label: Option<string>, F1Type: string, CoreEmrType: int32, CoreEmrTypeName: string, ChoiceScores: string, Code: Option<string>, Required: boolean, Options: int32, ScoreSignal: string, MappingNotes: string, Status: FieldMappingStatus_$union, Triggers: FSharpList<TriggerMapping>) {
+        super();
+        this.FieldId = FieldId;
+        this.ItemId = (ItemId | 0);
+        this.Order = (Order | 0);
+        this.Label = Label;
+        this.F1Type = F1Type;
+        this.CoreEmrType = (CoreEmrType | 0);
+        this.CoreEmrTypeName = CoreEmrTypeName;
+        this.ChoiceScores = ChoiceScores;
+        this.Code = Code;
+        this.Required = Required;
+        this.Options = (Options | 0);
+        this.ScoreSignal = ScoreSignal;
+        this.MappingNotes = MappingNotes;
+        this.Status = Status;
+        this.Triggers = Triggers;
+    }
+}
+
+export function FieldMapping_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.FieldMapping", [], FieldMapping, () => [["FieldId", string_type], ["ItemId", int32_type], ["Order", int32_type], ["Label", option_type(string_type)], ["F1Type", string_type], ["CoreEmrType", int32_type], ["CoreEmrTypeName", string_type], ["ChoiceScores", string_type], ["Code", option_type(string_type)], ["Required", bool_type], ["Options", int32_type], ["ScoreSignal", string_type], ["MappingNotes", string_type], ["Status", FieldMappingStatus_$reflection()], ["Triggers", list_type(TriggerMapping_$reflection())]]);
+}
+
+export class StepMapping extends Record implements IEquatable<StepMapping>, IComparable<StepMapping> {
+    readonly StepOrder: int32;
+    readonly StepLabel: Option<string>;
+    readonly Fields: FSharpList<FieldMapping>;
+    constructor(StepOrder: int32, StepLabel: Option<string>, Fields: FSharpList<FieldMapping>) {
+        super();
+        this.StepOrder = (StepOrder | 0);
+        this.StepLabel = StepLabel;
+        this.Fields = Fields;
+    }
+}
+
+export function StepMapping_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.StepMapping", [], StepMapping, () => [["StepOrder", int32_type], ["StepLabel", option_type(string_type)], ["Fields", list_type(FieldMapping_$reflection())]]);
+}
+
+export class TemplateMapping extends Record implements IEquatable<TemplateMapping>, IComparable<TemplateMapping> {
+    readonly TemplateId: string;
+    readonly TemplateCode: string;
+    readonly TemplateName: string;
+    readonly BlueprintId: string;
+    readonly BlueprintCode: string;
+    readonly BlueprintName: string;
+    readonly Classification: Option<string>;
+    readonly Readiness: float64;
+    readonly Status: TemplateStatus_$union;
+    readonly TotalFields: int32;
+    readonly ChoiceFields: int32;
+    readonly BitmaskFields: int32;
+    readonly BitmaskCoverage: float64;
+    readonly CodeCoverage: float64;
+    readonly CodedFieldCount: int32;
+    readonly RequiredDensity: float64;
+    readonly RequiredFieldCount: int32;
+    readonly ScoringSignal: float64;
+    readonly InstrumentMapping: float64;
+    readonly BlueprintCodeAvailable: boolean;
+    readonly TriggerCount: int32;
+    readonly TriggeredFieldCount: int32;
+    readonly TriggerActionBreakdown: FSharpMap<string, int32>;
+    readonly IsIntake: boolean;
+    readonly IsScored: boolean;
+    readonly EncounterTypes: FSharpList<string>;
+    readonly Usage: Option<string>;
+    readonly HasSignature: boolean;
+    readonly StructureHash: string;
+    readonly FormSpec: Spec_FormSpec$1<Spec_FieldType_$union>;
+    readonly FormSpecJson: string;
+    readonly Steps: FSharpList<StepMapping>;
+    constructor(TemplateId: string, TemplateCode: string, TemplateName: string, BlueprintId: string, BlueprintCode: string, BlueprintName: string, Classification: Option<string>, Readiness: float64, Status: TemplateStatus_$union, TotalFields: int32, ChoiceFields: int32, BitmaskFields: int32, BitmaskCoverage: float64, CodeCoverage: float64, CodedFieldCount: int32, RequiredDensity: float64, RequiredFieldCount: int32, ScoringSignal: float64, InstrumentMapping: float64, BlueprintCodeAvailable: boolean, TriggerCount: int32, TriggeredFieldCount: int32, TriggerActionBreakdown: FSharpMap<string, int32>, IsIntake: boolean, IsScored: boolean, EncounterTypes: FSharpList<string>, Usage: Option<string>, HasSignature: boolean, StructureHash: string, FormSpec: Spec_FormSpec$1<Spec_FieldType_$union>, FormSpecJson: string, Steps: FSharpList<StepMapping>) {
+        super();
+        this.TemplateId = TemplateId;
+        this.TemplateCode = TemplateCode;
+        this.TemplateName = TemplateName;
+        this.BlueprintId = BlueprintId;
+        this.BlueprintCode = BlueprintCode;
+        this.BlueprintName = BlueprintName;
+        this.Classification = Classification;
+        this.Readiness = Readiness;
+        this.Status = Status;
+        this.TotalFields = (TotalFields | 0);
+        this.ChoiceFields = (ChoiceFields | 0);
+        this.BitmaskFields = (BitmaskFields | 0);
+        this.BitmaskCoverage = BitmaskCoverage;
+        this.CodeCoverage = CodeCoverage;
+        this.CodedFieldCount = (CodedFieldCount | 0);
+        this.RequiredDensity = RequiredDensity;
+        this.RequiredFieldCount = (RequiredFieldCount | 0);
+        this.ScoringSignal = ScoringSignal;
+        this.InstrumentMapping = InstrumentMapping;
+        this.BlueprintCodeAvailable = BlueprintCodeAvailable;
+        this.TriggerCount = (TriggerCount | 0);
+        this.TriggeredFieldCount = (TriggeredFieldCount | 0);
+        this.TriggerActionBreakdown = TriggerActionBreakdown;
+        this.IsIntake = IsIntake;
+        this.IsScored = IsScored;
+        this.EncounterTypes = EncounterTypes;
+        this.Usage = Usage;
+        this.HasSignature = HasSignature;
+        this.StructureHash = StructureHash;
+        this.FormSpec = FormSpec;
+        this.FormSpecJson = FormSpecJson;
+        this.Steps = Steps;
+    }
+}
+
+export function TemplateMapping_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.TemplateMapping", [], TemplateMapping, () => [["TemplateId", string_type], ["TemplateCode", string_type], ["TemplateName", string_type], ["BlueprintId", string_type], ["BlueprintCode", string_type], ["BlueprintName", string_type], ["Classification", option_type(string_type)], ["Readiness", float64_type], ["Status", TemplateStatus_$reflection()], ["TotalFields", int32_type], ["ChoiceFields", int32_type], ["BitmaskFields", int32_type], ["BitmaskCoverage", float64_type], ["CodeCoverage", float64_type], ["CodedFieldCount", int32_type], ["RequiredDensity", float64_type], ["RequiredFieldCount", int32_type], ["ScoringSignal", float64_type], ["InstrumentMapping", float64_type], ["BlueprintCodeAvailable", bool_type], ["TriggerCount", int32_type], ["TriggeredFieldCount", int32_type], ["TriggerActionBreakdown", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, int32_type])], ["IsIntake", bool_type], ["IsScored", bool_type], ["EncounterTypes", list_type(string_type)], ["Usage", option_type(string_type)], ["HasSignature", bool_type], ["StructureHash", string_type], ["FormSpec", Spec_FormSpec$1_$reflection(Spec_FieldType_$reflection())], ["FormSpecJson", string_type], ["Steps", list_type(StepMapping_$reflection())]]);
+}
+
+export class FormDetail extends Record implements IEquatable<FormDetail>, IComparable<FormDetail> {
+    readonly FormId: int32;
+    readonly FormCode: string;
+    readonly FormName: string;
+    constructor(FormId: int32, FormCode: string, FormName: string) {
+        super();
+        this.FormId = (FormId | 0);
+        this.FormCode = FormCode;
+        this.FormName = FormName;
+    }
+}
+
+export function FormDetail_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.FormDetail", [], FormDetail, () => [["FormId", int32_type], ["FormCode", string_type], ["FormName", string_type]]);
+}
+
+export class TriggerFormStat extends Record implements IEquatable<TriggerFormStat>, IComparable<TriggerFormStat> {
+    readonly FormId: int32;
+    readonly FormCode: string;
+    readonly FormName: string;
+    readonly TriggerCount: int32;
+    constructor(FormId: int32, FormCode: string, FormName: string, TriggerCount: int32) {
+        super();
+        this.FormId = (FormId | 0);
+        this.FormCode = FormCode;
+        this.FormName = FormName;
+        this.TriggerCount = (TriggerCount | 0);
+    }
+}
+
+export function TriggerFormStat_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.TriggerFormStat", [], TriggerFormStat, () => [["FormId", int32_type], ["FormCode", string_type], ["FormName", string_type], ["TriggerCount", int32_type]]);
+}
+
+export class ActionFormDetail extends Record implements IEquatable<ActionFormDetail>, IComparable<ActionFormDetail> {
+    readonly FormId: int32;
+    readonly FormCode: string;
+    readonly FormName: string;
+    readonly Count: int32;
+    constructor(FormId: int32, FormCode: string, FormName: string, Count: int32) {
+        super();
+        this.FormId = (FormId | 0);
+        this.FormCode = FormCode;
+        this.FormName = FormName;
+        this.Count = (Count | 0);
+    }
+}
+
+export function ActionFormDetail_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.ActionFormDetail", [], ActionFormDetail, () => [["FormId", int32_type], ["FormCode", string_type], ["FormName", string_type], ["Count", int32_type]]);
+}
+
+export class InstrumentDetail extends Record implements IEquatable<InstrumentDetail>, IComparable<InstrumentDetail> {
+    readonly FormId: int32;
+    readonly FormCode: string;
+    readonly FormName: string;
+    readonly InstrumentType: string;
+    readonly MaxScore: Option<int32>;
+    readonly Source: string;
+    readonly Archived: boolean;
+    constructor(FormId: int32, FormCode: string, FormName: string, InstrumentType: string, MaxScore: Option<int32>, Source: string, Archived: boolean) {
+        super();
+        this.FormId = (FormId | 0);
+        this.FormCode = FormCode;
+        this.FormName = FormName;
+        this.InstrumentType = InstrumentType;
+        this.MaxScore = MaxScore;
+        this.Source = Source;
+        this.Archived = Archived;
+    }
+}
+
+export function InstrumentDetail_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.InstrumentDetail", [], InstrumentDetail, () => [["FormId", int32_type], ["FormCode", string_type], ["FormName", string_type], ["InstrumentType", string_type], ["MaxScore", option_type(int32_type)], ["Source", string_type], ["Archived", bool_type]]);
+}
+
+export class ManifestStats extends Record implements IEquatable<ManifestStats>, IComparable<ManifestStats> {
+    readonly TotalForms: int32;
+    readonly TotalFields: int32;
+    readonly TotalTriggers: int32;
+    readonly FormsWithTriggers: int32;
+    readonly FormsWithScoring: int32;
+    readonly FormsWithSignature: int32;
+    readonly FormsIntake: int32;
+    readonly EncMedical: int32;
+    readonly EncMental: int32;
+    readonly EncDental: int32;
+    readonly EncOther: int32;
+    readonly EncounterFormMap: FSharpMap<string, FSharpList<FormDetail>>;
+    readonly PropertyFormMap: FSharpMap<string, FSharpList<FormDetail>>;
+    readonly TopFormsByTriggers: FSharpList<TriggerFormStat>;
+    readonly ActionTypeBreakdown: FSharpList<[string, int32]>;
+    readonly ActionTypeFormMap: FSharpMap<string, FSharpList<ActionFormDetail>>;
+    readonly EventTypeBreakdown: FSharpList<[string, int32]>;
+    readonly EventTypeFormMap: FSharpMap<string, FSharpList<FormDetail>>;
+    readonly ExclusiveTagForms: int32;
+    readonly InstrumentTotal: int32;
+    readonly InstrumentCurrent: int32;
+    readonly InstrumentArchived: int32;
+    readonly InstrumentByType: FSharpMap<string, int32>;
+    readonly InstrumentBySource: FSharpMap<string, int32>;
+    readonly InstrumentDetails: FSharpList<InstrumentDetail>;
+    readonly InstrumentTypeDetails: FSharpMap<string, FSharpList<InstrumentDetail>>;
+    readonly InstrumentSourceDetails: FSharpMap<string, FSharpList<InstrumentDetail>>;
+    readonly AppVersion: string;
+    readonly SchemaVersion: string;
+    readonly SchemaRevision: int32;
+    readonly WithCodes: int32;
+    readonly WithSyntheticCodes: int32;
+    constructor(TotalForms: int32, TotalFields: int32, TotalTriggers: int32, FormsWithTriggers: int32, FormsWithScoring: int32, FormsWithSignature: int32, FormsIntake: int32, EncMedical: int32, EncMental: int32, EncDental: int32, EncOther: int32, EncounterFormMap: FSharpMap<string, FSharpList<FormDetail>>, PropertyFormMap: FSharpMap<string, FSharpList<FormDetail>>, TopFormsByTriggers: FSharpList<TriggerFormStat>, ActionTypeBreakdown: FSharpList<[string, int32]>, ActionTypeFormMap: FSharpMap<string, FSharpList<ActionFormDetail>>, EventTypeBreakdown: FSharpList<[string, int32]>, EventTypeFormMap: FSharpMap<string, FSharpList<FormDetail>>, ExclusiveTagForms: int32, InstrumentTotal: int32, InstrumentCurrent: int32, InstrumentArchived: int32, InstrumentByType: FSharpMap<string, int32>, InstrumentBySource: FSharpMap<string, int32>, InstrumentDetails: FSharpList<InstrumentDetail>, InstrumentTypeDetails: FSharpMap<string, FSharpList<InstrumentDetail>>, InstrumentSourceDetails: FSharpMap<string, FSharpList<InstrumentDetail>>, AppVersion: string, SchemaVersion: string, SchemaRevision: int32, WithCodes: int32, WithSyntheticCodes: int32) {
+        super();
+        this.TotalForms = (TotalForms | 0);
+        this.TotalFields = (TotalFields | 0);
+        this.TotalTriggers = (TotalTriggers | 0);
+        this.FormsWithTriggers = (FormsWithTriggers | 0);
+        this.FormsWithScoring = (FormsWithScoring | 0);
+        this.FormsWithSignature = (FormsWithSignature | 0);
+        this.FormsIntake = (FormsIntake | 0);
+        this.EncMedical = (EncMedical | 0);
+        this.EncMental = (EncMental | 0);
+        this.EncDental = (EncDental | 0);
+        this.EncOther = (EncOther | 0);
+        this.EncounterFormMap = EncounterFormMap;
+        this.PropertyFormMap = PropertyFormMap;
+        this.TopFormsByTriggers = TopFormsByTriggers;
+        this.ActionTypeBreakdown = ActionTypeBreakdown;
+        this.ActionTypeFormMap = ActionTypeFormMap;
+        this.EventTypeBreakdown = EventTypeBreakdown;
+        this.EventTypeFormMap = EventTypeFormMap;
+        this.ExclusiveTagForms = (ExclusiveTagForms | 0);
+        this.InstrumentTotal = (InstrumentTotal | 0);
+        this.InstrumentCurrent = (InstrumentCurrent | 0);
+        this.InstrumentArchived = (InstrumentArchived | 0);
+        this.InstrumentByType = InstrumentByType;
+        this.InstrumentBySource = InstrumentBySource;
+        this.InstrumentDetails = InstrumentDetails;
+        this.InstrumentTypeDetails = InstrumentTypeDetails;
+        this.InstrumentSourceDetails = InstrumentSourceDetails;
+        this.AppVersion = AppVersion;
+        this.SchemaVersion = SchemaVersion;
+        this.SchemaRevision = (SchemaRevision | 0);
+        this.WithCodes = (WithCodes | 0);
+        this.WithSyntheticCodes = (WithSyntheticCodes | 0);
+    }
+}
+
+export function ManifestStats_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.ManifestStats", [], ManifestStats, () => [["TotalForms", int32_type], ["TotalFields", int32_type], ["TotalTriggers", int32_type], ["FormsWithTriggers", int32_type], ["FormsWithScoring", int32_type], ["FormsWithSignature", int32_type], ["FormsIntake", int32_type], ["EncMedical", int32_type], ["EncMental", int32_type], ["EncDental", int32_type], ["EncOther", int32_type], ["EncounterFormMap", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, list_type(FormDetail_$reflection())])], ["PropertyFormMap", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, list_type(FormDetail_$reflection())])], ["TopFormsByTriggers", list_type(TriggerFormStat_$reflection())], ["ActionTypeBreakdown", list_type(tuple_type(string_type, int32_type))], ["ActionTypeFormMap", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, list_type(ActionFormDetail_$reflection())])], ["EventTypeBreakdown", list_type(tuple_type(string_type, int32_type))], ["EventTypeFormMap", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, list_type(FormDetail_$reflection())])], ["ExclusiveTagForms", int32_type], ["InstrumentTotal", int32_type], ["InstrumentCurrent", int32_type], ["InstrumentArchived", int32_type], ["InstrumentByType", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, int32_type])], ["InstrumentBySource", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, int32_type])], ["InstrumentDetails", list_type(InstrumentDetail_$reflection())], ["InstrumentTypeDetails", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, list_type(InstrumentDetail_$reflection())])], ["InstrumentSourceDetails", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, list_type(InstrumentDetail_$reflection())])], ["AppVersion", string_type], ["SchemaVersion", string_type], ["SchemaRevision", int32_type], ["WithCodes", int32_type], ["WithSyntheticCodes", int32_type]]);
+}
+
+export function computeStats(m: LandingSource): ManifestStats {
+    let matchValue: ReleaseAvailability$1_$union<ScoringCatalog>;
+    const forms: FSharpList<TemplateForm> = map<[string, TemplateForm], TemplateForm>((tuple: [string, TemplateForm]): TemplateForm => tuple[1], toList<string, TemplateForm>(m.Forms));
+    const toDetail = (f: TemplateForm): FormDetail => (new FormDetail(f.FormId, f.FormCode, f.Name));
+    const allItems: FSharpList<TemplateItem> = collect<TemplateForm, TemplateItem>((f_1: TemplateForm): FSharpList<TemplateItem> => f_1.Items, forms);
+    const allTriggers: FSharpList<ItemTrigger> = collect<TemplateItem, ItemTrigger>((i: TemplateItem): FSharpList<ItemTrigger> => ReleaseAvailability_readList<ItemTrigger>(i.Triggers), allItems);
+    const formsWithTriggerCounts: FSharpList<TriggerFormStat> = sortByDescending<TriggerFormStat, int32>((f_4: TriggerFormStat): int32 => f_4.TriggerCount, filter<TriggerFormStat>((f_3: TriggerFormStat): boolean => (f_3.TriggerCount > 0), map<TemplateForm, TriggerFormStat>((f_2: TemplateForm): TriggerFormStat => (new TriggerFormStat(f_2.FormId, f_2.FormCode, f_2.Name, sumBy<TemplateItem, int32>((i_1: TemplateItem): int32 => length(ReleaseAvailability_readList<ItemTrigger>(i_1.Triggers)), f_2.Items, {
+        GetZero: (): int32 => 0,
+        Add: (x: int32, y: int32): int32 => (x + y),
+    }))), forms)), {
+        Compare: comparePrimitives,
+    });
+    const actionBreakdown: FSharpList<[string, int32]> = sortByDescending<[string, int32], int32>((tuple_1: [string, int32]): int32 => tuple_1[1], List_countBy<string, string>((x_2: string): string => x_2, map<TriggerAction, string>((a: TriggerAction): string => a.ActionType, collect<ItemTrigger, TriggerAction>((t: ItemTrigger): FSharpList<TriggerAction> => t.Actions, allTriggers)), {
+        Equals: (x_3: string, y_2: string): boolean => (x_3 === y_2),
+        GetHashCode: stringHash,
+    }), {
+        Compare: comparePrimitives,
+    });
+    const actionTypeFormMap: FSharpMap<string, FSharpList<ActionFormDetail>> = ofList<string, FSharpList<ActionFormDetail>>(map<[string, FSharpList<[string, int32, string, string]>], [string, FSharpList<ActionFormDetail>]>((tupledArg_1: [string, FSharpList<[string, int32, string, string]>]): [string, FSharpList<ActionFormDetail>] => ([tupledArg_1[0], sortByDescending<ActionFormDetail, int32>((d: ActionFormDetail): int32 => d.Count, map<[[int32, string, string], int32], ActionFormDetail>((tupledArg_3: [[int32, string, string], int32]): ActionFormDetail => {
+        const _arg_4: [int32, string, string] = tupledArg_3[0];
+        return new ActionFormDetail(_arg_4[0], _arg_4[1], _arg_4[2], tupledArg_3[1]);
+    }, List_countBy<[int32, string, string], [int32, string, string]>((x_6: [int32, string, string]): [int32, string, string] => x_6, map<[string, int32, string, string], [int32, string, string]>((tupledArg_2: [string, int32, string, string]): [int32, string, string] => ([tupledArg_2[1], tupledArg_2[2], tupledArg_2[3]] as [int32, string, string]), tupledArg_1[1]), {
+        Equals: equalArrays,
+        GetHashCode: arrayHash,
+    })), {
+        Compare: comparePrimitives,
+    })] as [string, FSharpList<ActionFormDetail>]), List_groupBy<[string, int32, string, string], string>((tupledArg: [string, int32, string, string]): string => tupledArg[0], collect<TemplateForm, [string, int32, string, string]>((f_5: TemplateForm): FSharpList<[string, int32, string, string]> => collect<TemplateItem, [string, int32, string, string]>((i_2: TemplateItem): FSharpList<[string, int32, string, string]> => collect<ItemTrigger, [string, int32, string, string]>((t_1: ItemTrigger): FSharpList<[string, int32, string, string]> => map<TriggerAction, [string, int32, string, string]>((a_1: TriggerAction): [string, int32, string, string] => ([a_1.ActionType, f_5.FormId, f_5.FormCode, f_5.Name] as [string, int32, string, string]), t_1.Actions), ReleaseAvailability_readList<ItemTrigger>(i_2.Triggers)), f_5.Items), forms), {
+        Equals: (x_5: string, y_4: string): boolean => (x_5 === y_4),
+        GetHashCode: stringHash,
+    })), {
+        Compare: comparePrimitives,
+    });
+    const eventBreakdown: FSharpList<[string, int32]> = sortByDescending<[string, int32], int32>((tuple_2: [string, int32]): int32 => tuple_2[1], List_countBy<string, string>((x_10: string): string => x_10, map<ItemTrigger, string>((t_2: ItemTrigger): string => t_2.EventName, allTriggers), {
+        Equals: (x_11: string, y_8: string): boolean => (x_11 === y_8),
+        GetHashCode: stringHash,
+    }), {
+        Compare: comparePrimitives,
+    });
+    const eventTypeFormMap: FSharpMap<string, FSharpList<FormDetail>> = ofList<string, FSharpList<FormDetail>>(map<[string, FSharpList<[string, TemplateForm]>], [string, FSharpList<FormDetail>]>((tupledArg_4: [string, FSharpList<[string, TemplateForm]>]): [string, FSharpList<FormDetail>] => ([tupledArg_4[0], sortBy<FormDetail, string>((d_1: FormDetail): string => d_1.FormName, map<TemplateForm, FormDetail>(toDetail, List_distinctBy<TemplateForm, int32>((f_7: TemplateForm): int32 => f_7.FormId, map<[string, TemplateForm], TemplateForm>((tuple_4: [string, TemplateForm]): TemplateForm => tuple_4[1], tupledArg_4[1]), {
+        Equals: (x_14: int32, y_11: int32): boolean => (x_14 === y_11),
+        GetHashCode: numberHash,
+    })), {
+        Compare: comparePrimitives,
+    })] as [string, FSharpList<FormDetail>]), List_groupBy<[string, TemplateForm], string>((tuple_3: [string, TemplateForm]): string => tuple_3[0], collect<TemplateForm, [string, TemplateForm]>((f_6: TemplateForm): FSharpList<[string, TemplateForm]> => collect<TemplateItem, [string, TemplateForm]>((i_3: TemplateItem): FSharpList<[string, TemplateForm]> => map<ItemTrigger, [string, TemplateForm]>((t_3: ItemTrigger): [string, TemplateForm] => ([t_3.EventName, f_6] as [string, TemplateForm]), ReleaseAvailability_readList<ItemTrigger>(i_3.Triggers)), f_6.Items), forms), {
+        Equals: (x_13: string, y_10: string): boolean => (x_13 === y_10),
+        GetHashCode: stringHash,
+    })), {
+        Compare: comparePrimitives,
+    });
+    const exclusiveTagForms: int32 = length<TemplateForm>(filter<TemplateForm>((f_8: TemplateForm): boolean => exists<TemplateItem>((i_4: TemplateItem): boolean => exists<ItemTrigger>((t_4: ItemTrigger): boolean => (t_4.ExclusiveTag != null), ReleaseAvailability_readList<ItemTrigger>(i_4.Triggers)), f_8.Items), forms)) | 0;
+    const encounterFormMap: FSharpMap<string, FSharpList<FormDetail>> = ofList<string, FSharpList<FormDetail>>(ofArray([["Medical", map<TemplateForm, FormDetail>(toDetail, filter<TemplateForm>((f_9: TemplateForm): boolean => f_9.EncounterTypes.Medical, forms))] as [string, FSharpList<FormDetail>], ["Mental", map<TemplateForm, FormDetail>(toDetail, filter<TemplateForm>((f_10: TemplateForm): boolean => f_10.EncounterTypes.Mental, forms))] as [string, FSharpList<FormDetail>], ["Dental", map<TemplateForm, FormDetail>(toDetail, filter<TemplateForm>((f_11: TemplateForm): boolean => f_11.EncounterTypes.Dental, forms))] as [string, FSharpList<FormDetail>], ["Other", map<TemplateForm, FormDetail>(toDetail, filter<TemplateForm>((f_12: TemplateForm): boolean => ReleaseAvailability_statedTrue(f_12.EncounterTypes.Other), forms))] as [string, FSharpList<FormDetail>]]), {
+        Compare: comparePrimitives,
+    });
+    const formsWithTriggerDetails: FSharpList<FormDetail> = map<TemplateForm, FormDetail>(toDetail, filter<TemplateForm>((f_13: TemplateForm): boolean => exists<TemplateItem>((i_5: TemplateItem): boolean => !isEmpty(ReleaseAvailability_readList<ItemTrigger>(i_5.Triggers)), f_13.Items), forms));
+    const propertyFormMap: FSharpMap<string, FSharpList<FormDetail>> = ofList<string, FSharpList<FormDetail>>(ofArray([["WithCodes", map<TemplateForm, FormDetail>(toDetail, filter<TemplateForm>((f_14: TemplateForm): boolean => (f_14.FormCodeSource !== "generated"), forms))] as [string, FSharpList<FormDetail>], ["WithTriggers", formsWithTriggerDetails] as [string, FSharpList<FormDetail>], ["WithScoring", map<TemplateForm, FormDetail>(toDetail, filter<TemplateForm>((f_15: TemplateForm): boolean => (f_15.Scoring != null), forms))] as [string, FSharpList<FormDetail>], ["Intake", map<TemplateForm, FormDetail>(toDetail, filter<TemplateForm>((f_16: TemplateForm): boolean => f_16.IsIntake, forms))] as [string, FSharpList<FormDetail>], ["RequireSignature", map<TemplateForm, FormDetail>(toDetail, filter<TemplateForm>((f_17: TemplateForm): boolean => f_17.RequiresSignature, forms))] as [string, FSharpList<FormDetail>]]), {
+        Compare: comparePrimitives,
+    });
+    const formsByCode: any = new Map<string, TemplateForm>(map<TemplateForm, [string, TemplateForm]>((f_18: TemplateForm): [string, TemplateForm] => ([f_18.FormCode, f_18] as [string, TemplateForm]), forms));
+    let allInstrumentDetails: FSharpList<InstrumentDetail>;
+    try {
+        allInstrumentDetails = choose<InstrumentMapEntry, InstrumentDetail>((e: InstrumentMapEntry): Option<InstrumentDetail> => {
+            let matchValue_1: [boolean, TemplateForm];
+            let outArg: TemplateForm = defaultOf();
+            matchValue_1 = ([tryGetValue(formsByCode, e.FormCode, new FSharpRef<TemplateForm>((): TemplateForm => outArg, (v: TemplateForm): void => {
+                outArg = v;
+            })), outArg] as [boolean, TemplateForm]);
+            if (matchValue_1[0]) {
+                return new InstrumentDetail(matchValue_1[1].FormId, e.FormCode, e.FormName, e.InstrumentType, e.MaxScore, e.Source, e.Archived);
+            }
+            else {
+                return undefined;
+            }
+        }, map<[string, InstrumentMapEntry], InstrumentMapEntry>((tuple_5: [string, InstrumentMapEntry]): InstrumentMapEntry => tuple_5[1], toList<string, InstrumentMapEntry>((matchValue = m.Scoring, (matchValue.tag === /* NotInRelease */ 1) ? empty_1<string, InstrumentMapEntry>({
+            Compare: comparePrimitives,
+        }) : ((matchValue.tag === /* NotReadYet */ 2) ? empty_1<string, InstrumentMapEntry>({
+            Compare: comparePrimitives,
+        }) : matchValue.fields[0].InstrumentMap)))));
+    }
+    catch (matchValue_2: any) {
+        allInstrumentDetails = empty<InstrumentDetail>();
+    }
+    const instrumentTypeDetails: FSharpMap<string, FSharpList<InstrumentDetail>> = ofList<string, FSharpList<InstrumentDetail>>(List_groupBy<InstrumentDetail, string>((d_2: InstrumentDetail): string => d_2.InstrumentType, allInstrumentDetails, {
+        Equals: (x_20: string, y_17: string): boolean => (x_20 === y_17),
+        GetHashCode: stringHash,
+    }), {
+        Compare: comparePrimitives,
+    });
+    const instrumentSourceDetails: FSharpMap<string, FSharpList<InstrumentDetail>> = ofList<string, FSharpList<InstrumentDetail>>(List_groupBy<InstrumentDetail, string>((d_3: InstrumentDetail): string => d_3.Source, allInstrumentDetails, {
+        Equals: (x_22: string, y_19: string): boolean => (x_22 === y_19),
+        GetHashCode: stringHash,
+    }), {
+        Compare: comparePrimitives,
+    });
+    return new ManifestStats(length(forms), length(allItems), length(allTriggers), length(formsWithTriggerCounts), length<TemplateForm>(filter<TemplateForm>((f_20: TemplateForm): boolean => (f_20.Scoring != null), forms)), length<TemplateForm>(filter<TemplateForm>((f_21: TemplateForm): boolean => f_21.RequiresSignature, forms)), length<TemplateForm>(filter<TemplateForm>((f_22: TemplateForm): boolean => f_22.IsIntake, forms)), length<TemplateForm>(filter<TemplateForm>((f_23: TemplateForm): boolean => f_23.EncounterTypes.Medical, forms)), length<TemplateForm>(filter<TemplateForm>((f_24: TemplateForm): boolean => f_24.EncounterTypes.Mental, forms)), length<TemplateForm>(filter<TemplateForm>((f_25: TemplateForm): boolean => f_25.EncounterTypes.Dental, forms)), length<TemplateForm>(filter<TemplateForm>((f_26: TemplateForm): boolean => ReleaseAvailability_statedTrue(f_26.EncounterTypes.Other), forms)), encounterFormMap, propertyFormMap, truncate<TriggerFormStat>(15, formsWithTriggerCounts), actionBreakdown, actionTypeFormMap, eventBreakdown, eventTypeFormMap, exclusiveTagForms, length(allInstrumentDetails), length<InstrumentDetail>(filter<InstrumentDetail>((d_4: InstrumentDetail): boolean => !d_4.Archived, allInstrumentDetails)), length<InstrumentDetail>(filter<InstrumentDetail>((d_5: InstrumentDetail): boolean => d_5.Archived, allInstrumentDetails)), ofList<string, int32>(List_countBy<InstrumentDetail, string>((d_6: InstrumentDetail): string => d_6.InstrumentType, allInstrumentDetails, {
+        Equals: (x_24: string, y_21: string): boolean => (x_24 === y_21),
+        GetHashCode: stringHash,
+    }), {
+        Compare: comparePrimitives,
+    }), ofList<string, int32>(List_countBy<InstrumentDetail, string>((d_7: InstrumentDetail): string => d_7.Source, allInstrumentDetails, {
+        Equals: (x_26: string, y_23: string): boolean => (x_26 === y_23),
+        GetHashCode: stringHash,
+    }), {
+        Compare: comparePrimitives,
+    }), allInstrumentDetails, instrumentTypeDetails, instrumentSourceDetails, m.CoreEmr.AppVersion, m.CoreEmr.SchemaVersion, m.CoreEmr.SchemaRevision, m.Stats.WithCodes, m.Stats.WithSyntheticCodes);
+}
+
+export function toManifest(m: LandingSource): Manifest {
+    let matchValue: ReleaseAvailability$1_$union<ScoringCatalog>, matchValue_1: ReleaseAvailability$1_$union<ScoringCatalog>, matchValue_2: ReleaseAvailability$1_$union<ScoringCatalog>, matchValue_3: ReleaseAvailability$1_$union<ScoringCatalog>, matchValue_4: ReleaseAvailability$1_$union<ScoringCatalog>, matchValue_5: ReleaseAvailability$1_$union<TriggerStats>;
+    return new Manifest(m.GeneratedFrom, m.GeneratedAt, int32ToString(m.Version), m.CoreEmr.AppVersion, m.CoreEmr.SchemaVersion, int32ToString(m.CoreEmr.SchemaRevision), m.Stats.TotalForms, m.Stats.WithCodes, (matchValue = m.Scoring, (matchValue.tag === /* Stated */ 0) ? matchValue.fields[0].FormsWithScoring : 0), (matchValue_1 = m.Scoring, (matchValue_1.tag === /* Stated */ 0) ? matchValue_1.fields[0].InstrumentMapStats.Total : 0), (matchValue_2 = m.Scoring, (matchValue_2.tag === /* Stated */ 0) ? matchValue_2.fields[0].InstrumentMapStats.Current : 0), (matchValue_3 = m.Scoring, (matchValue_3.tag === /* Stated */ 0) ? matchValue_3.fields[0].InstrumentMapStats.Archived : 0), (matchValue_4 = m.Scoring, (matchValue_4.tag === /* Stated */ 0) ? undefined : ReleaseAvailability_describe<ScoringCatalog>(matchValue_4)), (matchValue_5 = m.Triggers, (matchValue_5.tag === /* Stated */ 0) ? undefined : ReleaseAvailability_describe<TriggerStats>(matchValue_5)));
+}
+
+/**
+ * ⭐ THE INSTRUMENT CATALOG THIS SITE'S RELEASE STATES — empty where it states none.
+ * ⚠️ An empty map here means NOTHING WAS READ, ⛔ never "this site runs no instruments";
+ * `Manifest.ScoringFrom` carries conduit's reason and must be shown wherever these counts are.
+ */
+export function toTemplateListFromMappings(m: LandingSource, mappings: FSharpMap<string, FSharpResult$2_$union<TemplateMapping, FSharpList<string>>>): FSharpList<TemplateListItem> {
+    return map<[string, TemplateForm], TemplateListItem>((tupledArg_1: [string, TemplateForm]): TemplateListItem => {
+        const form: TemplateForm = tupledArg_1[1];
+        const mappingResult: Option<FSharpResult$2_$union<TemplateMapping, FSharpList<string>>> = tryFind<string, FSharpResult$2_$union<TemplateMapping, FSharpList<string>>>(tupledArg_1[0], mappings);
+        let matchResult: int32, mapping: TemplateMapping;
+        if (mappingResult != null) {
+            const copyOfStruct: FSharpResult$2_$union<TemplateMapping, FSharpList<string>> = value_3(mappingResult);
+            if (copyOfStruct.tag === /* Ok */ 0) {
+                matchResult = 0;
+                mapping = copyOfStruct.fields[0];
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0: {
+                const issueCount: int32 = length<FieldMapping>(filter<FieldMapping>((f_1: FieldMapping): boolean => equals(f_1.Status, FieldMappingStatus_Unsupported()), collect<StepMapping, FieldMapping>((s: StepMapping): FSharpList<FieldMapping> => s.Fields, mapping!.Steps))) | 0;
+                return new TemplateListItem(int32ToString(form.FormId), form.FormCode, form.Name, form.Usage, mapping!.TotalFields, mapping!.TriggerCount, mapping!.IsScored, mapping!.BlueprintCodeAvailable, mapping!.InstrumentMapping > 0, mapping!.IsIntake, mapping!.EncounterTypes, issueCount, map_1<InstrumentMapEntry, string>((e_1: InstrumentMapEntry): string => e_1.InstrumentType, tryFind_1<InstrumentMapEntry>((e: InstrumentMapEntry): boolean => {
+                    if (compare(e.FormCode, form.FormCode, 5) === 0) {
+                        return !e.Archived;
+                    }
+                    else {
+                        return false;
+                    }
+                }, map<[string, InstrumentMapEntry], InstrumentMapEntry>((tuple: [string, InstrumentMapEntry]): InstrumentMapEntry => tuple[1], toList<string, InstrumentMapEntry>(instrumentsOf(m))))), undefined);
+            }
+            default: {
+                const triggerCount: int32 = sumBy<TemplateItem, int32>((i: TemplateItem): int32 => length(ReleaseAvailability_readList<ItemTrigger>(i.Triggers)), form.Items, {
+                    GetZero: (): int32 => 0,
+                    Add: (x_1: int32, y_1: int32): int32 => (x_1 + y_1),
+                }) | 0;
+                return new TemplateListItem(int32ToString(form.FormId), form.FormCode, form.Name, form.Usage, length(form.Items), triggerCount, form.Scoring != null, (form.FormCode.length > 0) && !(form.FormCode.indexOf("#") >= 0), false, form.IsIntake, empty<string>(), 0, undefined, undefined);
+            }
+        }
+    }, sortBy<[string, TemplateForm], string>((tupledArg: [string, TemplateForm]): string => tupledArg[1].Name.toLowerCase(), toList<string, TemplateForm>(m.Forms), {
+        Compare: comparePrimitives,
+    }));
+}
+
+function describeActionInfo(ai: ClinicalPathway_ActionInfo_$union): string {
+    switch (ai.tag) {
+        case /* Alert */ 9:
+            return `Alert: ${ai.fields[0].Category}`;
+        case /* Task */ 8:
+            return `Task: ${ai.fields[0].Category}`;
+        case /* Medication */ 0:
+            return `Medication: ${ai.fields[0].Name}`;
+        case /* Treatment */ 1:
+            return `Treatment: ${defaultArg<string>(ai.fields[0].Name, "")}`;
+        case /* Medset */ 2:
+            return `Medset: ${ai.fields[0].Name}`;
+        case /* Problem */ 10:
+            return `Problem: ${defaultArg<string>(ai.fields[0].ProblemName, "")}`;
+        case /* Documentation */ 7:
+            return `Doc: ${ai.fields[0].Purpose}`;
+        case /* Prescription */ 11:
+            return `Rx: ${ai.fields[0].Medication}`;
+        case /* ChangeGroups */ 14:
+            return `Groups: ${length(ai.fields[0].Groups)}`;
+        default:
+            return "Action";
+    }
+}
+
+function describeCondition(tc: ClinicalPathway_TransitionCondition_$union): string {
+    switch (tc.tag) {
+        case /* FieldCondition */ 0: {
+            const evaluator: ClinicalPathway_FieldEvaluator_$union = tc.fields[1];
+            const condValue: Shared_ConditionValue_$union = tc.fields[2];
+            return `field ${(evaluator.tag === /* InSet */ 2) ? (`in [${join(", ", evaluator.fields[0])}]`) : ((evaluator.tag === /* Equals */ 0) ? "equals" : ((evaluator.tag === /* NotEquals */ 1) ? "not equals" : ((evaluator.tag === /* GreaterOrEqual */ 6) ? ">=" : ((evaluator.tag === /* GreaterThan */ 5) ? ">" : ((evaluator.tag === /* LessOrEqual */ 8) ? "<=" : ((evaluator.tag === /* LessThan */ 7) ? "<" : "?"))))))} ${(condValue.tag === /* Single */ 0) ? condValue.fields[0] : ((condValue.tag === /* Multiple */ 1) ? join(", ", toList_1<string>(condValue.fields[0])) : "...")}`;
+        }
+        case /* CompositeCondition */ 6: {
+            const op: ClinicalPathway_LogicalOp_$union = tc.fields[0];
+            const condList: FSharpList<ClinicalPathway_TransitionCondition_$union> = tc.fields[1];
+            const opStr: string = (op.tag === /* And */ 0) ? "AND" : ((op.tag === /* Or */ 1) ? "OR" : "?");
+            return `${length(condList)} conditions (${opStr})`;
+        }
+        case /* Always */ 8:
+            return "always";
+        default:
+            return "condition";
+    }
+}
+
+function toTriggerMapping(items: FSharpList<TemplateItem>, readsById: FSharpMap<int32, Trigger>, trigger: ItemTrigger, itemFieldKeyMap: FSharpMap<int32, Shared_FieldKey>): TriggerMapping {
+    const read: Trigger = find<int32, Trigger>(trigger.TriggerId, readsById);
+    const conditions: FSharpList<ConditionEquivalence> = map<[TriggerCondition, StatedCondition], ConditionEquivalence>((tupledArg: [TriggerCondition, StatedCondition]): ConditionEquivalence => {
+        const c: TriggerCondition = tupledArg[0];
+        let condText: string;
+        const matchValue: FSharpList<string> = c.Values;
+        condText = (isEmpty(matchValue) ? (`${c.Source} ${c.Operator}`) : (`${c.Source} ${c.Operator} [${join(", ", matchValue)}]`));
+        try {
+            return new ConditionEquivalence(condText, describeCondition(convertCondition(items, tupledArg[1], itemFieldKeyMap)), EquivalenceStatus_EquivEquivalent());
+        }
+        catch (matchValue_1: any) {
+            return new ConditionEquivalence(condText, "unsupported", EquivalenceStatus_EquivMissing());
+        }
+    }, zip<TriggerCondition, StatedCondition>(trigger.Conditions, read.Conditions));
+    const actions: FSharpList<ActionEquivalence> = map<TriggerAction, ActionEquivalence>((a: TriggerAction): ActionEquivalence => {
+        const name: string = defaultArg(orElse(tryFind<string, string>("category_name", a.Params), tryFind<string, string>("medset_name", a.Params)), "");
+        const actionText: string = isNullOrEmpty(name) ? a.ActionType : (`${a.ActionType}: ${name}`);
+        let patternInput: [string, EquivalenceStatus_$union];
+        const matchValue_2: ActionRead_$union = find_1<StatedAction>((r: StatedAction): boolean => (r.ActionId === a.ActionId), read.Actions).Read;
+        patternInput = ((matchValue_2.tag === /* Unmodelled */ 1) ? ([`Not modelled: ${matchValue_2.fields[1]}`, EquivalenceStatus_EquivMismatch()] as [string, EquivalenceStatus_$union]) : ([describeActionInfo(convertAction(matchValue_2.fields[0])), EquivalenceStatus_EquivEquivalent()] as [string, EquivalenceStatus_$union]));
+        return new ActionEquivalence(actionText, patternInput[0], patternInput[1]);
+    }, trigger.Actions);
+    const firstAction: Option<TriggerAction> = tryHead<TriggerAction>(trigger.Actions);
+    const allStatuses: FSharpList<EquivalenceStatus_$union> = append(map<ConditionEquivalence, EquivalenceStatus_$union>((c_1: ConditionEquivalence): EquivalenceStatus_$union => c_1.Status, conditions), map<ActionEquivalence, EquivalenceStatus_$union>((a_1: ActionEquivalence): EquivalenceStatus_$union => a_1.Status, actions));
+    const triggerStatus: TriggerStatus_$union = !trigger.Enabled ? TriggerStatus_Pending() : (exists<EquivalenceStatus_$union>((s: EquivalenceStatus_$union): boolean => equals(s, EquivalenceStatus_EquivMissing()), allStatuses) ? TriggerStatus_Failed() : (exists<EquivalenceStatus_$union>((s_1: EquivalenceStatus_$union): boolean => equals(s_1, EquivalenceStatus_EquivMismatch()), allStatuses) ? TriggerStatus_Partial() : TriggerStatus_Equivalent()));
+    return new TriggerMapping(trigger.TriggerId, trigger.EventName, length(trigger.Conditions), length(trigger.Actions), defaultArg(map_1<TriggerAction, string>((a_2: TriggerAction): string => a_2.ActionType, firstAction), "unknown"), "current", defaultArg(bind<TriggerAction, string>((a_3: TriggerAction): Option<string> => tryFind<string, string>("category_name", a_3.Params), firstAction), "action"), triggerStatus, conditions, actions);
+}
+
+function getFieldTypeName(fieldType: Spec_FieldType_$union): string {
+    return name_2(getUnionFields(fieldType, Spec_FieldType_$reflection())[0]);
+}
+
+/**
+ * SSOT: All 27 element types from CorEMRElementTypeMap
+ */
+export function getF1TypeDisplay(typeCode: int32): string {
+    const info: ElementTypeInfo = getElementTypeInfo(typeCode);
+    const matchValue: string = info.Code;
+    switch (matchValue) {
+        case "text":
+            return "Text";
+        case "text_multiline":
+            return "TextArea";
+        case "dropdown":
+            return "Dropdown";
+        case "dropdown_notes":
+            return "Dropdown + Notes";
+        case "dropdown_notes_ui":
+            return "Dropdown";
+        case "chips_notes":
+            return "Multi-Select + Notes";
+        case "chips_ros":
+            return "Multi-Select";
+        case "yes_no_text":
+            return "Radio";
+        case "yes_no_notes":
+            return "Radio + Notes";
+        case "exam_3choice":
+            return "Radio";
+        case "checkbox":
+            return "Checkbox";
+        case "checkbox_notes":
+            return "Checkbox + Notes";
+        case "date":
+            return "Date";
+        case "datetime":
+            return "DateTime";
+        case "signature_date":
+            return "Signature + Date";
+        case "signature":
+            return "Signature";
+        case "heading":
+        case "instructions":
+        case "group_row":
+        case "sub_header":
+            return "Message";
+        case "vitals_widget":
+            return "PluginField";
+        case "allergy_autofill":
+            return "PluginField";
+        case "linked_data":
+        case "linked_data_rare":
+            return "PluginField";
+        case "score_display":
+        case "score_explanation":
+            return "Message";
+        default:
+            return info.Label;
+    }
+}
+
+/**
+ * SSOT: CorEMR type label from the element type map
+ */
+export function getCoreEmrTypeLabel(typeCode: int32): string {
+    return `${getElementTypeInfo(typeCode).Label} (${typeCode})`;
+}
+
+/**
+ * Build TemplateMapping from the REAL FormSpec pipeline + SourceMap parallel zip.
+ * No reconciliation. No label matching. No order guessing.
+ * FormSpec.Steps[i].Fields[j] ↔ SourceMap.Steps[i].FieldAnchors[j] — by design.
+ */
+export function toTemplateMapping(origin: ImportOrigin, importedAt: Date, facts: ServedFacts, form: TemplateForm): FSharpResult$2_$union<TemplateMapping, FSharpList<string>> {
+    const instrumentMapping: float64 = defaultArg(map_1<InstrumentMapEntry, boolean>((e: InstrumentMapEntry): boolean => e.Archived, tryFind<string, InstrumentMapEntry>(int32ToString(form.FormId), facts.Instruments)), false) ? 40 : 100;
+    const hasBlueprintCode: boolean = (form.FormCode.length > 0) && !(form.FormCode.indexOf("#") >= 0);
+    const matchValue: FSharpResult$2_$union<[Spec_FormSpec$1<Spec_FieldType_$union>, CoreMRSourceMap], FSharpList<string>> = runPipeline(origin, importedAt, facts, form);
+    if (matchValue.tag === /* Ok */ 0) {
+        const sourceMap: CoreMRSourceMap = matchValue.fields[0][1];
+        const formSpec: Spec_FormSpec$1<Spec_FieldType_$union> = matchValue.fields[0][0];
+        let readsById: FSharpMap<int32, Trigger>;
+        const matchValue_1: ReleaseAvailability$1_$union<FSharpList<Trigger>> = facts.Triggers;
+        switch (matchValue_1.tag) {
+            case /* NotInRelease */ 1:
+            case /* NotReadYet */ 2: {
+                readsById = empty_1<int32, Trigger>({
+                    Compare: comparePrimitives,
+                });
+                break;
+            }
+            default:
+                readsById = ofList<int32, Trigger>(map<Trigger, [int32, Trigger]>((t: Trigger): [int32, Trigger] => ([t.TriggerId, t] as [int32, Trigger]), matchValue_1.fields[0]), {
+                    Compare: comparePrimitives,
+                });
+        }
+        const fieldKeyMap: FSharpMap<int32, Shared_FieldKey> = ofList<int32, Shared_FieldKey>(map<CoreMRFieldAnchor, [int32, Shared_FieldKey]>((anchor: CoreMRFieldAnchor): [int32, Shared_FieldKey] => ([anchor.ItemId, anchor.FieldKey] as [int32, Shared_FieldKey]), collect<CoreMRStepMap, CoreMRFieldAnchor>((step: CoreMRStepMap): FSharpList<CoreMRFieldAnchor> => step.FieldAnchors, sourceMap.Steps)), {
+            Compare: comparePrimitives,
+        });
+        const finalSteps: FSharpList<StepMapping> = map2<Spec_FormStep$1<Spec_FieldType_$union>, CoreMRStepMap, StepMapping>((fStep: Spec_FormStep$1<Spec_FieldType_$union>, sStep: CoreMRStepMap): StepMapping => (new StepMapping(fStep.StepOrder, fStep.StepLabel, map2<Spec_FormField$1<Spec_FieldType_$union>, CoreMRFieldAnchor, FieldMapping>((field: Spec_FormField$1<Spec_FieldType_$union>, anchor_1: CoreMRFieldAnchor): FieldMapping => {
+            const fieldTypeName: string = getFieldTypeName(field.FieldType);
+            const itemTriggers: FSharpList<TriggerMapping> = map<ItemTrigger, TriggerMapping>((t_1: ItemTrigger): TriggerMapping => toTriggerMapping(form.Items, readsById, t_1, fieldKeyMap), anchor_1.Triggers);
+            return new FieldMapping(`f-${anchor_1.ItemId}`, anchor_1.ItemId, field.FieldOrder, field.Label, fieldTypeName, anchor_1.ItemTypeId, getCoreEmrTypeLabel(anchor_1.ItemTypeId), isEmpty(anchor_1.Choices) ? "-" : join(", ", map<CoreMRChoiceAnchor, string>((c_1: CoreMRChoiceAnchor): string => int64ToString(c_1.Score), sortBy<CoreMRChoiceAnchor, int32>((c: CoreMRChoiceAnchor): int32 => c.Sequence, anchor_1.Choices, {
+                Compare: comparePrimitives,
+            }))), anchor_1.Code, !field.IsOptional, length(anchor_1.Choices), isEmpty(anchor_1.Choices) ? "-" : (`${length(anchor_1.Choices)} scored`), `Item ${anchor_1.ItemId} / SSOT`, (field.FieldType.tag === /* UnsupportedField */ 22) ? FieldMappingStatus_Unsupported() : FieldMappingStatus_Mapped(), itemTriggers);
+        }, fStep.Fields, sStep.FieldAnchors))), formSpec.Steps, sourceMap.Steps);
+        const allFields: FSharpList<FieldMapping> = collect<StepMapping, FieldMapping>((s: StepMapping): FSharpList<FieldMapping> => s.Fields, finalSteps);
+        const totalFields: int32 = length(allFields) | 0;
+        const codedFieldCount: int32 = length<FieldMapping>(filter<FieldMapping>((f: FieldMapping): boolean => (f.Code != null), allFields)) | 0;
+        const requiredFieldCount: int32 = length<FieldMapping>(filter<FieldMapping>((f_1: FieldMapping): boolean => f_1.Required, allFields)) | 0;
+        const choiceFields: int32 = length<FieldMapping>(filter<FieldMapping>((f_2: FieldMapping): boolean => (f_2.Options > 0), allFields)) | 0;
+        const bitmaskFields: int32 = length<FieldMapping>(filter<FieldMapping>((f_3: FieldMapping): boolean => {
+            if (((f_3.CoreEmrType === 26) ? true : (f_3.CoreEmrType === 40)) ? true : (f_3.CoreEmrType === 41)) {
+                return true;
+            }
+            else {
+                return f_3.CoreEmrType === 143;
+            }
+        }, allFields)) | 0;
+        const bitmaskCoverage: float64 = (choiceFields > 0) ? ((bitmaskFields / choiceFields) * 100) : 0;
+        const triggeredFields: FSharpList<FieldMapping> = filter<FieldMapping>((f_4: FieldMapping): boolean => !isEmpty(f_4.Triggers), allFields);
+        const triggerCount: int32 = sumBy<FieldMapping, int32>((f_5: FieldMapping): int32 => length(f_5.Triggers), allFields, {
+            GetZero: (): int32 => 0,
+            Add: (x_4: int32, y_4: int32): int32 => (x_4 + y_4),
+        }) | 0;
+        const triggeredFieldCount: int32 = length(triggeredFields) | 0;
+        const triggerActionBreakdown: FSharpMap<string, int32> = ofList<string, int32>(List_countBy<string, string>((x_5: string): string => x_5, map<ActionEquivalence, string>((a: ActionEquivalence): string => item(0, split(a.CoreEmrAction, [":"], undefined, 0)).trim(), collect<TriggerMapping, ActionEquivalence>((t_2: TriggerMapping): FSharpList<ActionEquivalence> => t_2.Actions, collect<FieldMapping, TriggerMapping>((f_6: FieldMapping): FSharpList<TriggerMapping> => f_6.Triggers, allFields))), {
+            Equals: (x_6: string, y_5: string): boolean => (x_6 === y_5),
+            GetHashCode: stringHash,
+        }), {
+            Compare: comparePrimitives,
+        });
+        const mappedCount: int32 = length<FieldMapping>(filter<FieldMapping>((f_7: FieldMapping): boolean => equals(f_7.Status, FieldMappingStatus_Mapped()), allFields)) | 0;
+        const unsupportedCount: int32 = length<FieldMapping>(filter<FieldMapping>((f_8: FieldMapping): boolean => equals(f_8.Status, FieldMappingStatus_Unsupported()), allFields)) | 0;
+        const instrumentSignal: float64 = instrumentMapping;
+        const pipelineReadiness: float64 = min(100, max(0, (((((totalFields > 0) ? ((mappedCount / totalFields) * 100) : 0) * 0.4) + (((triggerCount > 0) ? 100 : 100) * 0.25)) + ((hasBlueprintCode ? 100 : 0) * 0.2)) + (instrumentSignal * 0.15)));
+        const pipelineStatus: TemplateStatus_$union = (pipelineReadiness >= 75) ? TemplateStatus_Ready() : ((pipelineReadiness >= 50) ? TemplateStatus_Issues() : ((pipelineReadiness >= 25) ? TemplateStatus_Drift() : TemplateStatus_Blocked()));
+        const codeCoverage: float64 = (totalFields > 0) ? ((codedFieldCount / totalFields) * 100) : 0;
+        const requiredDensity: float64 = (totalFields > 0) ? ((requiredFieldCount / totalFields) * 100) : 0;
+        const encounterTypes: FSharpList<string> = toList_2<string>(delay<string>((): Iterable<string> => append_1<string>(form.EncounterTypes.Medical ? singleton<string>("medical") : empty_2<string>(), delay<string>((): Iterable<string> => append_1<string>(form.EncounterTypes.Mental ? singleton<string>("mental") : empty_2<string>(), delay<string>((): Iterable<string> => append_1<string>(form.EncounterTypes.Dental ? singleton<string>("dental") : empty_2<string>(), delay<string>((): Iterable<string> => (ReleaseAvailability_statedTrue(form.EncounterTypes.Other) ? singleton<string>("other") : empty_2<string>())))))))));
+        return ok<TemplateMapping, FSharpList<string>>(new TemplateMapping(int32ToString(form.FormId), form.FormCode, form.Name, formSpec.Id, defaultArg(formSpec.Code, form.FormCode), formSpec.Title, form.Usage, round(pipelineReadiness, 0), pipelineStatus, totalFields, choiceFields, bitmaskFields, round(bitmaskCoverage, 0), round(codeCoverage, 0), codedFieldCount, round(requiredDensity, 0), requiredFieldCount, (form.Scoring != null) ? 100 : 0, round(instrumentSignal, 0), hasBlueprintCode, triggerCount, triggeredFieldCount, triggerActionBreakdown, form.IsIntake, form.Scoring != null, encounterTypes, form.Usage, form.RequiresSignature, form.StructureHash, formSpec, toString(2, Auto_generateBoxedEncoder_437914C6(Spec_FormSpec$1_$reflection(Spec_FieldType_$reflection()), undefined, undefined, undefined)(formSpec)), finalSteps));
+    }
+    else {
+        return FSharpResult$2_Error<TemplateMapping, FSharpList<string>>(matchValue.fields[0]);
+    }
+}
+
+export class LandingAnalysis extends Record implements IEquatable<LandingAnalysis>, IComparable<LandingAnalysis> {
+    readonly Header: Manifest;
+    readonly Stats: ManifestStats;
+    readonly Templates: FSharpList<TemplateListItem>;
+    readonly Verdicts: FSharpMap<string, FSharpList<string>>;
+    readonly Triggers: ReleaseAvailability$1_$union<TriggerStats>;
+    readonly InactiveEverywhere: FSharpList<string>;
+    constructor(Header: Manifest, Stats: ManifestStats, Templates: FSharpList<TemplateListItem>, Verdicts: FSharpMap<string, FSharpList<string>>, Triggers: ReleaseAvailability$1_$union<TriggerStats>, InactiveEverywhere: FSharpList<string>) {
+        super();
+        this.Header = Header;
+        this.Stats = Stats;
+        this.Templates = Templates;
+        this.Verdicts = Verdicts;
+        this.Triggers = Triggers;
+        this.InactiveEverywhere = InactiveEverywhere;
+    }
+}
+
+export function LandingAnalysis_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRImporterAnalysis.LandingAnalysis", [], LandingAnalysis, () => [["Header", Manifest_$reflection()], ["Stats", ManifestStats_$reflection()], ["Templates", list_type(TemplateListItem_$reflection())], ["Verdicts", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, list_type(string_type)])], ["Triggers", ReleaseAvailability$1_$reflection(TriggerStats_$reflection())], ["InactiveEverywhere", list_type(string_type)]]);
+}
+
+/**
+ * The landing over `source`, every template converted by `toTemplateMapping` with ITS OWN facts.
+ * ⭐ The same function Studio runs for one template's tabs — so the list and the tabs cannot disagree.
+ */
+export function analyse(origin: ImportOrigin, importedAt: Date, source: LandingSource, factsOf: ((arg0: TemplateForm) => ServedFacts), activeAtOf: ((arg0: TemplateForm) => FSharpList<int32>)): LandingAnalysis {
+    const mappings: FSharpMap<string, FSharpResult$2_$union<TemplateMapping, FSharpList<string>>> = map_2<string, TemplateForm, FSharpResult$2_$union<TemplateMapping, FSharpList<string>>>((_arg: string, form: TemplateForm): FSharpResult$2_$union<TemplateMapping, FSharpList<string>> => toTemplateMapping(origin, importedAt, factsOf(form), form), source.Forms);
+    return new LandingAnalysis(toManifest(source), computeStats(source), toTemplateListFromMappings(source, mappings), ofList<string, FSharpList<string>>(choose<[string, FSharpResult$2_$union<TemplateMapping, FSharpList<string>>], [string, FSharpList<string>]>((tupledArg: [string, FSharpResult$2_$union<TemplateMapping, FSharpList<string>>]): Option<[string, FSharpList<string>]> => {
+        const r: FSharpResult$2_$union<TemplateMapping, FSharpList<string>> = tupledArg[1];
+        if (r.tag === /* Ok */ 0) {
+            return undefined;
+        }
+        else {
+            return [tupledArg[0], r.fields[0]] as [string, FSharpList<string>];
+        }
+    }, toList<string, FSharpResult$2_$union<TemplateMapping, FSharpList<string>>>(mappings)), {
+        Compare: comparePrimitives,
+    }), source.Triggers, map<[string, TemplateForm], string>((tuple: [string, TemplateForm]): string => tuple[0], filter<[string, TemplateForm]>((tupledArg_1: [string, TemplateForm]): boolean => isEmpty(activeAtOf(tupledArg_1[1])), toList<string, TemplateForm>(source.Forms))));
+}
+
+//# sourceMappingURL=CoreMRImporterAnalysis.ts.map