@magnusopera/fscript 0.81.4 → 0.81.6

package/dist/FScript.Language/Eval.js

@@ -2006,88 +2006,112 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                 const target_2 = expr.fields[0];
                 const span_12 = expr.fields[2];
                 const fieldName = expr.fields[1];
-                let matchResult_2, moduleName_1;
-                if (target_2.tag === 2) {
-                    if (!FSharpMap__ContainsKey(env, target_2.fields[0])) {
-                        matchResult_2 = 0;
-                        moduleName_1 = target_2.fields[0];
-                    }
-                    else {
-                        matchResult_2 = 1;
-                    }
-                }
-                else {
-                    matchResult_2 = 1;
-                }
-                switch (matchResult_2) {
-                    case 0: {
-                        const matchValue_11 = FSharpMap__TryFind(env, concat(moduleName_1, ".", fieldName));
-                        if (matchValue_11 == null) {
-                            const matchValue_12 = evalExpr(runtime, typeDefs, env, target_2);
-                            let matchResult_3, fields_4;
-                            switch (matchValue_12.tag) {
-                                case 7: {
-                                    matchResult_3 = 0;
-                                    fields_4 = matchValue_12.fields[0];
-                                    break;
-                                }
-                                case 16: {
-                                    matchResult_3 = 0;
-                                    fields_4 = matchValue_12.fields[0].Fields;
-                                    break;
-                                }
-                                default:
-                                    matchResult_3 = 1;
+                const qualifiedTarget = (_arg_1) => {
+                    let matchResult_2, name_10, name_11, parent;
+                    switch (_arg_1.tag) {
+                        case 2: {
+                            if (!FSharpMap__ContainsKey(env, _arg_1.fields[0])) {
+                                matchResult_2 = 0;
+                                name_10 = _arg_1.fields[0];
                             }
-                            switch (matchResult_3) {
-                                case 0: {
-                                    const matchValue_13 = FSharpMap__TryFind(fields_4, fieldName);
-                                    if (matchValue_13 == null) {
-                                        throw new EvalException(new EvalError$(toText(printf("Record field \'%s\' not found"))(fieldName), span_12));
-                                    }
-                                    else {
-                                        return matchValue_13;
-                                    }
-                                }
-                                default:
-                                    throw new EvalException(new EvalError$("Field access requires a record value", span_12));
+                            else {
+                                matchResult_2 = 2;
                             }
+                            break;
                         }
-                        else {
-                            return matchValue_11;
+                        case 21: {
+                            matchResult_2 = 1;
+                            name_11 = _arg_1.fields[1];
+                            parent = _arg_1.fields[0];
+                            break;
                         }
+                        default:
+                            matchResult_2 = 2;
                     }
-                    default: {
-                        const matchValue_14 = evalExpr(runtime, typeDefs, env, target_2);
-                        let matchResult_4, fields_5;
-                        switch (matchValue_14.tag) {
+                    switch (matchResult_2) {
+                        case 0:
+                            return name_10;
+                        case 1: {
+                            const option_1 = qualifiedTarget(parent);
+                            if (option_1 != null) {
+                                return (option_1 + ".") + name_11;
+                            }
+                            else {
+                                return undefined;
+                            }
+                        }
+                        default:
+                            return undefined;
+                    }
+                };
+                const matchValue_11 = qualifiedTarget(target_2);
+                if (matchValue_11 != null) {
+                    const matchValue_12 = FSharpMap__TryFind(env, concat(matchValue_11, ".", fieldName));
+                    if (matchValue_12 == null) {
+                        const matchValue_13 = evalExpr(runtime, typeDefs, env, target_2);
+                        let matchResult_3, fields_4;
+                        switch (matchValue_13.tag) {
                             case 7: {
-                                matchResult_4 = 0;
-                                fields_5 = matchValue_14.fields[0];
+                                matchResult_3 = 0;
+                                fields_4 = matchValue_13.fields[0];
                                 break;
                             }
                             case 16: {
-                                matchResult_4 = 0;
-                                fields_5 = matchValue_14.fields[0].Fields;
+                                matchResult_3 = 0;
+                                fields_4 = matchValue_13.fields[0].Fields;
                                 break;
                             }
                             default:
-                                matchResult_4 = 1;
+                                matchResult_3 = 1;
                         }
-                        switch (matchResult_4) {
+                        switch (matchResult_3) {
                             case 0: {
-                                const matchValue_15 = FSharpMap__TryFind(fields_5, fieldName);
-                                if (matchValue_15 == null) {
+                                const matchValue_14 = FSharpMap__TryFind(fields_4, fieldName);
+                                if (matchValue_14 == null) {
                                     throw new EvalException(new EvalError$(toText(printf("Record field \'%s\' not found"))(fieldName), span_12));
                                 }
                                 else {
-                                    return matchValue_15;
+                                    return matchValue_14;
                                 }
                             }
                             default:
                                 throw new EvalException(new EvalError$("Field access requires a record value", span_12));
                         }
                     }
+                    else {
+                        return matchValue_12;
+                    }
+                }
+                else {
+                    const matchValue_15 = evalExpr(runtime, typeDefs, env, target_2);
+                    let matchResult_4, fields_5;
+                    switch (matchValue_15.tag) {
+                        case 7: {
+                            matchResult_4 = 0;
+                            fields_5 = matchValue_15.fields[0];
+                            break;
+                        }
+                        case 16: {
+                            matchResult_4 = 0;
+                            fields_5 = matchValue_15.fields[0].Fields;
+                            break;
+                        }
+                        default:
+                            matchResult_4 = 1;
+                    }
+                    switch (matchResult_4) {
+                        case 0: {
+                            const matchValue_16 = FSharpMap__TryFind(fields_5, fieldName);
+                            if (matchValue_16 == null) {
+                                throw new EvalException(new EvalError$(toText(printf("Record field \'%s\' not found"))(fieldName), span_12));
+                            }
+                            else {
+                                return matchValue_16;
+                            }
+                        }
+                        default:
+                            throw new EvalException(new EvalError$("Field access requires a record value", span_12));
+                    }
                 }
             }
             case 22: {
@@ -2428,22 +2452,22 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
             case 27:
                 return new Value(/* VOption */ 9, [undefined]);
             case 28: {
-                const name_9 = expr.fields[0];
-                const matchValue_24 = FSharpMap__TryFind(typeDefs, name_9);
-                if (matchValue_24 == null) {
-                    throw new EvalException(new EvalError$(concat("Unknown type \'", name_9, "\'"), expr.fields[1]));
+                const name_12 = expr.fields[0];
+                const matchValue_25 = FSharpMap__TryFind(typeDefs, name_12);
+                if (matchValue_25 == null) {
+                    throw new EvalException(new EvalError$(concat("Unknown type \'", name_12, "\'"), expr.fields[1]));
                 }
                 else {
-                    return new Value(/* VTypeToken */ 12, [matchValue_24]);
+                    return new Value(/* VTypeToken */ 12, [matchValue_25]);
                 }
             }
             case 29: {
-                const name_10 = expr.fields[0];
-                if (FSharpMap__ContainsKey(env, name_10)) {
-                    return new Value(/* VString */ 4, [name_10]);
+                const name_13 = expr.fields[0];
+                if (FSharpMap__ContainsKey(env, name_13)) {
+                    return new Value(/* VString */ 4, [name_13]);
                 }
                 else {
-                    throw new EvalException(new EvalError$(concat("Unbound variable \'", name_10, "\'"), expr.fields[1]));
+                    throw new EvalException(new EvalError$(concat("Unbound variable \'", name_13, "\'"), expr.fields[1]));
                 }
             }
             case 30: {
@@ -2811,9 +2835,14 @@ export function evalProgramWithRegistrationState(registration, program) {
             return ofArray([[caseName_2, value], [concat(typeName, ".", caseName_2), value]]);
         }, tupledArg_6[1].Cases);
     }, toList(decls));
+    const constructorValues_1 = append(collect((descriptor) => collect((tupledArg_8) => {
+        const caseName_3 = tupledArg_8[0];
+        const value_1 = (tupledArg_8[1] == null) ? (new Value(/* VUnionCase */ 10, [descriptor.Name, caseName_3, undefined])) : (new Value(/* VUnionCtor */ 11, [descriptor.Name, caseName_3]));
+        return ofArray([[caseName_3, value_1], [concat(descriptor.Name, ".", caseName_3), value_1]]);
+    }, toList(descriptor.Cases)), registration.Unions), constructorValues);
     const externContext = createExternContext(runtime, typeDefs_1, unknownSpan);
     let env;
-    const list_13 = append(builtinExterns, externs);
+    const list_15 = append(builtinExterns, externs);
     env = fold_1((acc_1, ext_2) => {
         if (ext_2.Arity === 0) {
             return FSharpMap__Add(acc_1, ext_2.Name, invoke(typeDefs_1, ext_2, externContext, empty()));
@@ -2823,8 +2852,8 @@ export function evalProgramWithRegistrationState(registration, program) {
         }
     }, empty_1({
         Compare: (x_7, y_8) => (comparePrimitives(x_7, y_8) | 0),
-    }), list_13);
-    env = fold_1((acc_2, tupledArg_8) => FSharpMap__Add(acc_2, tupledArg_8[0], tupledArg_8[1]), env, constructorValues);
+    }), list_15);
+    env = fold_1((acc_2, tupledArg_9) => FSharpMap__Add(acc_2, tupledArg_9[0], tupledArg_9[1]), env, constructorValues_1);
     return evaluateStatements(runtime, typeDefs_1, env, program);
 }
 

package/dist/FScript.Language/HostInterop.js

@@ -4,11 +4,11 @@ import { EvalException, EvalError$ } from "./Error.js";
 import { tail as tail_1, head, isEmpty as isEmpty_1, iterate2, iterate as iterate_1, tryFind as tryFind_1, forAll2, length, forAll as forAll_1, contains, map, ofArray, append, empty as empty_1 } from "../fable_modules/fable-library-js.5.13.0/List.js";
 import { Value, HostManagedValue, ExtensionRegistration } from "./Value.js";
 import { typeDefs } from "./BuiltinTypes.js";
-import { FSharpMap__get_Item, iterate, map as map_1, FSharpMap__get_Count, FSharpMap__TryFind, tryFind, forAll, FSharpMap__Add, containsKey, empty as empty_2 } from "../fable_modules/fable-library-js.5.13.0/Map.js";
+import { FSharpMap__get_Item, iterate, map as map_1, FSharpMap__get_Count, FSharpMap__TryFind, tryFind, forAll, exists, FSharpMap__get_IsEmpty, FSharpMap__Add, containsKey, empty as empty_2 } from "../fable_modules/fable-library-js.5.13.0/Map.js";
 import { curry2, stringHash, disposeSafe, getEnumerator, comparePrimitives } from "../fable_modules/fable-library-js.5.13.0/Util.js";
 import { concat, isNullOrWhiteSpace } from "../fable_modules/fable-library-js.5.13.0/String.js";
 import { Types_ftvType, Types_typeToString, Type } from "./Types.js";
-import { exists } from "../fable_modules/fable-library-js.5.13.0/Seq.js";
+import { exists as exists_1 } from "../fable_modules/fable-library-js.5.13.0/Seq.js";
 import { value as value_4, toArray } from "../fable_modules/fable-library-js.5.13.0/Option.js";
 import { minElement, isEmpty } from "../fable_modules/fable-library-js.5.13.0/Set.js";
 import { min } from "../fable_modules/fable-library-js.5.13.0/Double.js";
@@ -19,10 +19,10 @@ function fail(message) {
     throw new EvalException(new EvalError$(message, span));
 }
 
-export const empty = new ExtensionRegistration(empty_1(), empty_1());
+export const empty = new ExtensionRegistration(empty_1(), empty_1(), empty_1());
 
 export function ofExterns(functions) {
-    return new ExtensionRegistration(empty.Types, functions);
+    return new ExtensionRegistration(empty.Types, empty.Unions, functions);
 }
 
 export function typeDefinitions(registration, scriptNames) {
@@ -49,6 +49,28 @@ export function typeDefinitions(registration, scriptNames) {
     finally {
         disposeSafe(enumerator);
     }
+    const enumerator_1 = getEnumerator(registration.Unions);
+    try {
+        while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+            const descriptor_1 = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (isNullOrWhiteSpace(descriptor_1.Name) ? true : FSharpMap__get_IsEmpty(descriptor_1.Cases)) {
+                fail("Host unions require a name and at least one case");
+            }
+            if (contains(descriptor_1.Name, reserved, {
+                Equals: (x_2, y_2) => (x_2 === y_2),
+                GetHashCode: (x_2) => (stringHash(x_2) | 0),
+            }) ? true : containsKey(descriptor_1.Name, definitions)) {
+                fail(concat("Host type name conflict: \'", descriptor_1.Name, "\'"));
+            }
+            if (exists((name, _arg) => isNullOrWhiteSpace(name), descriptor_1.Cases)) {
+                fail(concat("Host union \'", descriptor_1.Name, "\' has an empty case name"));
+            }
+            definitions = FSharpMap__Add(definitions, descriptor_1.Name, new Type(/* TUnion */ 13, [descriptor_1.Name, descriptor_1.Cases]));
+        }
+    }
+    finally {
+        disposeSafe(enumerator_1);
+    }
     return definitions;
 }
 
@@ -56,7 +78,7 @@ export function matches(definitions_mut, expected_mut, value_mut) {
     matches:
     while (true) {
         const definitions = definitions_mut, expected = expected_mut, value = value_mut;
-        const fieldsMatch = (fields, values) => forAll((name, fieldType) => exists((value_1) => matches(definitions, fieldType, value_1), toArray(tryFind(name, values))), fields);
+        const fieldsMatch = (fields, values) => forAll((name, fieldType) => exists_1((value_1) => matches(definitions, fieldType, value_1), toArray(tryFind(name, values))), fields);
         let matchResult, name_1, fields_1, host, name_2, fields_2, values_1, constructible, fields_3, host_1, fields_4, values_2, t_1, values_3, ts, values_4, t_2, v, t_3, values_5, actualName, caseName, cases, name_3, payload;
         switch (expected.tag) {
             case 17: {
@@ -264,7 +286,7 @@ export function matches(definitions_mut, expected_mut, value_mut) {
         }
         switch (matchResult) {
             case 0:
-                return exists((t) => matches(definitions, t, value), toArray(FSharpMap__TryFind(definitions, name_1)));
+                return exists_1((t) => matches(definitions, t, value), toArray(FSharpMap__TryFind(definitions, name_1)));
             case 1:
                 if (((host.Descriptor.HostManaged && (host.Descriptor.Name === name_2)) && host.Descriptor.Fields.Equals(fields_1)) && (FSharpMap__get_Count(host.Fields) === FSharpMap__get_Count(fields_1))) {
                     return fieldsMatch(fields_1, host.Fields);

package/dist/FScript.Language/Interactive.js

@@ -111,6 +111,7 @@ export function retainedCount(session) {
 }
 
 export function submit(session, program) {
+    let bind$0040;
     const retainedRev = appendRetained(session.RetainedProgramRev, program);
     const retainedCount_1 = length(retainedRev) | 0;
     const containsTypeDeclaration = exists((_arg) => {
@@ -133,7 +134,7 @@ export function submit(session, program) {
         }
         else {
             const previousState = matchValue;
-            const typed_2 = inferProgramWithRegistration(new ExtensionRegistration(session.Registration.Types, append(session.Registration.Functions, toList_1(values(session.InferenceBindings)))), append(session.TypeDeclarations, program));
+            const typed_2 = inferProgramWithRegistration((bind$0040 = session.Registration, new ExtensionRegistration(bind$0040.Types, bind$0040.Unions, append(session.Registration.Functions, toList_1(values(session.InferenceBindings))))), append(session.TypeDeclarations, program));
             const submittedTyped_1 = skip(length(session.TypeDeclarations), typed_2);
             const state_2 = evalProgramFromState(previousState, submittedTyped_1);
             return new Submission(new Session(session.Registration, retainedRev, session.TypeDeclarations, updateInferenceBindings(session.InferenceBindings, submittedTyped_1), state_2), submittedTyped_1, state_2, retainedCount_1);

package/dist/FScript.Language/TypeInfer.js

@@ -2935,39 +2935,63 @@ function inferExprRaw(telemetry, typeDefs, constructors, env, expr) {
                         throw new TypeException(new TypeError$("Field access requires a record value", span_18));
                 }
             };
-            let matchResult_6, moduleName_1;
-            if (target.tag === 2) {
-                if (!FSharpMap__ContainsKey(env, target.fields[0])) {
-                    matchResult_6 = 0;
-                    moduleName_1 = target.fields[0];
+            const qualifiedTarget = (_arg_9) => {
+                let matchResult_6, name_21, name_22, parent;
+                switch (_arg_9.tag) {
+                    case 2: {
+                        if (!FSharpMap__ContainsKey(env, _arg_9.fields[0])) {
+                            matchResult_6 = 0;
+                            name_21 = _arg_9.fields[0];
+                        }
+                        else {
+                            matchResult_6 = 2;
+                        }
+                        break;
+                    }
+                    case 21: {
+                        matchResult_6 = 1;
+                        name_22 = _arg_9.fields[1];
+                        parent = _arg_9.fields[0];
+                        break;
+                    }
+                    default:
+                        matchResult_6 = 2;
+                }
+                switch (matchResult_6) {
+                    case 0:
+                        return name_21;
+                    case 1: {
+                        const option_2 = qualifiedTarget(parent);
+                        if (option_2 != null) {
+                            return (option_2 + ".") + name_22;
+                        }
+                        else {
+                            return undefined;
+                        }
+                    }
+                    default:
+                        return undefined;
+                }
+            };
+            const matchValue_16 = qualifiedTarget(target);
+            if (matchValue_16 != null) {
+                const matchValue_17 = FSharpMap__TryFind(env, concat(matchValue_16, ".", fieldName));
+                if (matchValue_17 == null) {
+                    const patternInput_37 = inferExpr(telemetry, typeDefs, constructors, env, target);
+                    const patternInput_38 = inferRecordField(patternInput_37[0], patternInput_37[1]);
+                    const tField_7 = patternInput_38[1];
+                    return [patternInput_38[0], tField_7, asTyped(expr, tField_7)];
                 }
                 else {
-                    matchResult_6 = 1;
+                    const t_7 = instantiate(matchValue_17);
+                    return [emptySubst, t_7, asTyped(expr, t_7)];
                 }
             }
             else {
-                matchResult_6 = 1;
-            }
-            switch (matchResult_6) {
-                case 0: {
-                    const matchValue_16 = FSharpMap__TryFind(env, concat(moduleName_1, ".", fieldName));
-                    if (matchValue_16 == null) {
-                        const patternInput_37 = inferExpr(telemetry, typeDefs, constructors, env, target);
-                        const patternInput_38 = inferRecordField(patternInput_37[0], patternInput_37[1]);
-                        const tField_7 = patternInput_38[1];
-                        return [patternInput_38[0], tField_7, asTyped(expr, tField_7)];
-                    }
-                    else {
-                        const t_7 = instantiate(matchValue_16);
-                        return [emptySubst, t_7, asTyped(expr, t_7)];
-                    }
-                }
-                default: {
-                    const patternInput_39 = inferExpr(telemetry, typeDefs, constructors, env, target);
-                    const patternInput_40 = inferRecordField(patternInput_39[0], patternInput_39[1]);
-                    const tField_8 = patternInput_40[1];
-                    return [patternInput_40[0], tField_8, asTyped(expr, tField_8)];
-                }
+                const patternInput_39 = inferExpr(telemetry, typeDefs, constructors, env, target);
+                const patternInput_40 = inferRecordField(patternInput_39[0], patternInput_39[1]);
+                const tField_8 = patternInput_40[1];
+                return [patternInput_40[0], tField_8, asTyped(expr, tField_8)];
             }
         }
         case 22: {
@@ -3240,6 +3264,7 @@ function topLevelBindingNames(program) {
 }
 
 function inferProgramWithExternsRawAndLocals(captureLocalVariables, registration, program) {
+    let list_11;
     let hostDefinitions;
     try {
         hostDefinitions = typeDefinitions(registration, append(map_1((d) => d.Name, typeDefs_2), choose((_arg) => {
@@ -3285,7 +3310,7 @@ function inferProgramWithExternsRawAndLocals(captureLocalVariables, registration
             })]);
         }
     }, decls), hostDefinitions);
-    const constructors = ofList(collect((tupledArg_2) => {
+    const constructors = ofList((list_11 = collect((tupledArg_2) => {
         const typeName = tupledArg_2[0];
         return collect((tupledArg_3) => {
             let option_3;
@@ -3293,16 +3318,20 @@ function inferProgramWithExternsRawAndLocals(captureLocalVariables, registration
             const sigInfo = new ConstructorSig(typeName, (option_3 = tupledArg_3[1], (option_3 != null) ? typeFromRef(decls, singleton(typeName), option_3) : undefined));
             return ofArray([[caseName_1, sigInfo], [concat(typeName, ".", caseName_1), sigInfo]]);
         }, tupledArg_2[1].Cases);
-    }, toList(decls)), {
+    }, toList(decls)), append(collect((descriptor) => collect((tupledArg_4) => {
+        const caseName_2 = tupledArg_4[0];
+        const info = new ConstructorSig(descriptor.Name, tupledArg_4[1]);
+        return ofArray([[caseName_2, info], [concat(descriptor.Name, ".", caseName_2), info]]);
+    }, toList(descriptor.Cases)), registration.Unions), list_11)), {
         Compare: (x_3, y_3) => (comparePrimitives(x_3, y_3) | 0),
     });
-    const constructorSchemes = map_1((tupledArg_4) => {
+    const constructorSchemes = map_1((tupledArg_5) => {
         let matchValue_1;
-        const sigInfo_1 = tupledArg_4[1];
+        const sigInfo_1 = tupledArg_5[1];
         const unionType = new Type(/* TNamed */ 12, [sigInfo_1.UnionName]);
-        return [tupledArg_4[0], new Scheme(empty_2(), (matchValue_1 = sigInfo_1.Payload, (matchValue_1 != null) ? (new Type(/* TFun */ 11, [matchValue_1, unionType])) : unionType))];
+        return [tupledArg_5[0], new Scheme(empty_2(), (matchValue_1 = sigInfo_1.Payload, (matchValue_1 != null) ? (new Type(/* TFun */ 11, [matchValue_1, unionType])) : unionType))];
     }, toList(constructors));
-    let env = fold((acc_1, tupledArg_5) => FSharpMap__Add(acc_1, tupledArg_5[0], tupledArg_5[1]), envFromExterns(registration.Functions), constructorSchemes);
+    let env = fold((acc_1, tupledArg_6) => FSharpMap__Add(acc_1, tupledArg_6[0], tupledArg_6[1]), envFromExterns(registration.Functions), constructorSchemes);
     const telemetry = captureLocalVariables ? createTelemetry() : undefined;
     const typed = [];
     try {
@@ -3397,15 +3426,15 @@ function inferProgramWithExternsRawAndLocals(captureLocalVariables, registration
                             const t_4 = telemetry;
                             startIndex_2 = t_4.LocalVariableTypes.length;
                         }
-                        const foldedBindings = map_1((tupledArg_6) => {
-                            const args_1 = tupledArg_6[1];
-                            const bindingSpan = tupledArg_6[4];
+                        const foldedBindings = map_1((tupledArg_7) => {
+                            const args_1 = tupledArg_7[1];
+                            const bindingSpan = tupledArg_7[4];
                             if (isEmpty_1(args_1)) {
                                 throw new TypeException(new TypeError$("\'let rec ... and ...\' requires function arguments for each binding", bindingSpan));
                             }
-                            return [tupledArg_6[0], tupledArg_6[2], foldBack((arg_1, acc_3) => (new Expr(/* ELambda */ 4, [arg_1, acc_3, bindingSpan])), args_1, tupledArg_6[3]), bindingSpan];
+                            return [tupledArg_7[0], tupledArg_7[2], foldBack((arg_1, acc_3) => (new Expr(/* ELambda */ 4, [arg_1, acc_3, bindingSpan])), args_1, tupledArg_7[3]), bindingSpan];
                         }, stmt.fields[0]);
-                        const freshByName = ofList(map_1((tupledArg_7) => [tupledArg_7[0], Types_freshVar()], foldedBindings), {
+                        const freshByName = ofList(map_1((tupledArg_8) => [tupledArg_8[0], Types_freshVar()], foldedBindings), {
                             Compare: (x_4, y_4) => (comparePrimitives(x_4, y_4) | 0),
                         });
                         const envRec_1 = fold_1((acc_4, name_7, tv_1) => add(name_7, new Scheme(empty_2(), tv_1), acc_4), env, freshByName);
@@ -3443,17 +3472,17 @@ function inferProgramWithExternsRawAndLocals(captureLocalVariables, registration
                         }
                         applySubstToCapturedLocals(telemetry, startIndex_2, sRec);
                         const envGeneralize = applyEnv(sRec, env);
-                        const schemes = map_1((tupledArg_8) => {
-                            const name_10 = tupledArg_8[0];
+                        const schemes = map_1((tupledArg_9) => {
+                            const name_10 = tupledArg_9[0];
                             const inferred_2 = applyType(sRec, FSharpMap__get_Item(freshByName, name_10));
                             validateMapKeyTypes(typeDefs_1, span_3, inferred_2);
                             return [name_10, Types_generalize(envGeneralize, inferred_2)];
                         }, foldedBindings);
-                        const typedBindings_1 = map_1((tupledArg_9) => {
-                            const name_11 = tupledArg_9[0];
-                            return [name_11, tupledArg_9[2], applyType(sRec, FSharpMap__get_Item(freshByName, name_11)), tupledArg_9[3]];
+                        const typedBindings_1 = map_1((tupledArg_10) => {
+                            const name_11 = tupledArg_10[0];
+                            return [name_11, tupledArg_10[2], applyType(sRec, FSharpMap__get_Item(freshByName, name_11)), tupledArg_10[3]];
                         }, foldedBindings);
-                        env = fold((acc_5, tupledArg_10) => add(tupledArg_10[0], tupledArg_10[1], acc_5), envGeneralize, schemes);
+                        env = fold((acc_5, tupledArg_11) => add(tupledArg_11[0], tupledArg_11[1], acc_5), envGeneralize, schemes);
                         void (typed.push(new TypedStmt(/* TSLetRecGroup */ 3, [typedBindings_1, stmt.fields[1], span_3])));
                         break;
                     }

package/dist/FScript.Language/Types.js

@@ -42,6 +42,21 @@ export function HostTypeDescriptor_$reflection() {
     return record_type("FScript.Language.HostTypeDescriptor", [], HostTypeDescriptor, () => [["Name", string_type], ["Fields", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, Type_$reflection()])], ["HostManaged", bool_type]]);
 }
 
+/**
+ * Script-constructible union supplied by a host; payloads use ordinary script types.
+ */
+export class HostUnionDescriptor extends Record {
+    constructor(Name, Cases) {
+        super();
+        this.Name = Name;
+        this.Cases = Cases;
+    }
+}
+
+export function HostUnionDescriptor_$reflection() {
+    return record_type("FScript.Language.HostUnionDescriptor", [], HostUnionDescriptor, () => [["Name", string_type], ["Cases", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, option_type(Type_$reflection())])]]);
+}
+
 export class Scheme extends Union {
     constructor(Item1, Item2) {
         super();

package/dist/FScript.Language/Value.js

@@ -1,7 +1,7 @@
 
 import { Record, FSharpRef, Union } from "../fable_modules/fable-library-js.5.13.0/Types.js";
 import { int32_type, unit_type, lambda_type, obj_type, record_type, option_type, class_type, list_type, float64_type, union_type, bool_type, int64_type, string_type } from "../fable_modules/fable-library-js.5.13.0/Reflection.js";
-import { Scheme_$reflection, HostTypeDescriptor_$reflection, Type_$reflection } from "./Types.js";
+import { HostUnionDescriptor_$reflection, Scheme_$reflection, HostTypeDescriptor_$reflection, Type_$reflection } from "./Types.js";
 import { Expr_$reflection } from "./Ast.js";
 import { EvalError$_$reflection } from "./Error.js";
 
@@ -104,14 +104,15 @@ export function ExternalFunction_$reflection() {
 }
 
 export class ExtensionRegistration extends Record {
-    constructor(Types, Functions) {
+    constructor(Types, Unions, Functions) {
         super();
         this.Types = Types;
+        this.Unions = Unions;
         this.Functions = Functions;
     }
 }
 
 export function ExtensionRegistration_$reflection() {
-    return record_type("FScript.Language.ExtensionRegistration", [], ExtensionRegistration, () => [["Types", list_type(HostTypeDescriptor_$reflection())], ["Functions", list_type(ExternalFunction_$reflection())]]);
+    return record_type("FScript.Language.ExtensionRegistration", [], ExtensionRegistration, () => [["Types", list_type(HostTypeDescriptor_$reflection())], ["Unions", list_type(HostUnionDescriptor_$reflection())], ["Functions", list_type(ExternalFunction_$reflection())]]);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magnusopera/fscript",
-  "version": "0.81.4",
+  "version": "0.81.6",
   "description": "Embeddable FScript language engine: parser, type inference, and evaluator.",
   "type": "module",
   "main": "./dist/Library.js",