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

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

@@ -0,0 +1,372 @@
+import { FSharpRef, Record } from "@fable-org/fable-library-js/Types.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { empty as empty_1, ofList, toList, isEmpty as isEmpty_1, tryFind as tryFind_1, FSharpMap } from "@fable-org/fable-library-js/Map.js";
+import { Spec_FormSpec$1, Spec_FormStep$1, Spec_FormField$1, Shared_PluginDataProperty, Shared_MatrixAnswer, Shared_FieldValue, Shared_FieldValue_$union, Spec_FieldType_$union, Spec_MultiChoiceInfo, Spec_SingleChoiceInfo, Shared_FieldAnswer, Shared_FieldOption, Shared_FieldKey_$reflection, Shared_FieldKey } from "../../../FormSpec.js";
+import { compare, uncurry2, uncurry3, IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { bool_type, list_type, option_type, record_type, class_type, string_type, int32_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { defaultArg, toArray, value as value_6, map, bind, Option } from "@fable-org/fable-library-js/Option.js";
+import { map as map_1, choose, mapIndexed, collect, head, tail, isEmpty, ofArray, empty, tryFind, FSharpList } from "@fable-org/fable-library-js/List.js";
+import { Helpers_canonicalizeFieldKey } from "../../../Helpers.js";
+import { isNullOrWhiteSpace } from "@fable-org/fable-library-js/String.js";
+import { object, toString } from "../../../../fable_modules/Thoth.Json.10.4.1/Encode.fs.js";
+import { keyValuePairs, map as map_2, fromString, IOptionalGetter, list as list_4, IRequiredGetter, IGetters, int, object as object_1, string, fail, succeed, andThen, guid, index, field as field_1, oneOf } from "../../../../fable_modules/Thoth.Json.10.4.1/Decode.fs.js";
+import { FSharpResult$2_$union } from "@fable-org/fable-library-js/Result.js";
+import { ErrorReason_$union } from "../../../../fable_modules/Thoth.Json.10.4.1/Types.fs.js";
+import { tryParse } from "@fable-org/fable-library-js/Guid.js";
+import { IntegrationProvenance } from "../../../Provenance.js";
+
+export class CoreMRPublishMetadata extends Record implements IEquatable<CoreMRPublishMetadata>, IComparable<CoreMRPublishMetadata> {
+    readonly FormId: int32;
+    readonly FormName: string;
+    readonly FieldKeyToSequence: FSharpMap<Shared_FieldKey, int32>;
+    constructor(FormId: int32, FormName: string, FieldKeyToSequence: FSharpMap<Shared_FieldKey, int32>) {
+        super();
+        this.FormId = (FormId | 0);
+        this.FormName = FormName;
+        this.FieldKeyToSequence = FieldKeyToSequence;
+    }
+}
+
+export function CoreMRPublishMetadata_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRPublishMetadata", [], CoreMRPublishMetadata, () => [["FormId", int32_type], ["FormName", string_type], ["FieldKeyToSequence", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [Shared_FieldKey_$reflection(), int32_type])]]);
+}
+
+export class CoreMRAnswer extends Record implements IEquatable<CoreMRAnswer>, IComparable<CoreMRAnswer> {
+    readonly Sequence: int32;
+    readonly Value: int32;
+    readonly Text: Option<string>;
+    constructor(Sequence: int32, Value: int32, Text$: Option<string>) {
+        super();
+        this.Sequence = (Sequence | 0);
+        this.Value = (Value | 0);
+        this.Text = Text$;
+    }
+}
+
+export function CoreMRAnswer_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRAnswer", [], CoreMRAnswer, () => [["Sequence", int32_type], ["Value", int32_type], ["Text", option_type(string_type)]]);
+}
+
+export class CoreMRFormInsertRequest extends Record implements IEquatable<CoreMRFormInsertRequest>, IComparable<CoreMRFormInsertRequest> {
+    readonly FormId: int32;
+    readonly FormName: string;
+    readonly Answers: Option<FSharpList<CoreMRAnswer>>;
+    readonly DryRun: Option<boolean>;
+    constructor(FormId: int32, FormName: string, Answers: Option<FSharpList<CoreMRAnswer>>, DryRun: Option<boolean>) {
+        super();
+        this.FormId = (FormId | 0);
+        this.FormName = FormName;
+        this.Answers = Answers;
+        this.DryRun = DryRun;
+    }
+}
+
+export function CoreMRFormInsertRequest_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CoreMRFormInsertRequest", [], CoreMRFormInsertRequest, () => [["FormId", int32_type], ["FormName", string_type], ["Answers", option_type(list_type(CoreMRAnswer_$reflection()))], ["DryRun", option_type(bool_type)]]);
+}
+
+function FormSpecToCoreMRInsert_getScoreFromOption(options: FSharpList<Shared_FieldOption>, selectedValue: string): Option<int32> {
+    const canonicalSelected: string = Helpers_canonicalizeFieldKey(selectedValue);
+    return bind<Shared_FieldOption, int32>((opt_1: Shared_FieldOption): Option<int32> => opt_1.Score, tryFind<Shared_FieldOption>((opt: Shared_FieldOption): boolean => (Helpers_canonicalizeFieldKey(opt.Value) === canonicalSelected), options));
+}
+
+function FormSpecToCoreMRInsert_singleToAnswer(fieldKey: Shared_FieldKey, options: FSharpList<Shared_FieldOption>, answer: Shared_FieldAnswer, seqMap: FSharpMap<Shared_FieldKey, int32>): Option<CoreMRAnswer> {
+    return map<int32, CoreMRAnswer>((seq: int32): CoreMRAnswer => {
+        const matchValue: Option<int32> = FormSpecToCoreMRInsert_getScoreFromOption(options, answer.Value);
+        if (matchValue == null) {
+            return new CoreMRAnswer(seq, 0, answer.Value);
+        }
+        else {
+            return new CoreMRAnswer(seq, value_6(matchValue), undefined);
+        }
+    }, tryFind_1<Shared_FieldKey, int32>(fieldKey, seqMap));
+}
+
+function FormSpecToCoreMRInsert_getOptionsFromFieldType(ft: Spec_FieldType_$union): FSharpList<Shared_FieldOption> {
+    let matchResult: int32, info: Spec_SingleChoiceInfo, info_1: Spec_MultiChoiceInfo;
+    switch (ft.tag) {
+        case /* Radio */ 12: {
+            matchResult = 0;
+            info = ft.fields[0];
+            break;
+        }
+        case /* SingleChoice */ 13: {
+            matchResult = 0;
+            info = ft.fields[0];
+            break;
+        }
+        case /* Dropdown */ 14: {
+            matchResult = 0;
+            info = ft.fields[0];
+            break;
+        }
+        case /* TextAutoComplete */ 18: {
+            matchResult = 0;
+            info = ft.fields[0];
+            break;
+        }
+        case /* MultiChoice */ 15: {
+            matchResult = 1;
+            info_1 = ft.fields[0];
+            break;
+        }
+        case /* CheckboxList */ 16: {
+            matchResult = 1;
+            info_1 = ft.fields[0];
+            break;
+        }
+        case /* TagList */ 17: {
+            matchResult = 1;
+            info_1 = ft.fields[0];
+            break;
+        }
+        case /* Matrix */ 19: {
+            matchResult = 2;
+            break;
+        }
+        default:
+            matchResult = 3;
+    }
+    switch (matchResult) {
+        case 0:
+            return info!.Options;
+        case 1:
+            return info_1!.Options;
+        case 2:
+            return ft.fields[0].Options;
+        default:
+            return empty<Shared_FieldOption>();
+    }
+}
+
+function FormSpecToCoreMRInsert_fieldToAnswers(field: Spec_FormField$1<Spec_FieldType_$union>, seqMap: FSharpMap<Shared_FieldKey, int32>): FSharpList<CoreMRAnswer> {
+    const matchValue: Option<Shared_FieldValue_$union> = field.Value;
+    if (matchValue != null) {
+        switch (value_6(matchValue).tag) {
+            case /* Multiple */ 1:
+                return empty<CoreMRAnswer>();
+            case /* Matrix */ 2: {
+                const matrix: Shared_MatrixAnswer = (value_6(matchValue) as Shared_FieldValue<2>).fields[0];
+                return empty<CoreMRAnswer>();
+            }
+            case /* PluginData */ 3: {
+                const props: FSharpList<Shared_PluginDataProperty> = (value_6(matchValue) as Shared_FieldValue<3>).fields[0];
+                let matchResult: int32, p_1: Shared_PluginDataProperty;
+                if (!isEmpty(props)) {
+                    if (isEmpty(tail(props))) {
+                        if (!isNullOrWhiteSpace(head(props).Value)) {
+                            matchResult = 0;
+                            p_1 = head(props);
+                        }
+                        else {
+                            matchResult = 1;
+                        }
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+                switch (matchResult) {
+                    case 0:
+                        return ofArray(toArray<CoreMRAnswer>(map<int32, CoreMRAnswer>((seq: int32): CoreMRAnswer => (new CoreMRAnswer(seq, 0, p_1!.Value)), tryFind_1<Shared_FieldKey, int32>(field.FieldKey, seqMap))));
+                    default:
+                        return empty<CoreMRAnswer>();
+                }
+            }
+            default: {
+                const answer: Shared_FieldAnswer = (value_6(matchValue) as Shared_FieldValue<0>).fields[0];
+                return ofArray(toArray<CoreMRAnswer>(FormSpecToCoreMRInsert_singleToAnswer(field.FieldKey, FormSpecToCoreMRInsert_getOptionsFromFieldType(field.FieldType), answer, seqMap)));
+            }
+        }
+    }
+    else {
+        return empty<CoreMRAnswer>();
+    }
+}
+
+function FormSpecToCoreMRInsert_fieldToValueAndText(field: Spec_FormField$1<Spec_FieldType_$union>): Option<[int32, Option<string>]> {
+    const matchValue: Option<Shared_FieldValue_$union> = field.Value;
+    let matchResult: int32, answer: Shared_FieldAnswer, p_1: Shared_PluginDataProperty;
+    if (matchValue != null) {
+        switch (value_6(matchValue).tag) {
+            case /* Single */ 0: {
+                matchResult = 1;
+                answer = (value_6(matchValue) as Shared_FieldValue<0>).fields[0];
+                break;
+            }
+            case /* PluginData */ 3: {
+                if (!isEmpty((value_6(matchValue) as Shared_FieldValue<3>).fields[0])) {
+                    if (isEmpty(tail((value_6(matchValue) as Shared_FieldValue<3>).fields[0]))) {
+                        if (!isNullOrWhiteSpace(head((value_6(matchValue) as Shared_FieldValue<3>).fields[0]).Value)) {
+                            matchResult = 2;
+                            p_1 = head((value_6(matchValue) as Shared_FieldValue<3>).fields[0]);
+                        }
+                        else {
+                            matchResult = 3;
+                        }
+                    }
+                    else {
+                        matchResult = 3;
+                    }
+                }
+                else {
+                    matchResult = 3;
+                }
+                break;
+            }
+            default:
+                matchResult = 3;
+        }
+    }
+    else {
+        matchResult = 0;
+    }
+    switch (matchResult) {
+        case 0:
+            return undefined;
+        case 1: {
+            const matchValue_1: Option<int32> = FormSpecToCoreMRInsert_getScoreFromOption(FormSpecToCoreMRInsert_getOptionsFromFieldType(field.FieldType), answer!.Value);
+            if (matchValue_1 == null) {
+                return [0, answer!.Value] as [int32, Option<string>];
+            }
+            else {
+                return [value_6(matchValue_1), undefined] as [int32, Option<string>];
+            }
+        }
+        case 2:
+            return [0, p_1!.Value] as [int32, Option<string>];
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Convert filled FormSpec to CoreMR form-insert payload.
+ * scaffoldMode: when true, omit answers (scaffold mode - all items get value=2).
+ * When false, include answers from form values (real-answers mode).
+ * When FieldKeyToSequence is empty (fallback metadata), uses positional mapping (sequence=1,2,3...).
+ */
+export function FormSpecToCoreMRInsert_convertToCoreMRInsertPayload(filledFormSpec: Spec_FormSpec$1<Spec_FieldType_$union>, metadata: CoreMRPublishMetadata, scaffoldMode: boolean, dryRun: boolean): CoreMRFormInsertRequest {
+    let allFields: FSharpList<Spec_FormField$1<Spec_FieldType_$union>>, acc: FSharpList<CoreMRAnswer>;
+    return new CoreMRFormInsertRequest(metadata.FormId, metadata.FormName, scaffoldMode ? undefined : ((allFields = collect<Spec_FormStep$1<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>>((step: Spec_FormStep$1<Spec_FieldType_$union>): FSharpList<Spec_FormField$1<Spec_FieldType_$union>> => step.Fields, filledFormSpec.Steps), (acc = (isEmpty_1<Shared_FieldKey, int32>(metadata.FieldKeyToSequence) ? mapIndexed<[int32, Option<string>], CoreMRAnswer>((i: int32, tupledArg: [int32, Option<string>]): CoreMRAnswer => (new CoreMRAnswer((2 * i) + 1, tupledArg[0], tupledArg[1])), choose<Spec_FormField$1<Spec_FieldType_$union>, [int32, Option<string>]>(FormSpecToCoreMRInsert_fieldToValueAndText, allFields)) : collect<Spec_FormField$1<Spec_FieldType_$union>, CoreMRAnswer>((f: Spec_FormField$1<Spec_FieldType_$union>): FSharpList<CoreMRAnswer> => FormSpecToCoreMRInsert_fieldToAnswers(f, metadata.FieldKeyToSequence), allFields)), isEmpty(acc) ? undefined : acc))), dryRun);
+}
+
+const CoreMRPublishMetadataCustomData_key = "coremr_publish";
+
+/**
+ * Serialize CoreMRPublishMetadata to JSON string for CustomData storage
+ */
+export function CoreMRPublishMetadataCustomData_serialize(metadata: CoreMRPublishMetadata): string {
+    return toString(0, object([["formId", metadata.FormId] as [string, any], ["formName", metadata.FormName] as [string, any], ["fieldKeyToSequence", object(map_1<[Shared_FieldKey, int32], [string, any]>((tupledArg: [Shared_FieldKey, int32]): [string, any] => ([tupledArg[0].fields[0], tupledArg[1]] as [string, any]), toList<Shared_FieldKey, int32>(metadata.FieldKeyToSequence)))] as [string, any]]));
+}
+
+const CoreMRPublishMetadataCustomData_guidDecoder = (path_6: string): ((arg0: any) => FSharpResult$2_$union<string, [string, ErrorReason_$union]>) => ((value_5: any): FSharpResult$2_$union<string, [string, ErrorReason_$union]> => oneOf<string>(ofArray([(path_2: string): ((arg0: any) => FSharpResult$2_$union<string, [string, ErrorReason_$union]>) => ((value_2: any): FSharpResult$2_$union<string, [string, ErrorReason_$union]> => field_1<string>("Fields", (path_1: string, value_1: any): FSharpResult$2_$union<string, [string, ErrorReason_$union]> => index<string>(0, guid, path_1, value_1), path_2, value_2)), (path_5: string): ((arg0: any) => FSharpResult$2_$union<string, [string, ErrorReason_$union]>) => ((value_4: any): FSharpResult$2_$union<string, [string, ErrorReason_$union]> => andThen<string, string>(uncurry3((s: string): ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<string, [string, ErrorReason_$union]>)) => {
+    let matchValue: [boolean, string];
+    let outArg = "00000000-0000-0000-0000-000000000000";
+    matchValue = ([tryParse(s, new FSharpRef<string>((): string => outArg, (v: string): void => {
+        outArg = v;
+    })), outArg] as [boolean, string]);
+    if (matchValue[0]) {
+        return (arg10$0040: string): ((arg0: any) => FSharpResult$2_$union<string, [string, ErrorReason_$union]>) => ((arg20$0040: any): FSharpResult$2_$union<string, [string, ErrorReason_$union]> => succeed<string>(matchValue[1], arg10$0040, arg20$0040));
+    }
+    else {
+        const msg = `Invalid Guid: ${s}`;
+        return (path_4: string): ((arg0: any) => FSharpResult$2_$union<string, [string, ErrorReason_$union]>) => ((arg20$0040_1: any): FSharpResult$2_$union<string, [string, ErrorReason_$union]> => fail<string>(msg, path_4, arg20$0040_1));
+    }
+}), string, path_5, value_4))]), path_6, value_5));
+
+const CoreMRPublishMetadataCustomData_sourceMapFieldAnchorDecoder = (path: string): ((arg0: any) => FSharpResult$2_$union<[Shared_FieldKey, int32], [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<[Shared_FieldKey, int32], [string, ErrorReason_$union]> => object_1<[Shared_FieldKey, int32]>((get$: IGetters): [Shared_FieldKey, int32] => {
+    let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter;
+    return [new Shared_FieldKey((objectArg = get$.Required, objectArg.Field<string>("FieldKey", uncurry2(CoreMRPublishMetadataCustomData_guidDecoder)))), (objectArg_1 = get$.Required, objectArg_1.Field<int32>("Sequence", uncurry2(int)))] as [Shared_FieldKey, int32];
+}, path, v));
+
+const CoreMRPublishMetadataCustomData_sourceMapStepDecoder = (path_1: string): ((arg0: any) => FSharpResult$2_$union<FSharpList<[Shared_FieldKey, int32]>, [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<FSharpList<[Shared_FieldKey, int32]>, [string, ErrorReason_$union]> => object_1<FSharpList<[Shared_FieldKey, int32]>>((get$: IGetters): FSharpList<[Shared_FieldKey, int32]> => {
+    let objectArg: IOptionalGetter;
+    return defaultArg((objectArg = get$.Optional, objectArg.Field<FSharpList<[Shared_FieldKey, int32]>>("FieldAnchors", (path: string, value: any): FSharpResult$2_$union<FSharpList<[Shared_FieldKey, int32]>, [string, ErrorReason_$union]> => list_4<[Shared_FieldKey, int32]>(uncurry2(CoreMRPublishMetadataCustomData_sourceMapFieldAnchorDecoder), path, value))), empty<[Shared_FieldKey, int32]>());
+}, path_1, v));
+
+const CoreMRPublishMetadataCustomData_sourceMapPayloadDecoder = (path_1: string): ((arg0: any) => FSharpResult$2_$union<[int32, FSharpMap<Shared_FieldKey, int32>], [string, ErrorReason_$union]>) => ((v: any): FSharpResult$2_$union<[int32, FSharpMap<Shared_FieldKey, int32>], [string, ErrorReason_$union]> => object_1<[int32, FSharpMap<Shared_FieldKey, int32>]>((get$: IGetters): [int32, FSharpMap<Shared_FieldKey, int32>] => {
+    let objectArg: IRequiredGetter, objectArg_1: IOptionalGetter;
+    return [(objectArg = get$.Required, objectArg.Field<int32>("FormId", uncurry2(int))), ofList<Shared_FieldKey, int32>(collect<FSharpList<[Shared_FieldKey, int32]>, [Shared_FieldKey, int32]>((x: FSharpList<[Shared_FieldKey, int32]>): FSharpList<[Shared_FieldKey, int32]> => x, defaultArg((objectArg_1 = get$.Optional, objectArg_1.Field<FSharpList<FSharpList<[Shared_FieldKey, int32]>>>("Steps", (path: string, value: any): FSharpResult$2_$union<FSharpList<FSharpList<[Shared_FieldKey, int32]>>, [string, ErrorReason_$union]> => list_4<FSharpList<[Shared_FieldKey, int32]>>(uncurry2(CoreMRPublishMetadataCustomData_sourceMapStepDecoder), path, value))), empty<FSharpList<[Shared_FieldKey, int32]>>())), {
+        Compare: compare,
+    })] as [int32, FSharpMap<Shared_FieldKey, int32>];
+}, path_1, v));
+
+function CoreMRPublishMetadataCustomData_tryDeserializeFromProvenance(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): Option<CoreMRPublishMetadata> {
+    return bind<IntegrationProvenance, CoreMRPublishMetadata>((p: IntegrationProvenance): Option<CoreMRPublishMetadata> => {
+        let matchValue_1: Option<string>;
+        if (p.IntegrationKey !== "coremr") {
+            return undefined;
+        }
+        else {
+            try {
+                const matchValue: FSharpResult$2_$union<[int32, FSharpMap<Shared_FieldKey, int32>], string> = fromString<[int32, FSharpMap<Shared_FieldKey, int32>]>(uncurry2(CoreMRPublishMetadataCustomData_sourceMapPayloadDecoder), p.Payload);
+                if (matchValue.tag === /* Error */ 1) {
+                    return undefined;
+                }
+                else {
+                    const formId: int32 = matchValue.fields[0][0] | 0;
+                    const fieldKeyToSequence: FSharpMap<Shared_FieldKey, int32> = matchValue.fields[0][1];
+                    return new CoreMRPublishMetadata(formId, !isNullOrWhiteSpace(formSpec.Title) ? formSpec.Title : ((matchValue_1 = formSpec.Code, (matchValue_1 == null) ? (`CORE-${formId}`) : value_6(matchValue_1))), fieldKeyToSequence);
+                }
+            }
+            catch (matchValue_2: any) {
+                return undefined;
+            }
+        }
+    }, formSpec.Provenance);
+}
+
+/**
+ * Deserialize CoreMRPublishMetadata from CustomData (legacy) or Provenance (current).
+ * Provenance is used when form was imported via convertWithMapAndProvenance.
+ */
+export function CoreMRPublishMetadataCustomData_tryDeserialize(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): Option<CoreMRPublishMetadata> {
+    const matchValue_2: Option<CoreMRPublishMetadata> = bind<string, CoreMRPublishMetadata>((jsonStr: string): Option<CoreMRPublishMetadata> => {
+        const matchValue_1: FSharpResult$2_$union<CoreMRPublishMetadata, string> = fromString<CoreMRPublishMetadata>((path_3: string, v_2: any): FSharpResult$2_$union<CoreMRPublishMetadata, [string, ErrorReason_$union]> => object_1<CoreMRPublishMetadata>((get$: IGetters): CoreMRPublishMetadata => {
+            let objectArg: IRequiredGetter, objectArg_1: IRequiredGetter, objectArg_2: IRequiredGetter;
+            return new CoreMRPublishMetadata((objectArg = get$.Required, objectArg.Field<int32>("formId", uncurry2(int))), (objectArg_1 = get$.Required, objectArg_1.Field<string>("formName", string)), (objectArg_2 = get$.Required, objectArg_2.Field<FSharpMap<Shared_FieldKey, int32>>("fieldKeyToSequence", (path_2: string, value_2: any): FSharpResult$2_$union<FSharpMap<Shared_FieldKey, int32>, [string, ErrorReason_$union]> => map_2<FSharpList<[string, int32]>, FSharpMap<Shared_FieldKey, int32>>((pairs: FSharpList<[string, int32]>): FSharpMap<Shared_FieldKey, int32> => ofList<Shared_FieldKey, int32>(choose<[string, int32], [Shared_FieldKey, int32]>((tupledArg: [string, int32]): Option<[Shared_FieldKey, int32]> => {
+                let matchValue: [boolean, string];
+                let outArg = "00000000-0000-0000-0000-000000000000";
+                matchValue = ([tryParse(tupledArg[0], new FSharpRef<string>((): string => outArg, (v_1: string): void => {
+                    outArg = v_1;
+                })), outArg] as [boolean, string]);
+                if (matchValue[0]) {
+                    return [new Shared_FieldKey(matchValue[1]), tupledArg[1]] as [Shared_FieldKey, int32];
+                }
+                else {
+                    return undefined;
+                }
+            }, pairs), {
+                Compare: compare,
+            }), (path_1: string, value_1: any): FSharpResult$2_$union<FSharpList<[string, int32]>, [string, ErrorReason_$union]> => keyValuePairs<int32>(uncurry2(int), path_1, value_1), path_2, value_2))));
+        }, path_3, v_2), jsonStr);
+        if (matchValue_1.tag === /* Error */ 1) {
+            return undefined;
+        }
+        else {
+            return matchValue_1.fields[0];
+        }
+    }, bind<FSharpMap<string, string>, string>((customData: FSharpMap<string, string>): Option<string> => tryFind_1<string, string>(CoreMRPublishMetadataCustomData_key, customData), formSpec.CustomData));
+    if (matchValue_2 == null) {
+        return CoreMRPublishMetadataCustomData_tryDeserializeFromProvenance(formSpec);
+    }
+    else {
+        return value_6(matchValue_2);
+    }
+}
+
+/**
+ * TEMPORARY: Return metadata or fallback when None (gate off for testing).
+ * Use when provenance/customData is missing so publish can proceed.
+ */
+export function CoreMRPublishMetadataCustomData_tryDeserializeWithFallback(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): CoreMRPublishMetadata {
+    return defaultArg(CoreMRPublishMetadataCustomData_tryDeserialize(formSpec), new CoreMRPublishMetadata(1002, isNullOrWhiteSpace(formSpec.Title) ? defaultArg<string>(formSpec.Code, "Unknown") : formSpec.Title, empty_1<Shared_FieldKey, int32>({
+        Compare: compare,
+    })));
+}
+
+//# sourceMappingURL=FormSpecToCoreMRInsert.ts.map

package/src/FormSpec.FS/Integrations/Adapters/FormSystemAdapter.ts

@@ -0,0 +1,92 @@
+import { Record } from "@fable-org/fable-library-js/Types.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { Option } from "@fable-org/fable-library-js/Option.js";
+import { IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { unit_type, lambda_type, union_type, list_type, record_type, option_type, bool_type, int32_type, string_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { FSharpResult$2_Ok, FSharpResult$2, FSharpResult$2_$union } from "@fable-org/fable-library-js/Result.js";
+import { Spec_FormSpec$1_$reflection, Spec_FieldType_$reflection, Spec_FieldType_$union, Spec_FormSpec$1 } from "../../FormSpec.js";
+import { FSharpList } from "@fable-org/fable-library-js/List.js";
+import { printf, toText } from "@fable-org/fable-library-js/String.js";
+
+export class FormMetadata extends Record implements IEquatable<FormMetadata>, IComparable<FormMetadata> {
+    readonly Title: string;
+    readonly Description: string;
+    readonly FieldCount: int32;
+    readonly HasScoring: boolean;
+    readonly HasPathways: boolean;
+    readonly Version: Option<string>;
+    constructor(Title: string, Description: string, FieldCount: int32, HasScoring: boolean, HasPathways: boolean, Version: Option<string>) {
+        super();
+        this.Title = Title;
+        this.Description = Description;
+        this.FieldCount = (FieldCount | 0);
+        this.HasScoring = HasScoring;
+        this.HasPathways = HasPathways;
+        this.Version = Version;
+    }
+}
+
+export function FormMetadata_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.FormSystemAdapter.FormMetadata", [], FormMetadata, () => [["Title", string_type], ["Description", string_type], ["FieldCount", int32_type], ["HasScoring", bool_type], ["HasPathways", bool_type], ["Version", option_type(string_type)]]);
+}
+
+export class FormSystemFeatures extends Record implements IEquatable<FormSystemFeatures>, IComparable<FormSystemFeatures> {
+    readonly SupportsScoring: boolean;
+    readonly SupportsPathways: boolean;
+    readonly SupportsValidation: boolean;
+    readonly SupportsConditionals: boolean;
+    readonly SupportsMultiStep: boolean;
+    constructor(SupportsScoring: boolean, SupportsPathways: boolean, SupportsValidation: boolean, SupportsConditionals: boolean, SupportsMultiStep: boolean) {
+        super();
+        this.SupportsScoring = SupportsScoring;
+        this.SupportsPathways = SupportsPathways;
+        this.SupportsValidation = SupportsValidation;
+        this.SupportsConditionals = SupportsConditionals;
+        this.SupportsMultiStep = SupportsMultiStep;
+    }
+}
+
+export function FormSystemFeatures_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.FormSystemAdapter.FormSystemFeatures", [], FormSystemFeatures, () => [["SupportsScoring", bool_type], ["SupportsPathways", bool_type], ["SupportsValidation", bool_type], ["SupportsConditionals", bool_type], ["SupportsMultiStep", bool_type]]);
+}
+
+export class FormSystemAdapter$1<TSource> extends Record {
+    readonly Name: string;
+    readonly ConvertToFormSpec: ((arg0: TSource) => FSharpResult$2_$union<Spec_FormSpec$1<Spec_FieldType_$union>, FSharpList<string>>);
+    readonly GenerateSemanticReport: ((arg0: TSource) => string);
+    readonly ValidateSource: ((arg0: TSource) => FSharpResult$2_$union<void, FSharpList<string>>);
+    readonly ExtractMetadata: ((arg0: TSource) => FormMetadata);
+    readonly SupportedFeatures: FormSystemFeatures;
+    constructor(Name: string, ConvertToFormSpec: ((arg0: TSource) => FSharpResult$2_$union<Spec_FormSpec$1<Spec_FieldType_$union>, FSharpList<string>>), GenerateSemanticReport: ((arg0: TSource) => string), ValidateSource: ((arg0: TSource) => FSharpResult$2_$union<void, FSharpList<string>>), ExtractMetadata: ((arg0: TSource) => FormMetadata), SupportedFeatures: FormSystemFeatures) {
+        super();
+        this.Name = Name;
+        this.ConvertToFormSpec = ConvertToFormSpec;
+        this.GenerateSemanticReport = GenerateSemanticReport;
+        this.ValidateSource = ValidateSource;
+        this.ExtractMetadata = ExtractMetadata;
+        this.SupportedFeatures = SupportedFeatures;
+    }
+}
+
+export function FormSystemAdapter$1_$reflection(gen0: TypeInfo): TypeInfo {
+    return record_type("FormSpec.Integrations.FormSystemAdapter.FormSystemAdapter`1", [gen0], FormSystemAdapter$1, () => [["Name", string_type], ["ConvertToFormSpec", lambda_type(gen0, union_type("Microsoft.FSharp.Core.FSharpResult`2", [Spec_FormSpec$1_$reflection(Spec_FieldType_$reflection()), list_type(string_type)], FSharpResult$2, () => [[["ResultValue", Spec_FormSpec$1_$reflection(Spec_FieldType_$reflection())]], [["ErrorValue", list_type(string_type)]]]))], ["GenerateSemanticReport", lambda_type(gen0, string_type)], ["ValidateSource", lambda_type(gen0, union_type("Microsoft.FSharp.Core.FSharpResult`2", [unit_type, list_type(string_type)], FSharpResult$2, () => [[["ResultValue", unit_type]], [["ErrorValue", list_type(string_type)]]]))], ["ExtractMetadata", lambda_type(gen0, FormMetadata_$reflection())], ["SupportedFeatures", FormSystemFeatures_$reflection()]]);
+}
+
+/**
+ * Compose two adapters
+ */
+export function AdapterHelpers_compose<a, b>(adapter1: FormSystemAdapter$1<a>, adapter2: FormSystemAdapter$1<b>, transformer: ((arg0: b) => a)): FormSystemAdapter$1<b> {
+    return new FormSystemAdapter$1(toText(printf("%s->%s"))(adapter2.Name)(adapter1.Name), (source: b): FSharpResult$2_$union<Spec_FormSpec$1<Spec_FieldType_$union>, FSharpList<string>> => adapter1.ConvertToFormSpec(transformer(source)), (source_1: b): string => adapter1.GenerateSemanticReport(transformer(source_1)), (source_2: b): FSharpResult$2_$union<void, FSharpList<string>> => adapter1.ValidateSource(transformer(source_2)), (source_3: b): FormMetadata => adapter1.ExtractMetadata(transformer(source_3)), adapter1.SupportedFeatures);
+}
+
+/**
+ * Create adapter with fallback
+ */
+export function AdapterHelpers_withFallback<a>(primary: FormSystemAdapter$1<a>, fallback: FormSystemAdapter$1<a>): FormSystemAdapter$1<a> {
+    return new FormSystemAdapter$1(toText(printf("%s-with-fallback"))(primary.Name), (source: a): FSharpResult$2_$union<Spec_FormSpec$1<Spec_FieldType_$union>, FSharpList<string>> => {
+        const matchValue: FSharpResult$2_$union<Spec_FormSpec$1<Spec_FieldType_$union>, FSharpList<string>> = primary.ConvertToFormSpec(source);
+        return (matchValue.tag === /* Error */ 1) ? fallback.ConvertToFormSpec(source) : FSharpResult$2_Ok<Spec_FormSpec$1<Spec_FieldType_$union>, FSharpList<string>>(matchValue.fields[0]);
+    }, primary.GenerateSemanticReport, primary.ValidateSource, primary.ExtractMetadata, primary.SupportedFeatures);
+}
+
+//# sourceMappingURL=FormSystemAdapter.ts.map

package/src/FormSpec.FS/Integrations/Adapters/ReactHookForm/ReactHookFormAdapter.ts

@@ -0,0 +1,51 @@
+import { isEmpty, map, exists, length, FSharpList, singleton } from "@fable-org/fable-library-js/List.js";
+import { FSharpResult$2_Ok, FSharpResult$2_$union, FSharpResult$2_Error } from "@fable-org/fable-library-js/Result.js";
+import { Spec_FieldType_$union, Spec_FormSpec$1 } from "../../../FormSpec.js";
+import { ReactHookFormField, ReactHookFormSchema } from "./ReactHookFormTypes.js";
+import { count } from "@fable-org/fable-library-js/Map.js";
+import { defaultArg } from "@fable-org/fable-library-js/Option.js";
+import { printf, toText, join } from "@fable-org/fable-library-js/String.js";
+import { FormSystemAdapter$1, FormSystemFeatures, FormMetadata } from "../FormSystemAdapter.js";
+
+export const adapter: FormSystemAdapter$1<ReactHookFormSchema> = new FormSystemAdapter$1("react-hook-form", (schema: ReactHookFormSchema): FSharpResult$2_$union<Spec_FormSpec$1<Spec_FieldType_$union>, FSharpList<string>> => FSharpResult$2_Error<Spec_FormSpec$1<Spec_FieldType_$union>, FSharpList<string>>(singleton("React Hook Form conversion not yet implemented. This adapter is a placeholder for future development.")), (schema_1: ReactHookFormSchema): string => (`
+        # React Hook Form Schema
+
+        ## Summary
+        React Hook Form semantic report generation is not yet implemented.
+
+        ## Schema Overview
+        - Field Count: ${length<ReactHookFormField>(schema_1.Fields)}
+        - Has Validation: ${exists<ReactHookFormField>((f: ReactHookFormField): boolean => {
+    if (f.Required) {
+        return true;
+    }
+    else {
+        return f.ValidationRules != null;
+    }
+}, schema_1.Fields) ? "Yes" : "No"}
+        - Default Values: ${count<string, string>(schema_1.DefaultValues)} fields
+        - Validation Mode: ${defaultArg(schema_1.ValidationMode, "onSubmit")}
+
+        ## Fields
+        ${join("\n", map<ReactHookFormField, string>((f_1: ReactHookFormField): string => {
+    const required: string = f_1.Required ? " *required" : "";
+    return toText(printf("- %s (%s)%s"))(f_1.Name)(f_1.Type)(required);
+}, schema_1.Fields))}
+
+        ## Next Steps
+        This is a stub implementation. To complete the adapter:
+        1. Implement field type mapping from React Hook Form to FormSpec
+        2. Handle validation rules conversion (yup, zod, joi, etc.)
+        3. Process default values and initial state
+        4. Map React Hook Form's control flow to FormSpec pathways
+        5. Generate comprehensive semantic reports
+
+        ## Supported Features (When Implemented)
+        - Dynamic field arrays
+        - Nested field structures
+        - Custom validation
+        - Field dependencies
+        - Conditional rendering
+        `), (schema_2: ReactHookFormSchema): FSharpResult$2_$union<void, FSharpList<string>> => (isEmpty(schema_2.Fields) ? FSharpResult$2_Error<void, FSharpList<string>>(singleton("Schema has no fields defined")) : FSharpResult$2_Ok<void, FSharpList<string>>(undefined)), (schema_3: ReactHookFormSchema): FormMetadata => (new FormMetadata("React Hook Form", "Imported from React Hook Form schema", length<ReactHookFormField>(schema_3.Fields), false, false, undefined)), new FormSystemFeatures(false, false, true, true, false));
+
+//# sourceMappingURL=ReactHookFormAdapter.ts.map

package/src/FormSpec.FS/Integrations/Adapters/ReactHookForm/ReactHookFormTypes.ts

@@ -0,0 +1,71 @@
+import { Record } from "@fable-org/fable-library-js/Types.js";
+import { Option } from "@fable-org/fable-library-js/Option.js";
+import { IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { class_type, list_type, float64_type, int32_type, record_type, option_type, bool_type, string_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { float64, int32 } from "@fable-org/fable-library-js/Int32.js";
+import { FSharpList } from "@fable-org/fable-library-js/List.js";
+import { FSharpMap } from "@fable-org/fable-library-js/Map.js";
+
+export class ReactHookFormField extends Record implements IEquatable<ReactHookFormField>, IComparable<ReactHookFormField> {
+    readonly Name: string;
+    readonly Type: string;
+    readonly Required: boolean;
+    readonly DefaultValue: Option<string>;
+    readonly ValidationRules: Option<ReactHookFormValidation>;
+    constructor(Name: string, Type: string, Required: boolean, DefaultValue: Option<string>, ValidationRules: Option<ReactHookFormValidation>) {
+        super();
+        this.Name = Name;
+        this.Type = Type;
+        this.Required = Required;
+        this.DefaultValue = DefaultValue;
+        this.ValidationRules = ValidationRules;
+    }
+}
+
+export function ReactHookFormField_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.ReactHookForm.ReactHookFormTypes.ReactHookFormField", [], ReactHookFormField, () => [["Name", string_type], ["Type", string_type], ["Required", bool_type], ["DefaultValue", option_type(string_type)], ["ValidationRules", option_type(ReactHookFormValidation_$reflection())]]);
+}
+
+export class ReactHookFormValidation extends Record implements IEquatable<ReactHookFormValidation>, IComparable<ReactHookFormValidation> {
+    readonly Required: boolean;
+    readonly MinLength: Option<int32>;
+    readonly MaxLength: Option<int32>;
+    readonly Pattern: Option<string>;
+    readonly Min: Option<float64>;
+    readonly Max: Option<float64>;
+    readonly Custom: Option<string>;
+    constructor(Required: boolean, MinLength: Option<int32>, MaxLength: Option<int32>, Pattern: Option<string>, Min: Option<float64>, Max: Option<float64>, Custom: Option<string>) {
+        super();
+        this.Required = Required;
+        this.MinLength = MinLength;
+        this.MaxLength = MaxLength;
+        this.Pattern = Pattern;
+        this.Min = Min;
+        this.Max = Max;
+        this.Custom = Custom;
+    }
+}
+
+export function ReactHookFormValidation_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.ReactHookForm.ReactHookFormTypes.ReactHookFormValidation", [], ReactHookFormValidation, () => [["Required", bool_type], ["MinLength", option_type(int32_type)], ["MaxLength", option_type(int32_type)], ["Pattern", option_type(string_type)], ["Min", option_type(float64_type)], ["Max", option_type(float64_type)], ["Custom", option_type(string_type)]]);
+}
+
+export class ReactHookFormSchema extends Record implements IEquatable<ReactHookFormSchema>, IComparable<ReactHookFormSchema> {
+    readonly Fields: FSharpList<ReactHookFormField>;
+    readonly DefaultValues: FSharpMap<string, string>;
+    readonly SubmitHandler: Option<string>;
+    readonly ValidationMode: Option<string>;
+    constructor(Fields: FSharpList<ReactHookFormField>, DefaultValues: FSharpMap<string, string>, SubmitHandler: Option<string>, ValidationMode: Option<string>) {
+        super();
+        this.Fields = Fields;
+        this.DefaultValues = DefaultValues;
+        this.SubmitHandler = SubmitHandler;
+        this.ValidationMode = ValidationMode;
+    }
+}
+
+export function ReactHookFormSchema_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.ReactHookForm.ReactHookFormTypes.ReactHookFormSchema", [], ReactHookFormSchema, () => [["Fields", list_type(ReactHookFormField_$reflection())], ["DefaultValues", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, string_type])], ["SubmitHandler", option_type(string_type)], ["ValidationMode", option_type(string_type)]]);
+}
+
+//# sourceMappingURL=ReactHookFormTypes.ts.map

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

@@ -0,0 +1,15 @@
+import { Auto_generateBoxedDecoder_Z6670B51, fromString } from "../../../fable_modules/Thoth.Json.10.4.1/Decode.fs.js";
+import { uncurry2 } from "@fable-org/fable-library-js/Util.js";
+import { array_type, bool_type, int32_type, class_type, option_type, anonRecord_type, string_type } from "@fable-org/fable-library-js/Reflection.js";
+import { FSharpMap } from "@fable-org/fable-library-js/Map.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { FSharpResult$2_$union } from "@fable-org/fable-library-js/Result.js";
+
+/**
+ * Load and decode templates.json. Path is relative to FormSpec.FS output (Interop/templates.json).
+ */
+export function decodeTemplates(json: string): FSharpResult$2_$union<{ $schema: string, coreEmr?: { appVersion: string, schemaRevision: string, schemaVersion: string }, elementTypes: FSharpMap<string, { code: string, textField: string, valueEncoding: string }>, forms: FSharpMap<string, { clinicalHash?: string, cosmeticHash?: string, currentVersionId?: int32, description?: string, encounterTypes?: { dental: boolean, medical: boolean, mental: boolean, other: boolean }, formCode?: string, formCodeSource?: string, formId: int32, hash?: string, isIntake?: boolean, items: { choices: { bitPosition?: int32, choiceId: int32, code?: string, highlight?: int32, score: int32, sequence: int32, text: string }[], code?: string, genderRequired?: string, highlight?: int32, isRequired: boolean, itemId: int32, nestingLevel: int32, sequence: int32, sequenceText?: string, text: string, type: int32, uuid?: string }[], name: string, onceAYear?: boolean, requiresSignature?: boolean, scoring?: { choiceScores: FSharpMap<string, int32>, labels: { min: int32, name: string }[], scoreId: int32, scoreName: string }, structureHash?: string, usage?: string }>, generatedAt?: string, generatedFrom?: string, stats?: { byElementType: FSharpMap<string, int32>, byUsage: FSharpMap<string, int32>, codeExtraction: { bySource: { description: int32, generated: int32, name: int32 }, extracted: int32, generated: int32, regex: string }, totalForms: int32, withCodes: int32, withScoring: int32, withSignature: int32, withSyntheticCodes: int32 }, version: int32 }, string> {
+    return fromString<{ $schema: string, coreEmr?: { appVersion: string, schemaRevision: string, schemaVersion: string }, elementTypes: FSharpMap<string, { code: string, textField: string, valueEncoding: string }>, forms: FSharpMap<string, { clinicalHash?: string, cosmeticHash?: string, currentVersionId?: int32, description?: string, encounterTypes?: { dental: boolean, medical: boolean, mental: boolean, other: boolean }, formCode?: string, formCodeSource?: string, formId: int32, hash?: string, isIntake?: boolean, items: { choices: { bitPosition?: int32, choiceId: int32, code?: string, highlight?: int32, score: int32, sequence: int32, text: string }[], code?: string, genderRequired?: string, highlight?: int32, isRequired: boolean, itemId: int32, nestingLevel: int32, sequence: int32, sequenceText?: string, text: string, type: int32, uuid?: string }[], name: string, onceAYear?: boolean, requiresSignature?: boolean, scoring?: { choiceScores: FSharpMap<string, int32>, labels: { min: int32, name: string }[], scoreId: int32, scoreName: string }, structureHash?: string, usage?: string }>, generatedAt?: string, generatedFrom?: string, stats?: { byElementType: FSharpMap<string, int32>, byUsage: FSharpMap<string, int32>, codeExtraction: { bySource: { description: int32, generated: int32, name: int32 }, extracted: int32, generated: int32, regex: string }, totalForms: int32, withCodes: int32, withScoring: int32, withSignature: int32, withSyntheticCodes: int32 }, version: int32 }>(uncurry2(Auto_generateBoxedDecoder_Z6670B51(anonRecord_type(["$schema", string_type], ["coreEmr", option_type(anonRecord_type(["appVersion", string_type], ["schemaRevision", string_type], ["schemaVersion", string_type]))], ["elementTypes", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, anonRecord_type(["code", string_type], ["textField", string_type], ["valueEncoding", string_type])])], ["forms", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, anonRecord_type(["clinicalHash", option_type(string_type)], ["cosmeticHash", option_type(string_type)], ["currentVersionId", option_type(int32_type)], ["description", option_type(string_type)], ["encounterTypes", option_type(anonRecord_type(["dental", bool_type], ["medical", bool_type], ["mental", bool_type], ["other", bool_type]))], ["formCode", option_type(string_type)], ["formCodeSource", option_type(string_type)], ["formId", int32_type], ["hash", option_type(string_type)], ["isIntake", option_type(bool_type)], ["items", array_type(anonRecord_type(["choices", array_type(anonRecord_type(["bitPosition", option_type(int32_type)], ["choiceId", int32_type], ["code", option_type(string_type)], ["highlight", option_type(int32_type)], ["score", int32_type], ["sequence", int32_type], ["text", string_type]))], ["code", option_type(string_type)], ["genderRequired", option_type(string_type)], ["highlight", option_type(int32_type)], ["isRequired", bool_type], ["itemId", int32_type], ["nestingLevel", int32_type], ["sequence", int32_type], ["sequenceText", option_type(string_type)], ["text", string_type], ["type", int32_type], ["uuid", option_type(string_type)]))], ["name", string_type], ["onceAYear", option_type(bool_type)], ["requiresSignature", option_type(bool_type)], ["scoring", option_type(anonRecord_type(["choiceScores", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, int32_type])], ["labels", array_type(anonRecord_type(["min", int32_type], ["name", string_type]))], ["scoreId", int32_type], ["scoreName", string_type]))], ["structureHash", option_type(string_type)], ["usage", option_type(string_type)])])], ["generatedAt", option_type(string_type)], ["generatedFrom", option_type(string_type)], ["stats", option_type(anonRecord_type(["byElementType", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, int32_type])], ["byUsage", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, int32_type])], ["codeExtraction", anonRecord_type(["bySource", anonRecord_type(["description", int32_type], ["generated", int32_type], ["name", int32_type])], ["extracted", int32_type], ["generated", int32_type], ["regex", string_type])], ["totalForms", int32_type], ["withCodes", int32_type], ["withScoring", int32_type], ["withSignature", int32_type], ["withSyntheticCodes", int32_type]))], ["version", int32_type]), undefined, undefined)), json);
+}
+
+//# sourceMappingURL=CorEmrTemplates.ts.map