@f1studio/form-spec 5.0.0-alpha.111 → 5.0.0-alpha.112

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

@@ -0,0 +1,1046 @@
+import { toString as toString_1, MatchFailureException, Record, Union } from "@fable-org/fable-library-js/Types.js";
+import { class_type, list_type, int64_type, bool_type, record_type, float64_type, option_type, string_type, int32_type, union_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { float64, int32 } from "@fable-org/fable-library-js/Int32.js";
+import { value as value_129, map, defaultArg, Option } from "@fable-org/fable-library-js/Option.js";
+import { stringHash, IDisposable, disposeSafe, IEnumerator, getEnumerator, compareArrays, comparePrimitives, IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { fromInt32, toInt64, int64 } from "@fable-org/fable-library-js/BigInt.js";
+import { reverse, length, sortByDescending, cons, sortBy, choose, map as map_2, collect, exists, empty as empty_1, tryFind, head, isEmpty, ofArray, FSharpList } from "@fable-org/fable-library-js/List.js";
+import { FSharpMap__get_IsEmpty, tryFind as tryFind_1, FSharpMap__TryFind, ofList, FSharpMap__ContainsKey, FSharpMap } from "@fable-org/fable-library-js/Map.js";
+import { CoreMRFormData, CoreMRChoice, CoreMRItem, CoreMRTrigger, CoreMRTriggerEvent } from "../../CorEMR/CoreMRTypes.js";
+import { toString, utcNow } from "@fable-org/fable-library-js/Date.js";
+import { matches as matches_1, isMatch, create, match } from "@fable-org/fable-library-js/RegExp.js";
+import { map as map_1, delay, toList } from "@fable-org/fable-library-js/Seq.js";
+import { ClinicalPathway_PathwayExecutionMode_$union, ClinicalPathway_TransitionDefinition, Shared_StateKey, Shared_MatrixItemKey, Shared_FieldOptionKey, Shared_FieldKey, Shared_ConditionValue_$union, ClinicalPathway_TransitionCondition_$union, ClinicalPathway_StateType_$union, ClinicalPathway_StateDefinition, ClinicalPathway_ClinicalPathwaySpec, Spec_FormSpec$1, Spec_FormStep$1, Spec_FormField$1 } from "../../../FormSpec.js";
+import { getElementTypeInfo } from "./CorEMRElementTypeMap.js";
+import { Helpers_generateDeterministicGuidRaw } from "../../../Helpers.js";
+import { substring, startsWith } from "@fable-org/fable-library-js/String.js";
+import { StringBuilder__AppendLine, StringBuilder__AppendLine_Z721C83C5, StringBuilder_$ctor } from "@fable-org/fable-library-js/System.Text.js";
+import { List_groupBy } from "@fable-org/fable-library-js/Seq2.js";
+import { newGuid } from "@fable-org/fable-library-js/Guid.js";
+
+export type ComplexityLevel_$union = 
+    | ComplexityLevel<0>
+    | ComplexityLevel<1>
+    | ComplexityLevel<2>
+
+export type ComplexityLevel_$cases = {
+    0: ["Essential", []],
+    1: ["Standard", []],
+    2: ["Advanced", []]
+}
+
+export function ComplexityLevel_Essential() {
+    return new ComplexityLevel<0>(0, []);
+}
+
+export function ComplexityLevel_Standard() {
+    return new ComplexityLevel<1>(1, []);
+}
+
+export function ComplexityLevel_Advanced() {
+    return new ComplexityLevel<2>(2, []);
+}
+
+export class ComplexityLevel<Tag extends keyof ComplexityLevel_$cases> extends Union<Tag, ComplexityLevel_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ComplexityLevel_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Essential", "Standard", "Advanced"];
+    }
+}
+
+export function ComplexityLevel_$reflection(): TypeInfo {
+    return union_type("FormSpec.Integrations.CorEMR.CorEMRSemanticReportBuilder.ComplexityLevel", [], ComplexityLevel, () => [[], [], []]);
+}
+
+/**
+ * Get emoji representation of complexity
+ */
+export function complexityToEmoji(_arg: ComplexityLevel_$union): string {
+    switch (_arg.tag) {
+        case /* Standard */ 1:
+            return "🟡";
+        case /* Advanced */ 2:
+            return "🔴";
+        default:
+            return "🟢";
+    }
+}
+
+/**
+ * Get string representation of complexity
+ */
+export function complexityToString(_arg: ComplexityLevel_$union): string {
+    switch (_arg.tag) {
+        case /* Standard */ 1:
+            return "Standard";
+        case /* Advanced */ 2:
+            return "Advanced";
+        default:
+            return "Essential";
+    }
+}
+
+export class InstructionItem extends Record implements IEquatable<InstructionItem>, IComparable<InstructionItem> {
+    readonly ItemId: int32;
+    readonly ItemType: int32;
+    readonly Text: string;
+    readonly Pattern: Option<string>;
+    readonly Confidence: float64;
+    readonly Complexity: ComplexityLevel_$union;
+    constructor(ItemId: int32, ItemType: int32, Text$: string, Pattern: Option<string>, Confidence: float64, Complexity: ComplexityLevel_$union) {
+        super();
+        this.ItemId = (ItemId | 0);
+        this.ItemType = (ItemType | 0);
+        this.Text = Text$;
+        this.Pattern = Pattern;
+        this.Confidence = Confidence;
+        this.Complexity = Complexity;
+    }
+}
+
+export function InstructionItem_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CorEMRSemanticReportBuilder.InstructionItem", [], InstructionItem, () => [["ItemId", int32_type], ["ItemType", int32_type], ["Text", string_type], ["Pattern", option_type(string_type)], ["Confidence", float64_type], ["Complexity", ComplexityLevel_$reflection()]]);
+}
+
+export class FormReference extends Record implements IEquatable<FormReference>, IComparable<FormReference> {
+    readonly SourceItemId: int32;
+    readonly SourceText: string;
+    readonly ReferencedFormCode: string;
+    readonly ActionSuggested: string;
+    readonly Complexity: ComplexityLevel_$union;
+    constructor(SourceItemId: int32, SourceText: string, ReferencedFormCode: string, ActionSuggested: string, Complexity: ComplexityLevel_$union) {
+        super();
+        this.SourceItemId = (SourceItemId | 0);
+        this.SourceText = SourceText;
+        this.ReferencedFormCode = ReferencedFormCode;
+        this.ActionSuggested = ActionSuggested;
+        this.Complexity = Complexity;
+    }
+}
+
+export function FormReference_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CorEMRSemanticReportBuilder.FormReference", [], FormReference, () => [["SourceItemId", int32_type], ["SourceText", string_type], ["ReferencedFormCode", string_type], ["ActionSuggested", string_type], ["Complexity", ComplexityLevel_$reflection()]]);
+}
+
+export class InferredRelationship extends Record implements IEquatable<InferredRelationship>, IComparable<InferredRelationship> {
+    readonly Field1: string;
+    readonly Field2: string;
+    readonly RelationType: string;
+    readonly Evidence: string;
+    readonly Confidence: float64;
+    readonly Complexity: ComplexityLevel_$union;
+    constructor(Field1: string, Field2: string, RelationType: string, Evidence: string, Confidence: float64, Complexity: ComplexityLevel_$union) {
+        super();
+        this.Field1 = Field1;
+        this.Field2 = Field2;
+        this.RelationType = RelationType;
+        this.Evidence = Evidence;
+        this.Confidence = Confidence;
+        this.Complexity = Complexity;
+    }
+}
+
+export function InferredRelationship_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CorEMRSemanticReportBuilder.InferredRelationship", [], InferredRelationship, () => [["Field1", string_type], ["Field2", string_type], ["RelationType", string_type], ["Evidence", string_type], ["Confidence", float64_type], ["Complexity", ComplexityLevel_$reflection()]]);
+}
+
+export class ConfidenceMetrics extends Record implements IEquatable<ConfidenceMetrics>, IComparable<ConfidenceMetrics> {
+    readonly MechanicalConversionRate: float64;
+    readonly InstructionDetectionRate: float64;
+    readonly EnhancementOpportunities: int32;
+    readonly UnmappedItemCount: int32;
+    constructor(MechanicalConversionRate: float64, InstructionDetectionRate: float64, EnhancementOpportunities: int32, UnmappedItemCount: int32) {
+        super();
+        this.MechanicalConversionRate = MechanicalConversionRate;
+        this.InstructionDetectionRate = InstructionDetectionRate;
+        this.EnhancementOpportunities = (EnhancementOpportunities | 0);
+        this.UnmappedItemCount = (UnmappedItemCount | 0);
+    }
+}
+
+export function ConfidenceMetrics_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CorEMRSemanticReportBuilder.ConfidenceMetrics", [], ConfidenceMetrics, () => [["MechanicalConversionRate", float64_type], ["InstructionDetectionRate", float64_type], ["EnhancementOpportunities", int32_type], ["UnmappedItemCount", int32_type]]);
+}
+
+export class FieldCatalogEntry extends Record implements IEquatable<FieldCatalogEntry>, IComparable<FieldCatalogEntry> {
+    readonly ItemId: int32;
+    readonly FieldKey: string;
+    readonly Label: string;
+    readonly FieldType: string;
+    readonly IsRequired: boolean;
+    readonly ParentId: Option<int32>;
+    readonly Notes: Option<string>;
+    readonly Complexity: ComplexityLevel_$union;
+    constructor(ItemId: int32, FieldKey: string, Label: string, FieldType: string, IsRequired: boolean, ParentId: Option<int32>, Notes: Option<string>, Complexity: ComplexityLevel_$union) {
+        super();
+        this.ItemId = (ItemId | 0);
+        this.FieldKey = FieldKey;
+        this.Label = Label;
+        this.FieldType = FieldType;
+        this.IsRequired = IsRequired;
+        this.ParentId = ParentId;
+        this.Notes = Notes;
+        this.Complexity = Complexity;
+    }
+}
+
+export function FieldCatalogEntry_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CorEMRSemanticReportBuilder.FieldCatalogEntry", [], FieldCatalogEntry, () => [["ItemId", int32_type], ["FieldKey", string_type], ["Label", string_type], ["FieldType", string_type], ["IsRequired", bool_type], ["ParentId", option_type(int32_type)], ["Notes", option_type(string_type)], ["Complexity", ComplexityLevel_$reflection()]]);
+}
+
+export class ChoiceCatalogEntry extends Record implements IEquatable<ChoiceCatalogEntry>, IComparable<ChoiceCatalogEntry> {
+    readonly ChoiceId: int32;
+    readonly ItemId: int32;
+    readonly FieldKey: string;
+    readonly OptionKey: string;
+    readonly Text: string;
+    readonly Score: int64;
+    readonly Sequence: int32;
+    constructor(ChoiceId: int32, ItemId: int32, FieldKey: string, OptionKey: string, Text$: string, Score: int64, Sequence: int32) {
+        super();
+        this.ChoiceId = (ChoiceId | 0);
+        this.ItemId = (ItemId | 0);
+        this.FieldKey = FieldKey;
+        this.OptionKey = OptionKey;
+        this.Text = Text$;
+        this.Score = Score;
+        this.Sequence = (Sequence | 0);
+    }
+}
+
+export function ChoiceCatalogEntry_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CorEMRSemanticReportBuilder.ChoiceCatalogEntry", [], ChoiceCatalogEntry, () => [["ChoiceId", int32_type], ["ItemId", int32_type], ["FieldKey", string_type], ["OptionKey", string_type], ["Text", string_type], ["Score", int64_type], ["Sequence", int32_type]]);
+}
+
+export class PathwayState extends Record implements IEquatable<PathwayState>, IComparable<PathwayState> {
+    readonly StateKey: string;
+    readonly StateType: string;
+    readonly StateLabel: string;
+    readonly StateOrder: int32;
+    constructor(StateKey: string, StateType: string, StateLabel: string, StateOrder: int32) {
+        super();
+        this.StateKey = StateKey;
+        this.StateType = StateType;
+        this.StateLabel = StateLabel;
+        this.StateOrder = (StateOrder | 0);
+    }
+}
+
+export function PathwayState_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CorEMRSemanticReportBuilder.PathwayState", [], PathwayState, () => [["StateKey", string_type], ["StateType", string_type], ["StateLabel", string_type], ["StateOrder", int32_type]]);
+}
+
+export class PathwayTransition extends Record implements IEquatable<PathwayTransition>, IComparable<PathwayTransition> {
+    readonly TransitionKey: string;
+    readonly FromState: string;
+    readonly ToState: string;
+    readonly ConditionType: string;
+    readonly ConditionSummary: string;
+    constructor(TransitionKey: string, FromState: string, ToState: string, ConditionType: string, ConditionSummary: string) {
+        super();
+        this.TransitionKey = TransitionKey;
+        this.FromState = FromState;
+        this.ToState = ToState;
+        this.ConditionType = ConditionType;
+        this.ConditionSummary = ConditionSummary;
+    }
+}
+
+export function PathwayTransition_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CorEMRSemanticReportBuilder.PathwayTransition", [], PathwayTransition, () => [["TransitionKey", string_type], ["FromState", string_type], ["ToState", string_type], ["ConditionType", string_type], ["ConditionSummary", string_type]]);
+}
+
+export class PathwayContext extends Record implements IEquatable<PathwayContext>, IComparable<PathwayContext> {
+    readonly States: FSharpList<PathwayState>;
+    readonly Transitions: FSharpList<PathwayTransition>;
+    readonly ExecutionMode: string;
+    constructor(States: FSharpList<PathwayState>, Transitions: FSharpList<PathwayTransition>, ExecutionMode: string) {
+        super();
+        this.States = States;
+        this.Transitions = Transitions;
+        this.ExecutionMode = ExecutionMode;
+    }
+}
+
+export function PathwayContext_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CorEMRSemanticReportBuilder.PathwayContext", [], PathwayContext, () => [["States", list_type(PathwayState_$reflection())], ["Transitions", list_type(PathwayTransition_$reflection())], ["ExecutionMode", string_type]]);
+}
+
+export class SemanticReport extends Record implements IEquatable<SemanticReport>, IComparable<SemanticReport> {
+    readonly FormId: string;
+    readonly FormName: string;
+    readonly FormCode: Option<string>;
+    readonly FieldCatalog: FSharpList<FieldCatalogEntry>;
+    readonly ChoiceCatalog: FSharpList<ChoiceCatalogEntry>;
+    readonly PathwayContext: Option<PathwayContext>;
+    readonly UnmappedInstructions: FSharpList<InstructionItem>;
+    readonly InferredRelationships: FSharpList<InferredRelationship>;
+    readonly CrossFormReferences: FSharpList<FormReference>;
+    readonly Confidence: ConfidenceMetrics;
+    readonly GeneratedAt: Date;
+    readonly ActionTypeSuggestions: FSharpList<ActionTypeSuggestion>;
+    constructor(FormId: string, FormName: string, FormCode: Option<string>, FieldCatalog: FSharpList<FieldCatalogEntry>, ChoiceCatalog: FSharpList<ChoiceCatalogEntry>, PathwayContext: Option<PathwayContext>, UnmappedInstructions: FSharpList<InstructionItem>, InferredRelationships: FSharpList<InferredRelationship>, CrossFormReferences: FSharpList<FormReference>, Confidence: ConfidenceMetrics, GeneratedAt: Date, ActionTypeSuggestions: FSharpList<ActionTypeSuggestion>) {
+        super();
+        this.FormId = FormId;
+        this.FormName = FormName;
+        this.FormCode = FormCode;
+        this.FieldCatalog = FieldCatalog;
+        this.ChoiceCatalog = ChoiceCatalog;
+        this.PathwayContext = PathwayContext;
+        this.UnmappedInstructions = UnmappedInstructions;
+        this.InferredRelationships = InferredRelationships;
+        this.CrossFormReferences = CrossFormReferences;
+        this.Confidence = Confidence;
+        this.GeneratedAt = GeneratedAt;
+        this.ActionTypeSuggestions = ActionTypeSuggestions;
+    }
+}
+
+export function SemanticReport_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CorEMRSemanticReportBuilder.SemanticReport", [], SemanticReport, () => [["FormId", class_type("System.Guid")], ["FormName", string_type], ["FormCode", option_type(string_type)], ["FieldCatalog", list_type(FieldCatalogEntry_$reflection())], ["ChoiceCatalog", list_type(ChoiceCatalogEntry_$reflection())], ["PathwayContext", option_type(PathwayContext_$reflection())], ["UnmappedInstructions", list_type(InstructionItem_$reflection())], ["InferredRelationships", list_type(InferredRelationship_$reflection())], ["CrossFormReferences", list_type(FormReference_$reflection())], ["Confidence", ConfidenceMetrics_$reflection()], ["GeneratedAt", class_type("System.DateTime")], ["ActionTypeSuggestions", list_type(ActionTypeSuggestion_$reflection())]]);
+}
+
+export class ActionTypeSuggestion extends Record implements IEquatable<ActionTypeSuggestion>, IComparable<ActionTypeSuggestion> {
+    readonly EventType: string;
+    readonly EventParams: FSharpMap<string, string>;
+    readonly SuggestedActionType: string;
+    readonly Confidence: float64;
+    readonly Reasoning: string;
+    readonly SuggestedParameters: Option<FSharpMap<string, string>>;
+    readonly TargetItemId: Option<int32>;
+    readonly TargetFieldKey: Option<string>;
+    constructor(EventType: string, EventParams: FSharpMap<string, string>, SuggestedActionType: string, Confidence: float64, Reasoning: string, SuggestedParameters: Option<FSharpMap<string, string>>, TargetItemId: Option<int32>, TargetFieldKey: Option<string>) {
+        super();
+        this.EventType = EventType;
+        this.EventParams = EventParams;
+        this.SuggestedActionType = SuggestedActionType;
+        this.Confidence = Confidence;
+        this.Reasoning = Reasoning;
+        this.SuggestedParameters = SuggestedParameters;
+        this.TargetItemId = TargetItemId;
+        this.TargetFieldKey = TargetFieldKey;
+    }
+}
+
+export function ActionTypeSuggestion_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CorEMRSemanticReportBuilder.ActionTypeSuggestion", [], ActionTypeSuggestion, () => [["EventType", string_type], ["EventParams", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, string_type])], ["SuggestedActionType", string_type], ["Confidence", float64_type], ["Reasoning", string_type], ["SuggestedParameters", option_type(class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, string_type]))], ["TargetItemId", option_type(int32_type)], ["TargetFieldKey", option_type(string_type)]]);
+}
+
+/**
+ * Analyze CoreMR event type and suggest appropriate FormSpec action type
+ */
+export function ActionTypeAnalysis_analyzeEventType(eventType: string, eventParams: FSharpMap<string, string>): [string, float64, string] {
+    const matchValue: string = eventType.toLowerCase();
+    switch (matchValue) {
+        case "task":
+            return ["task", 0.95, "CoreMR task events map directly to FormSpec task actions for workflow management"] as [string, float64, string];
+        case "taskcomplete":
+            return ["task", 0.9, "Task completion events should trigger task actions for workflow tracking"] as [string, float64, string];
+        case "alert":
+            return ["alert", 0.95, "CoreMR alert events map directly to FormSpec alert actions for clinical notifications"] as [string, float64, string];
+        case "medset":
+            if (FSharpMap__ContainsKey(eventParams, "quantity") ? true : FSharpMap__ContainsKey(eventParams, "refills")) {
+                return ["prescription", 0.9, "Medication event with quantity/refills suggests prescription action"] as [string, float64, string];
+            }
+            else {
+                return ["medication", 0.85, "Medication event suggests administration action"] as [string, float64, string];
+            }
+        case "problem":
+            return ["problem", 0.95, "Problem events map directly to FormSpec problem actions for problem list management"] as [string, float64, string];
+        default:
+            return ["documentation", 0.3, `Unknown CoreMR event type '${eventType}' - defaulting to documentation with low confidence`] as [string, float64, string];
+    }
+}
+
+/**
+ * Generate suggested parameters for FormSpec action based on CoreMR event
+ */
+export function ActionTypeAnalysis_generateSuggestedParameters(actionType: string, eventParams: FSharpMap<string, string>): Option<FSharpMap<string, string>> {
+    switch (actionType) {
+        case "task":
+            return ofList<string, string>(ofArray([["category", defaultArg(FSharpMap__TryFind(eventParams, "cat_desc"), "General")] as [string, string], ["priority", "medium"] as [string, string], ["assignee", "Assigned Clinician"] as [string, string]]), {
+                Compare: comparePrimitives,
+            });
+        case "alert":
+            return ofList<string, string>(ofArray([["category", defaultArg(FSharpMap__TryFind(eventParams, "category_desc"), "Clinical")] as [string, string], ["severity", "medium"] as [string, string]]), {
+                Compare: comparePrimitives,
+            });
+        case "medication":
+            return ofList<string, string>(ofArray([["medication_name", defaultArg(FSharpMap__TryFind(eventParams, "medication_name"), "As prescribed")] as [string, string], ["dose", defaultArg(FSharpMap__TryFind(eventParams, "dose"), "As directed")] as [string, string], ["route", "PO"] as [string, string], ["frequency", "As directed"] as [string, string]]), {
+                Compare: comparePrimitives,
+            });
+        case "prescription":
+            return ofList<string, string>(ofArray([["medication_name", defaultArg(FSharpMap__TryFind(eventParams, "medication_name"), "As prescribed")] as [string, string], ["quantity", "30"] as [string, string]]), {
+                Compare: comparePrimitives,
+            });
+        case "problem":
+            return ofList<string, string>(ofArray([["problem_name", defaultArg(FSharpMap__TryFind(eventParams, "problem_desc"), "Clinical problem")] as [string, string], ["status", "active"] as [string, string]]), {
+                Compare: comparePrimitives,
+            });
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Analyze a CoreMR trigger and generate action type suggestion
+ */
+export function ActionTypeAnalysis_analyzeTrigger(trigger: CoreMRTrigger, fieldCatalog: FSharpList<FieldCatalogEntry>): Option<ActionTypeSuggestion> {
+    const matchValue: FSharpList<CoreMRTriggerEvent> = trigger.Events;
+    if (isEmpty(matchValue)) {
+        return undefined;
+    }
+    else {
+        const event: CoreMRTriggerEvent = head<CoreMRTriggerEvent>(matchValue);
+        const eventParams: FSharpMap<string, string> = event.EventParams;
+        const patternInput: [string, float64, string] = ActionTypeAnalysis_analyzeEventType(event.EventType, eventParams);
+        const suggestedActionType: string = patternInput[0];
+        return new ActionTypeSuggestion(event.EventType, eventParams, suggestedActionType, patternInput[1], patternInput[2], ActionTypeAnalysis_generateSuggestedParameters(suggestedActionType, eventParams), trigger.TargetItemId, map<FieldCatalogEntry, string>((f_1: FieldCatalogEntry): string => f_1.FieldKey, tryFind<FieldCatalogEntry>((f: FieldCatalogEntry): boolean => (f.ItemId === trigger.TargetItemId), fieldCatalog)));
+    }
+}
+
+/**
+ * Create an empty semantic report
+ */
+export function empty(formId: string, formName: string): SemanticReport {
+    return new SemanticReport(formId, formName, undefined, empty_1<FieldCatalogEntry>(), empty_1<ChoiceCatalogEntry>(), undefined, empty_1<InstructionItem>(), empty_1<InferredRelationship>(), empty_1<FormReference>(), new ConfidenceMetrics(0, 0, 0, 0), utcNow(), empty_1<ActionTypeSuggestion>());
+}
+
+/**
+ * Extract form code from name using pattern matching
+ */
+export function extractFormCode(formName: string): Option<string> {
+    const m: any = match(create("\\b([A-Z]{2,3}-\\d{3}[A-Z]?)\\b"), formName);
+    if (m != null) {
+        return m[1] || "";
+    }
+    else {
+        return undefined;
+    }
+}
+
+/**
+ * Determine complexity based on instruction pattern
+ */
+export function scoreInstructionComplexity(text: string, pattern: Option<string>): ComplexityLevel_$union {
+    let p: string, p_1: string;
+    if (pattern == null) {
+        if ((text.indexOf("protocol") >= 0) ? true : (text.indexOf("navigate") >= 0)) {
+            return ComplexityLevel_Advanced();
+        }
+        else if ((text.indexOf("if") >= 0) ? true : (text.indexOf("when") >= 0)) {
+            return ComplexityLevel_Standard();
+        }
+        else {
+            return ComplexityLevel_Essential();
+        }
+    }
+    else if ((p = value_129(pattern), (p.indexOf("cross-form") >= 0) ? true : (p.indexOf("protocol") >= 0))) {
+        const p_2: string = value_129(pattern);
+        return ComplexityLevel_Advanced();
+    }
+    else if ((p_1 = value_129(pattern), (p_1.indexOf("conditional") >= 0) ? true : (p_1.indexOf("if") >= 0))) {
+        const p_3: string = value_129(pattern);
+        return ComplexityLevel_Standard();
+    }
+    else {
+        return ComplexityLevel_Essential();
+    }
+}
+
+/**
+ * Determine field complexity based on requirements
+ */
+export function scoreFieldComplexity(isRequired: boolean, hasDependency: boolean, hasComplexLogic: boolean): ComplexityLevel_$union {
+    if (hasComplexLogic) {
+        return ComplexityLevel_Advanced();
+    }
+    else if (isRequired) {
+        if (hasDependency) {
+            throw new MatchFailureException("/Users/luisfx/code/luisfx/f1-monorepo/packages/core/form-spec/FormSpec.FS/Integrations/Adapters/CorEMR/CorEMRSemanticReportBuilder.fs", 302, 14);
+        }
+        else {
+            return ComplexityLevel_Essential();
+        }
+    }
+    else if (hasDependency) {
+        return ComplexityLevel_Standard();
+    }
+    else {
+        return ComplexityLevel_Standard();
+    }
+}
+
+/**
+ * Check if text contains conditional instruction
+ */
+export function hasInstruction(text: string): boolean {
+    return exists<string>((p: string): boolean => isMatch(create(p, 1), text), ofArray(["\\bIf\\s+", "\\bWhen\\s+", "\\bcomplete\\s+", "\\bperform\\s+", "\\border\\s+", "\\brefer\\s+"]));
+}
+
+/**
+ * Check if text contains form reference
+ */
+export function hasFormReference(text: string): boolean {
+    return isMatch(create("\\[[A-Z]{2,3}-\\d{3}[A-Z]?\\]"), text);
+}
+
+/**
+ * Extract form references from text
+ */
+export function extractFormReferences(itemId: int32, text: string): FSharpList<FormReference> {
+    const matches: any = matches_1(create("\\[([A-Z]{2,3}-\\d{3}[A-Z]?)\\]"), text);
+    return toList<FormReference>(delay<FormReference>((): Iterable<FormReference> => map_1<any, FormReference>((m: any): FormReference => (new FormReference(itemId, text, m[1] || "", "Navigate to form", ComplexityLevel_Advanced())), matches)));
+}
+
+/**
+ * Build field catalog from CoreMR items and FormSpec
+ */
+export function buildFieldCatalog<T>(items: FSharpList<CoreMRItem>, formSpec: Spec_FormSpec$1<T>): FSharpList<FieldCatalogEntry> {
+    const fieldDataMap: FSharpMap<string, [string, Option<string>]> = ofList<string, [string, Option<string>]>(collect<Spec_FormStep$1<T>, [string, [string, Option<string>]]>((step: Spec_FormStep$1<T>): FSharpList<[string, [string, Option<string>]]> => map_2<Spec_FormField$1<T>, [string, [string, Option<string>]]>((field: Spec_FormField$1<T>): [string, [string, Option<string>]] => ([field.Label, [field.FieldKey.fields[0], field.Notes] as [string, Option<string>]] as [string, [string, Option<string>]]), step.Fields), formSpec.Steps), {
+        Compare: comparePrimitives,
+    });
+    return choose<CoreMRItem, FieldCatalogEntry>((item: CoreMRItem): Option<FieldCatalogEntry> => {
+        const matchValue: Option<[string, Option<string>]> = tryFind_1<string, [string, Option<string>]>(item.Label, fieldDataMap);
+        if (matchValue == null) {
+            if (getElementTypeInfo(item.ItemTypeId).IsScaffold) {
+                return undefined;
+            }
+            else {
+                return new FieldCatalogEntry(item.ItemId, `unmapped_${item.ItemId}`, item.Label, item.ItemTypeName, item.IsRequired, item.ParentId, undefined, scoreFieldComplexity(item.IsRequired, item.ParentId != null, false));
+            }
+        }
+        else {
+            const notes: Option<string> = value_129(matchValue)[1];
+            return new FieldCatalogEntry(item.ItemId, value_129(matchValue)[0], item.Label, item.ItemTypeName, item.IsRequired, item.ParentId, notes, scoreFieldComplexity(item.IsRequired, item.ParentId != null, (notes != null) && (value_129(notes).indexOf("if") >= 0)));
+        }
+    }, items);
+}
+
+/**
+ * Build choice catalog from CoreMR choices and FormSpec
+ */
+export function buildChoiceCatalog<T>(choices: FSharpList<CoreMRChoice>, formSpec: Spec_FormSpec$1<T>, fieldCatalog: FSharpList<FieldCatalogEntry>): FSharpList<ChoiceCatalogEntry> {
+    const fieldLookup: FSharpMap<int32, string> = ofList<int32, string>(map_2<FieldCatalogEntry, [int32, string]>((f: FieldCatalogEntry): [int32, string] => ([f.ItemId, f.FieldKey] as [int32, string]), fieldCatalog), {
+        Compare: comparePrimitives,
+    });
+    return sortBy<ChoiceCatalogEntry, [int32, int32]>((c: ChoiceCatalogEntry): [int32, int32] => ([c.ItemId, c.Sequence] as [int32, int32]), choose<CoreMRChoice, ChoiceCatalogEntry>((choice: CoreMRChoice): Option<ChoiceCatalogEntry> => {
+        const matchValue: Option<string> = tryFind_1<int32, string>(choice.ItemId, fieldLookup);
+        if (matchValue == null) {
+            return undefined;
+        }
+        else {
+            return new ChoiceCatalogEntry(choice.ChoiceId, choice.ItemId, value_129(matchValue), Helpers_generateDeterministicGuidRaw(`coremr:semantic-choice:${choice.ItemId}:${choice.ChoiceId}:${choice.Sequence}:${choice.Text}`), choice.Text, toInt64(fromInt32(choice.Score)), choice.Sequence);
+        }
+    }, choices), {
+        Compare: compareArrays,
+    });
+}
+
+/**
+ * Build pathway context from FormSpec clinical pathway
+ */
+export function buildPathwayContext(pathway: Option<ClinicalPathway_ClinicalPathwaySpec>): Option<PathwayContext> {
+    let matchValue_3: ClinicalPathway_PathwayExecutionMode_$union;
+    if (pathway != null) {
+        const p: ClinicalPathway_ClinicalPathwaySpec = value_129(pathway);
+        return new PathwayContext(map_2<ClinicalPathway_StateDefinition, PathwayState>((state: ClinicalPathway_StateDefinition): PathwayState => {
+            let matchValue: ClinicalPathway_StateType_$union;
+            return new PathwayState(state.StateKey.fields[0], (matchValue = state.StateType, (matchValue.tag === /* Evaluation */ 1) ? "Evaluation" : ((matchValue.tag === /* Action */ 2) ? "Action" : ((matchValue.tag === /* Terminal */ 5) ? "Terminal" : ((matchValue.tag === /* CompoundAction */ 3) ? "CompoundAction" : ((matchValue.tag === /* ConditionalAction */ 4) ? "ConditionalAction" : (() => {
+                throw new Error("Match failure: F1.Studio.ClinicalPathway.StateType");
+            })()))))), state.StateLabel, state.StateOrder);
+        }, p.States), map_2<ClinicalPathway_TransitionDefinition, PathwayTransition>((trans: ClinicalPathway_TransitionDefinition): PathwayTransition => {
+            let matchValue_2: ClinicalPathway_TransitionCondition_$union;
+            const transKey: string = trans.TransitionKey.fields[0];
+            const fromKey: string = trans.FromState.fields[0];
+            const toKey: string = trans.ToState.fields[0];
+            let conditionSummary: string;
+            const matchValue_1: ClinicalPathway_TransitionCondition_$union = trans.Condition;
+            switch (matchValue_1.tag) {
+                case /* Always */ 8: {
+                    conditionSummary = "Always";
+                    break;
+                }
+                case /* FieldCondition */ 0: {
+                    const value: Shared_ConditionValue_$union = matchValue_1.fields[2];
+                    const fieldKey: Shared_FieldKey = matchValue_1.fields[0];
+                    conditionSummary = (`Field: ${matchValue_1.fields[1]}`);
+                    break;
+                }
+                case /* FieldOptionCondition */ 1: {
+                    const value_1: Shared_ConditionValue_$union = matchValue_1.fields[4];
+                    const optionKey: Shared_FieldOptionKey = matchValue_1.fields[2];
+                    const itemKey: Option<Shared_MatrixItemKey> = matchValue_1.fields[1];
+                    const fieldKey_1: Shared_FieldKey = matchValue_1.fields[0];
+                    conditionSummary = (`Option: ${matchValue_1.fields[3]}`);
+                    break;
+                }
+                case /* CompositeCondition */ 6: {
+                    const conditions: FSharpList<ClinicalPathway_TransitionCondition_$union> = matchValue_1.fields[1];
+                    conditionSummary = (`Composite: ${matchValue_1.fields[0]}`);
+                    break;
+                }
+                case /* StateCondition */ 5: {
+                    const stateKey: Shared_StateKey = matchValue_1.fields[0];
+                    conditionSummary = (`State: ${matchValue_1.fields[1]}`);
+                    break;
+                }
+                case /* TestResultCondition */ 7: {
+                    conditionSummary = (`Test: ${matchValue_1.fields[0]} = ${matchValue_1.fields[1]}`);
+                    break;
+                }
+                default:
+                    throw new Error("Match failure: F1.Studio.ClinicalPathway.TransitionCondition");
+            }
+            return new PathwayTransition(transKey, fromKey, toKey, (matchValue_2 = trans.Condition, (matchValue_2.tag === /* Always */ 8) ? "automatic" : ((matchValue_2.tag === /* FieldCondition */ 0) ? "field" : ((matchValue_2.tag === /* FieldOptionCondition */ 1) ? "field_option" : ((matchValue_2.tag === /* CompositeCondition */ 6) ? "composite" : ((matchValue_2.tag === /* StateCondition */ 5) ? "state" : ((matchValue_2.tag === /* TestResultCondition */ 7) ? "test_result" : (() => {
+                throw new Error("Match failure: F1.Studio.ClinicalPathway.TransitionCondition");
+            })())))))), conditionSummary);
+        }, p.Transitions), (matchValue_3 = p.ExecutionMode, (matchValue_3.tag === /* MultiPathway */ 1) ? "MultiPathway" : ((matchValue_3.tag === /* TriggerBased */ 2) ? "TriggerBased" : "SinglePathway")));
+    }
+    else {
+        return undefined;
+    }
+}
+
+/**
+ * Add unmapped instruction to report with enhanced context
+ */
+export function addUnmappedInstruction(report: SemanticReport, item: CoreMRItem): SemanticReport {
+    let matchValue: Option<string>, text: string;
+    const pattern: Option<string> = startsWith(item.Label, "If ", 5) ? ("Conditional instruction" + ((matchValue = ((text = item.Label, (text.indexOf("cardiac risk factors") >= 0) ? "Check Field 20984 (Cardiac Risk Factors)" : ((text.indexOf("no CV risk factors") >= 0) ? "Check Field 20984 is empty AND vitals normal" : ((text.indexOf("referral") >= 0) ? "Check if referral field has value" : undefined)))), (matchValue == null) ? "" : (" - " + value_129(matchValue))))) : undefined;
+    return new SemanticReport(report.FormId, report.FormName, report.FormCode, report.FieldCatalog, report.ChoiceCatalog, report.PathwayContext, cons(new InstructionItem(item.ItemId, item.ItemTypeId, item.Label, pattern, 0.75, scoreInstructionComplexity(item.Label, pattern)), report.UnmappedInstructions), report.InferredRelationships, report.CrossFormReferences, report.Confidence, report.GeneratedAt, report.ActionTypeSuggestions);
+}
+
+/**
+ * Add cross-form reference to report
+ */
+export function addCrossFormReference(report: SemanticReport, reference: FormReference): SemanticReport {
+    return new SemanticReport(report.FormId, report.FormName, report.FormCode, report.FieldCatalog, report.ChoiceCatalog, report.PathwayContext, report.UnmappedInstructions, report.InferredRelationships, cons(reference, report.CrossFormReferences), report.Confidence, report.GeneratedAt, report.ActionTypeSuggestions);
+}
+
+/**
+ * Add inferred relationship to report
+ */
+export function addInferredRelationship(report: SemanticReport, field1: string, field2: string, relationType: string, evidence: string): SemanticReport {
+    return new SemanticReport(report.FormId, report.FormName, report.FormCode, report.FieldCatalog, report.ChoiceCatalog, report.PathwayContext, report.UnmappedInstructions, cons(new InferredRelationship(field1, field2, relationType, evidence, 0.65, (relationType === "triggers") ? ComplexityLevel_Standard() : ((relationType === "requires") ? ComplexityLevel_Standard() : ((relationType === "correlates with") ? ComplexityLevel_Essential() : ComplexityLevel_Standard()))), report.InferredRelationships), report.CrossFormReferences, report.Confidence, report.GeneratedAt, report.ActionTypeSuggestions);
+}
+
+/**
+ * Build action type suggestions from CoreMR triggers
+ */
+export function buildActionTypeSuggestions(triggers: FSharpList<CoreMRTrigger>, fieldCatalog: FSharpList<FieldCatalogEntry>): FSharpList<ActionTypeSuggestion> {
+    return sortByDescending<ActionTypeSuggestion, float64>((suggestion_2: ActionTypeSuggestion): float64 => suggestion_2.Confidence, choose<CoreMRTrigger, ActionTypeSuggestion>((trigger: CoreMRTrigger): Option<ActionTypeSuggestion> => {
+        const matchValue: Option<ActionTypeSuggestion> = ActionTypeAnalysis_analyzeTrigger(trigger, fieldCatalog);
+        let matchResult: int32, suggestion_1: ActionTypeSuggestion;
+        if (matchValue != null) {
+            if (value_129(matchValue).Confidence > 0.5) {
+                matchResult = 0;
+                suggestion_1 = value_129(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return suggestion_1!;
+            default:
+                return undefined;
+        }
+    }, triggers), {
+        Compare: comparePrimitives,
+    });
+}
+
+/**
+ * Add action type suggestion to the report
+ */
+export function addActionTypeSuggestion(report: SemanticReport, suggestion: ActionTypeSuggestion): SemanticReport {
+    return new SemanticReport(report.FormId, report.FormName, report.FormCode, report.FieldCatalog, report.ChoiceCatalog, report.PathwayContext, report.UnmappedInstructions, report.InferredRelationships, report.CrossFormReferences, report.Confidence, report.GeneratedAt, cons(suggestion, report.ActionTypeSuggestions));
+}
+
+/**
+ * Calculate confidence metrics
+ */
+export function calculateMetrics(report: SemanticReport, totalItems: int32, triggersConverted: int32): SemanticReport {
+    return new SemanticReport(report.FormId, report.FormName, report.FormCode, report.FieldCatalog, report.ChoiceCatalog, report.PathwayContext, report.UnmappedInstructions, report.InferredRelationships, report.CrossFormReferences, new ConfidenceMetrics((totalItems > 0) ? ((triggersConverted / totalItems) * 100) : 0, (totalItems > 0) ? ((length(report.UnmappedInstructions) / totalItems) * 100) : 0, (length(report.UnmappedInstructions) + length(report.InferredRelationships)) + length(report.CrossFormReferences), length(report.UnmappedInstructions)), report.GeneratedAt, report.ActionTypeSuggestions);
+}
+
+/**
+ * Convert report to markdown format
+ */
+export function toMarkdown(report: SemanticReport): string {
+    let s: string;
+    const sb: any = StringBuilder_$ctor();
+    StringBuilder__AppendLine_Z721C83C5(sb, `# Semantic Analysis Report - Form ${report.FormId}`);
+    StringBuilder__AppendLine_Z721C83C5(sb, `## ${report.FormName}`);
+    if (report.FormCode != null) {
+        StringBuilder__AppendLine_Z721C83C5(sb, `**Form Code:** ${value_129(report.FormCode)}`);
+    }
+    StringBuilder__AppendLine(sb);
+    StringBuilder__AppendLine_Z721C83C5(sb, `*Generated: ${toString(report.GeneratedAt, "yyyy-MM-dd HH:mm:ss")} UTC*`);
+    StringBuilder__AppendLine(sb);
+    StringBuilder__AppendLine_Z721C83C5(sb, "## Complexity Legend");
+    StringBuilder__AppendLine_Z721C83C5(sb, "🟢 **Essential** - Core functionality, required fields, simple mappings");
+    StringBuilder__AppendLine_Z721C83C5(sb, "🟡 **Standard** - Optional logic, basic conditions, common workflows");
+    StringBuilder__AppendLine_Z721C83C5(sb, "🔴 **Advanced** - Complex branching, cross-form refs, edge cases");
+    StringBuilder__AppendLine(sb);
+    StringBuilder__AppendLine_Z721C83C5(sb, "## Summary Statistics");
+    StringBuilder__AppendLine_Z721C83C5(sb, `- Mechanical Conversion Rate: ${report.Confidence.MechanicalConversionRate}%`);
+    StringBuilder__AppendLine_Z721C83C5(sb, `- Instruction Detection Rate: ${report.Confidence.InstructionDetectionRate}%`);
+    StringBuilder__AppendLine_Z721C83C5(sb, `- Enhancement Opportunities: ${report.Confidence.EnhancementOpportunities}`);
+    StringBuilder__AppendLine_Z721C83C5(sb, `- Unmapped Items: ${report.Confidence.UnmappedItemCount}`);
+    StringBuilder__AppendLine(sb);
+    if (!isEmpty(report.FieldCatalog)) {
+        StringBuilder__AppendLine_Z721C83C5(sb, "## Field Catalog");
+        StringBuilder__AppendLine_Z721C83C5(sb, "*Use these FieldKeys when creating conditions and references*");
+        StringBuilder__AppendLine(sb);
+        StringBuilder__AppendLine_Z721C83C5(sb, "| C | ItemId | FieldKey | Label | Type | Required | Notes |");
+        StringBuilder__AppendLine_Z721C83C5(sb, "|---|--------|----------|-------|------|----------|-------|");
+        const enumerator: IEnumerator<FieldCatalogEntry> = getEnumerator(report.FieldCatalog);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                const field: FieldCatalogEntry = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                StringBuilder__AppendLine_Z721C83C5(sb, `| ${complexityToEmoji(field.Complexity)} | ${field.ItemId} | \`${field.FieldKey}\` | ${field.Label} | ${field.FieldType} | ${field.IsRequired ? "Yes" : "No"} | ${(s = defaultArg(field.Notes, ""), (s.length > 50) ? (substring(s, 0, 47) + "...") : s)} |`);
+            }
+        }
+        finally {
+            disposeSafe(enumerator as IDisposable);
+        }
+        StringBuilder__AppendLine(sb);
+    }
+    if (!isEmpty(report.ChoiceCatalog)) {
+        StringBuilder__AppendLine_Z721C83C5(sb, "## Choice Catalog");
+        StringBuilder__AppendLine_Z721C83C5(sb, "*Use these OptionKeys when creating field_option conditions*");
+        StringBuilder__AppendLine(sb);
+        StringBuilder__AppendLine_Z721C83C5(sb, "| ItemId | OptionKey | Text | Score |");
+        StringBuilder__AppendLine_Z721C83C5(sb, "|--------|-----------|------|-------|");
+        const enumerator_1: IEnumerator<ChoiceCatalogEntry> = getEnumerator(report.ChoiceCatalog);
+        try {
+            while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+                const choice: ChoiceCatalogEntry = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                StringBuilder__AppendLine_Z721C83C5(sb, `| ${choice.ItemId} | \`${choice.OptionKey}\` | ${choice.Text} | ${choice.Score} |`);
+            }
+        }
+        finally {
+            disposeSafe(enumerator_1 as IDisposable);
+        }
+        StringBuilder__AppendLine(sb);
+    }
+    const matchValue: Option<PathwayContext> = report.PathwayContext;
+    if (matchValue == null) {
+    }
+    else {
+        const context: PathwayContext = value_129(matchValue);
+        StringBuilder__AppendLine_Z721C83C5(sb, "## Current Clinical Pathway");
+        StringBuilder__AppendLine_Z721C83C5(sb, `*Execution Mode: ${context.ExecutionMode}*`);
+        StringBuilder__AppendLine(sb);
+        StringBuilder__AppendLine_Z721C83C5(sb, "### Existing States");
+        StringBuilder__AppendLine_Z721C83C5(sb, "| StateKey | Type | Label |");
+        StringBuilder__AppendLine_Z721C83C5(sb, "|----------|------|-------|");
+        const enumerator_2: IEnumerator<PathwayState> = getEnumerator(sortBy<PathwayState, int32>((s_1: PathwayState): int32 => s_1.StateOrder, context.States, {
+            Compare: comparePrimitives,
+        }));
+        try {
+            while (enumerator_2["System.Collections.IEnumerator.MoveNext"]()) {
+                const state: PathwayState = enumerator_2["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                StringBuilder__AppendLine_Z721C83C5(sb, `| \`${state.StateKey}\` | ${state.StateType} | ${state.StateLabel} |`);
+            }
+        }
+        finally {
+            disposeSafe(enumerator_2 as IDisposable);
+        }
+        StringBuilder__AppendLine(sb);
+        if (!isEmpty(context.Transitions)) {
+            StringBuilder__AppendLine_Z721C83C5(sb, "### Existing Transitions");
+            StringBuilder__AppendLine_Z721C83C5(sb, "| From → To | Condition |");
+            StringBuilder__AppendLine_Z721C83C5(sb, "|-----------|-----------|");
+            const enumerator_3: IEnumerator<PathwayTransition> = getEnumerator(context.Transitions);
+            try {
+                while (enumerator_3["System.Collections.IEnumerator.MoveNext"]()) {
+                    const trans: PathwayTransition = enumerator_3["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    StringBuilder__AppendLine_Z721C83C5(sb, `| \`${trans.FromState}\` → \`${trans.ToState}\` | ${trans.ConditionSummary} |`);
+                }
+            }
+            finally {
+                disposeSafe(enumerator_3 as IDisposable);
+            }
+            StringBuilder__AppendLine(sb);
+        }
+    }
+    if (!isEmpty(report.UnmappedInstructions)) {
+        StringBuilder__AppendLine_Z721C83C5(sb, "## Unmapped Conditional Logic");
+        StringBuilder__AppendLine(sb);
+        const enumerator_4: IEnumerator<InstructionItem> = getEnumerator(reverse<InstructionItem>(report.UnmappedInstructions));
+        try {
+            while (enumerator_4["System.Collections.IEnumerator.MoveNext"]()) {
+                const inst: InstructionItem = enumerator_4["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                StringBuilder__AppendLine_Z721C83C5(sb, `### ${complexityToEmoji(inst.Complexity)} Item ${inst.ItemId} (Type ${inst.ItemType})`);
+                StringBuilder__AppendLine_Z721C83C5(sb, `**Complexity:** ${complexityToString(inst.Complexity)}`);
+                StringBuilder__AppendLine_Z721C83C5(sb, `**Text:** ${inst.Text}`);
+                if (inst.Pattern != null) {
+                    StringBuilder__AppendLine_Z721C83C5(sb, `**Pattern:** ${value_129(inst.Pattern)}`);
+                }
+                StringBuilder__AppendLine_Z721C83C5(sb, `**Confidence:** %P(F2)`);
+                StringBuilder__AppendLine(sb);
+                switch (inst.ItemId) {
+                    case 21001: {
+                        StringBuilder__AppendLine_Z721C83C5(sb, "**Clinical Context:** Emergency pathway for cardiac risk");
+                        StringBuilder__AppendLine_Z721C83C5(sb, "**Suggested Actions:**");
+                        StringBuilder__AppendLine_Z721C83C5(sb, "1. Check Field 20984 (Cardiac Risk Factors) for any value");
+                        StringBuilder__AppendLine_Z721C83C5(sb, "2. If true: Create Task \'Contact HCP\' with urgent priority");
+                        StringBuilder__AppendLine_Z721C83C5(sb, "3. If HCP unavailable: Create Alert \'911 Activation\'");
+                        StringBuilder__AppendLine_Z721C83C5(sb, "4. Navigate to Emergency Protocol");
+                        break;
+                    }
+                    case 21002: {
+                        StringBuilder__AppendLine_Z721C83C5(sb, "**Clinical Context:** Conservative treatment pathway");
+                        StringBuilder__AppendLine_Z721C83C5(sb, "**Suggested Actions:**");
+                        StringBuilder__AppendLine_Z721C83C5(sb, "1. Check Field 20984 is empty AND vitals are normal");
+                        StringBuilder__AppendLine_Z721C83C5(sb, "2. If true: Create Task \'Prescribe OTC medication\'");
+                        StringBuilder__AppendLine_Z721C83C5(sb, "3. Document treatment in appropriate fields");
+                        StringBuilder__AppendLine_Z721C83C5(sb, "4. Navigate to discharge instructions");
+                        break;
+                    }
+                    default: {
+                        StringBuilder__AppendLine_Z721C83C5(sb, "**Suggested Enhancement:**");
+                        StringBuilder__AppendLine_Z721C83C5(sb, "```fsharp");
+                        StringBuilder__AppendLine_Z721C83C5(sb, "// LLM should analyze this conditional and suggest:");
+                        StringBuilder__AppendLine_Z721C83C5(sb, "// 1. What fields should be updated");
+                        StringBuilder__AppendLine_Z721C83C5(sb, "// 2. What tasks should be created");
+                        StringBuilder__AppendLine_Z721C83C5(sb, "// 3. What forms should be navigated to");
+                        StringBuilder__AppendLine_Z721C83C5(sb, "```");
+                    }
+                }
+                StringBuilder__AppendLine(sb);
+            }
+        }
+        finally {
+            disposeSafe(enumerator_4 as IDisposable);
+        }
+    }
+    if (!isEmpty(report.ActionTypeSuggestions)) {
+        StringBuilder__AppendLine_Z721C83C5(sb, "## 🚀 Action Type Intelligence");
+        StringBuilder__AppendLine(sb);
+        StringBuilder__AppendLine_Z721C83C5(sb, "**AI-Suggested FormSpec Action Types** based on CoreMR event analysis:");
+        StringBuilder__AppendLine(sb);
+        const enumerator_5: IEnumerator<[string, FSharpList<ActionTypeSuggestion>]> = getEnumerator(sortBy<[string, FSharpList<ActionTypeSuggestion>], string>((tuple: [string, FSharpList<ActionTypeSuggestion>]): string => tuple[0], List_groupBy<ActionTypeSuggestion, string>((s_2: ActionTypeSuggestion): string => s_2.SuggestedActionType, report.ActionTypeSuggestions, {
+            Equals: (x_1: string, y_1: string): boolean => (x_1 === y_1),
+            GetHashCode: stringHash,
+        }), {
+            Compare: comparePrimitives,
+        }));
+        try {
+            while (enumerator_5["System.Collections.IEnumerator.MoveNext"]()) {
+                const forLoopVar: [string, FSharpList<ActionTypeSuggestion>] = enumerator_5["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                const suggestions: FSharpList<ActionTypeSuggestion> = forLoopVar[1];
+                StringBuilder__AppendLine_Z721C83C5(sb, `### \`action_type: "${forLoopVar[0]}"\` (${length(suggestions)} suggestions)`);
+                StringBuilder__AppendLine(sb);
+                const enumerator_6: IEnumerator<ActionTypeSuggestion> = getEnumerator(suggestions);
+                try {
+                    while (enumerator_6["System.Collections.IEnumerator.MoveNext"]()) {
+                        const suggestion: ActionTypeSuggestion = enumerator_6["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                        StringBuilder__AppendLine_Z721C83C5(sb, `**CoreMR Event**: \`${suggestion.EventType}\``);
+                        const matchValue_1: Option<int32> = suggestion.TargetItemId;
+                        if (matchValue_1 == null) {
+                        }
+                        else {
+                            StringBuilder__AppendLine_Z721C83C5(sb, `- **Target Item**: ${value_129(matchValue_1)}`);
+                        }
+                        StringBuilder__AppendLine_Z721C83C5(sb, `- **Confidence**: %P(P0)`);
+                        StringBuilder__AppendLine_Z721C83C5(sb, `- **Reasoning**: ${suggestion.Reasoning}`);
+                        const matchValue_2: Option<FSharpMap<string, string>> = suggestion.SuggestedParameters;
+                        let matchResult: int32, parameters_1: FSharpMap<string, string>;
+                        if (matchValue_2 != null) {
+                            if (!FSharpMap__get_IsEmpty(value_129(matchValue_2))) {
+                                matchResult = 0;
+                                parameters_1 = value_129(matchValue_2);
+                            }
+                            else {
+                                matchResult = 1;
+                            }
+                        }
+                        else {
+                            matchResult = 1;
+                        }
+                        switch (matchResult) {
+                            case 0: {
+                                StringBuilder__AppendLine_Z721C83C5(sb, "- **Suggested Parameters**:");
+                                const enumerator_7: IEnumerator<[string, string]> = getEnumerator(parameters_1!);
+                                try {
+                                    while (enumerator_7["System.Collections.IEnumerator.MoveNext"]()) {
+                                        const kvp: [string, string] = enumerator_7["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                                        StringBuilder__AppendLine_Z721C83C5(sb, `  - \`${kvp[0]}\`: "${kvp[1]}"`);
+                                    }
+                                }
+                                finally {
+                                    disposeSafe(enumerator_7 as IDisposable);
+                                }
+                                break;
+                            }
+                        }
+                        StringBuilder__AppendLine_Z721C83C5(sb, "- **Example YAML**:");
+                        StringBuilder__AppendLine_Z721C83C5(sb, "  ```yaml");
+                        StringBuilder__AppendLine_Z721C83C5(sb, `  action_type: "${suggestion.SuggestedActionType}"`);
+                        StringBuilder__AppendLine_Z721C83C5(sb, `  description: "[Your clinical description based on ${suggestion.EventType} event]"`);
+                        const matchValue_3: Option<FSharpMap<string, string>> = suggestion.SuggestedParameters;
+                        let matchResult_1: int32, parameters_3: FSharpMap<string, string>;
+                        if (matchValue_3 != null) {
+                            if (!FSharpMap__get_IsEmpty(value_129(matchValue_3))) {
+                                matchResult_1 = 0;
+                                parameters_3 = value_129(matchValue_3);
+                            }
+                            else {
+                                matchResult_1 = 1;
+                            }
+                        }
+                        else {
+                            matchResult_1 = 1;
+                        }
+                        switch (matchResult_1) {
+                            case 0: {
+                                StringBuilder__AppendLine_Z721C83C5(sb, "  parameters:");
+                                const enumerator_8: IEnumerator<[string, string]> = getEnumerator(parameters_3!);
+                                try {
+                                    while (enumerator_8["System.Collections.IEnumerator.MoveNext"]()) {
+                                        const kvp_1: [string, string] = enumerator_8["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                                        StringBuilder__AppendLine_Z721C83C5(sb, `    ${kvp_1[0]}: "${kvp_1[1]}"`);
+                                    }
+                                }
+                                finally {
+                                    disposeSafe(enumerator_8 as IDisposable);
+                                }
+                                break;
+                            }
+                            case 1: {
+                                StringBuilder__AppendLine_Z721C83C5(sb, "  parameters: {}");
+                                break;
+                            }
+                        }
+                        StringBuilder__AppendLine_Z721C83C5(sb, "  ```");
+                        StringBuilder__AppendLine(sb);
+                    }
+                }
+                finally {
+                    disposeSafe(enumerator_6 as IDisposable);
+                }
+            }
+        }
+        finally {
+            disposeSafe(enumerator_5 as IDisposable);
+        }
+        StringBuilder__AppendLine_Z721C83C5(sb, "💡 **LLM Guidance**: Use these suggestions to replace generic \"documentation\" actions with specific, clinically-appropriate action types.");
+        StringBuilder__AppendLine(sb);
+    }
+    if (!isEmpty(report.CrossFormReferences)) {
+        StringBuilder__AppendLine_Z721C83C5(sb, "## Cross-Form References");
+        StringBuilder__AppendLine(sb);
+        const enumerator_9: IEnumerator<FormReference> = getEnumerator(reverse<FormReference>(report.CrossFormReferences));
+        try {
+            while (enumerator_9["System.Collections.IEnumerator.MoveNext"]()) {
+                const ref: FormReference = enumerator_9["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                StringBuilder__AppendLine_Z721C83C5(sb, `- ${complexityToEmoji(ref.Complexity)} Item ${ref.SourceItemId}: References **[${ref.ReferencedFormCode}]**`);
+                StringBuilder__AppendLine_Z721C83C5(sb, `  - Context: ${(ref.SourceText.length > 100) ? (substring(ref.SourceText, 0, 100) + "...") : ref.SourceText}`);
+                StringBuilder__AppendLine_Z721C83C5(sb, `  - Suggested Action: ${ref.ActionSuggested}`);
+                StringBuilder__AppendLine(sb);
+            }
+        }
+        finally {
+            disposeSafe(enumerator_9 as IDisposable);
+        }
+    }
+    if (!isEmpty(report.InferredRelationships)) {
+        StringBuilder__AppendLine_Z721C83C5(sb, "## Inferred Relationships");
+        StringBuilder__AppendLine(sb);
+        StringBuilder__AppendLine_Z721C83C5(sb, "| C | Field 1 | Relationship | Field 2 | Evidence | Confidence |");
+        StringBuilder__AppendLine_Z721C83C5(sb, "|---|---------|--------------|---------|----------|------------|");
+        const enumerator_10: IEnumerator<InferredRelationship> = getEnumerator(reverse<InferredRelationship>(report.InferredRelationships));
+        try {
+            while (enumerator_10["System.Collections.IEnumerator.MoveNext"]()) {
+                const rel: InferredRelationship = enumerator_10["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                StringBuilder__AppendLine_Z721C83C5(sb, `| ${complexityToEmoji(rel.Complexity)} | ${rel.Field1} | ${rel.RelationType} | ${rel.Field2} | ${rel.Evidence} | %P(F2) |`);
+            }
+        }
+        finally {
+            disposeSafe(enumerator_10 as IDisposable);
+        }
+        StringBuilder__AppendLine(sb);
+    }
+    StringBuilder__AppendLine_Z721C83C5(sb, "## Recommended Enhancements");
+    StringBuilder__AppendLine(sb);
+    if (length(report.UnmappedInstructions) > 0) {
+        StringBuilder__AppendLine_Z721C83C5(sb, `1. **Parse ${length(report.UnmappedInstructions)} conditional instructions** for automated field updates`);
+    }
+    if (length(report.CrossFormReferences) > 0) {
+        StringBuilder__AppendLine_Z721C83C5(sb, `2. **Implement ${length(report.CrossFormReferences)} cross-form navigation** actions`);
+    }
+    if (length(report.InferredRelationships) > 0) {
+        StringBuilder__AppendLine_Z721C83C5(sb, `3. **Add ${length(report.InferredRelationships)} inferred field relationships** for better UX`);
+    }
+    StringBuilder__AppendLine(sb);
+    StringBuilder__AppendLine_Z721C83C5(sb, "## LLM Enhancement Prompts");
+    StringBuilder__AppendLine(sb);
+    StringBuilder__AppendLine_Z721C83C5(sb, "### For each unmapped instruction above:");
+    StringBuilder__AppendLine_Z721C83C5(sb, "```");
+    StringBuilder__AppendLine_Z721C83C5(sb, "Given the clinical context and instruction text,");
+    StringBuilder__AppendLine_Z721C83C5(sb, "suggest appropriate FormSpec actions:");
+    StringBuilder__AppendLine_Z721C83C5(sb, "1. SetFieldValue actions for automatic field updates");
+    StringBuilder__AppendLine_Z721C83C5(sb, "2. Task actions for clinical workflows");
+    StringBuilder__AppendLine_Z721C83C5(sb, "3. AdministerForm actions for form administration");
+    StringBuilder__AppendLine_Z721C83C5(sb, "4. Alert actions for critical conditions");
+    StringBuilder__AppendLine_Z721C83C5(sb, "```");
+    StringBuilder__AppendLine(sb);
+    StringBuilder__AppendLine_Z721C83C5(sb, "---");
+    StringBuilder__AppendLine_Z721C83C5(sb, "*This report identifies conversion opportunities that require semantic understanding.*");
+    StringBuilder__AppendLine_Z721C83C5(sb, "*Use with LLM/MCP tools to complete the enhancement process.*");
+    return toString_1(sb);
+}
+
+/**
+ * Main entry point to build a semantic report for CoreMR form data
+ */
+export function buildReport(formData: CoreMRFormData): string {
+    let report: SemanticReport = empty(newGuid(), formData.Metadata.FormName);
+    const enumerator: IEnumerator<CoreMRItem> = getEnumerator(formData.Items);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const item: CoreMRItem = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (hasInstruction(item.Label)) {
+                report = addUnmappedInstruction(report, item);
+            }
+            const enumerator_1: IEnumerator<FormReference> = getEnumerator(extractFormReferences(item.ItemId, item.Label));
+            try {
+                while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+                    const reference: FormReference = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    report = addCrossFormReference(report, reference);
+                }
+            }
+            finally {
+                disposeSafe(enumerator_1 as IDisposable);
+            }
+        }
+    }
+    finally {
+        disposeSafe(enumerator as IDisposable);
+    }
+    const enumerator_2: IEnumerator<ActionTypeSuggestion> = getEnumerator(buildActionTypeSuggestions(formData.Triggers, empty_1<any>()));
+    try {
+        while (enumerator_2["System.Collections.IEnumerator.MoveNext"]()) {
+            const suggestion: ActionTypeSuggestion = enumerator_2["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            report = addActionTypeSuggestion(report, suggestion);
+        }
+    }
+    finally {
+        disposeSafe(enumerator_2 as IDisposable);
+    }
+    const triggersConverted: int32 = length(formData.Triggers) | 0;
+    report = calculateMetrics(report, length(formData.Items), triggersConverted);
+    return toMarkdown(report);
+}
+
+//# sourceMappingURL=CorEMRSemanticReportBuilder.ts.map