@elaraai/east 0.0.1-beta.0

package/dist/src/types.js

@@ -0,0 +1,1631 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { isRef } from "./containers/ref.js";
+import { SortedMap } from "./containers/sortedmap.js";
+import { SortedSet } from "./containers/sortedset.js";
+import { variant_symbol } from "./containers/variant.js";
+/**
+ * Error thrown when type operations encounter incompatible types.
+ *
+ * @remarks
+ * Used by type union, intersection, and equality operations when types
+ * cannot be combined or compared as requested.
+ */
+class TypeMismatchError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "TypeMismatchError";
+    }
+}
+/** Singleton instance of the Never type. */
+export const NeverType = { type: "Never" };
+/** Singleton instance of the Null type. */
+export const NullType = { type: "Null" };
+/** Singleton instance of the Boolean type. */
+export const BooleanType = { type: "Boolean" };
+/** Singleton instance of the Integer type. */
+export const IntegerType = { type: "Integer" };
+/** Singleton instance of the Float type. */
+export const FloatType = { type: "Float" };
+/** Singleton instance of the String type. */
+export const StringType = { type: "String" };
+/** Singleton instance of the DateTime type. */
+export const DateTimeType = { type: "DateTime" };
+/** Singleton instance of the Blob type. */
+export const BlobType = { type: "Blob" };
+/**
+ * Constructs a reference (or cell) type with the specified element type.
+ *
+ * Conceptually, a reference is a box or cell that can hold a value of a specified type.
+ * The reference can be mutated by updating the contents of the reference.
+ * Multiple references can point to the same underlying value.
+ *
+ * @typeParam T - The type of value held by the reference
+ * @param type - The element type
+ * @returns A reference type
+ * @throws When the element type contains functions
+ */
+export function RefType(type) {
+    if (typeof type !== "string" && !isDataType(type)) {
+        throw new Error(`Ref value type must be a (non-function) data type, got ${printType(type)}`);
+    }
+    return { type: "Ref", value: type };
+}
+;
+/**
+ * Constructs an Array type with the specified element type.
+ *
+ * @typeParam T - The type of elements in the array
+ * @param type - The element type
+ * @returns An Array type
+ * @throws When the element type contains functions
+ */
+export function ArrayType(type) {
+    if (typeof type !== "string" && !isDataType(type)) {
+        throw new Error(`Array value type must be a (non-function) data type, got ${printType(type)}`);
+    }
+    return { type: "Array", value: type };
+}
+;
+/**
+ * Constructs a Set type with the specified key type.
+ *
+ * @typeParam T - The type of keys in the set
+ * @param type - The key type
+ * @returns A Set type
+ * @throws When the key type is not immutable
+ */
+export function SetType(type) {
+    if (typeof type !== "string" && !isImmutableType(type)) {
+        throw new Error(`Set key type must be an immutable type, got ${printType(type)}`);
+    }
+    return { type: "Set", key: type };
+}
+;
+/**
+ * Constructs a Dict type with the specified key and value types.
+ *
+ * @typeParam K - The type of keys in the dictionary
+ * @typeParam T - The type of values in the dictionary
+ * @param key - The key type
+ * @param value - The value type
+ * @returns A Dict type
+ * @throws When the key type is not immutable or value type contains functions
+ */
+export function DictType(key, value) {
+    if (typeof key !== "string" && !isImmutableType(key)) {
+        throw new Error(`Dict key type must be an immutable type, got ${printType(key)}`);
+    }
+    if (typeof value !== "string" && !isDataType(value)) {
+        throw new Error(`Dict value type must be a (non-function) data type, got ${printType(value)}`);
+    }
+    return { type: "Dict", key, value };
+}
+;
+/**
+ * Constructs a Struct type with the specified field types.
+ *
+ * @typeParam Fields - Object type mapping field names to their types
+ * @param field_types - Object mapping field names to {@link EastType} instances
+ * @returns A Struct type
+ */
+export function StructType(field_types) {
+    // Validate all field types are data types (no functions)
+    for (const [field_name, field_type] of Object.entries(field_types)) {
+        if (typeof field_type !== "string" && !isDataType(field_type)) {
+            throw new Error(`Struct field ${field_name} must be a (non-function) data type, got ${printType(field_type)}`);
+        }
+    }
+    return { type: "Struct", fields: field_types };
+}
+;
+/**
+ * Constructs a Variant type with the specified cases.
+ *
+ * @typeParam Cases - Object type mapping case names to their value types
+ * @param case_types - Object mapping case names to {@link EastType} instances
+ * @returns A Variant type with cases sorted alphabetically
+ */
+export function VariantType(case_types) {
+    // Validate all case types are data types (no functions)
+    for (const [case_name, case_type] of Object.entries(case_types)) {
+        if (typeof case_type !== "string" && !isDataType(case_type)) {
+            throw new Error(`Variant case ${case_name} must be a (non-function) data type, got ${printType(case_type)}`);
+        }
+    }
+    // Cases are sorted alphabetically by their name
+    const cases_sorted = Object.fromEntries(Object.entries(case_types).sort((x, y) => x[0] < y[0] ? -1 : x[0] === y[0] ? 0 : 1));
+    return { type: "Variant", cases: cases_sorted };
+}
+;
+/**
+ * Validates that a recursive type has SCC (Strongly Connected Component) size 1.
+ *
+ * @param type - The type to validate
+ * @param allowedMarker - The recursive marker that is allowed (the one being defined)
+ * @throws When nested RecursiveTypes with cross-references are detected
+ *
+ * @remarks
+ * This ensures that recursive types don't have mutual recursion or nested
+ * RecursiveTypes that reference outer scopes. Only simple recursion (SCC size 1)
+ * is supported for predictable behavior and implementation simplicity.
+ */
+function validateNotMutuallyRecursive(type, allowedMarker) {
+    const visited = new Set();
+    function check(t) {
+        // Skip string placeholders (used for generic builtins)
+        if (typeof t === "string")
+            return;
+        if (typeof t !== "object" || t === null) {
+            let allowedMarkerString = null;
+            try {
+                allowedMarkerString = printType(allowedMarker);
+            }
+            catch { }
+            throw new Error(`Invalid type encountered during recursion validation: ${t}${allowedMarkerString === null ? "" : ` (allowed marker: ${allowedMarkerString})`}`);
+        }
+        // Skip allowedMarker
+        if (t === allowedMarker)
+            return;
+        // Avoid infinite loops
+        if (visited.has(t))
+            return;
+        visited.add(t);
+        if (t.type === "Recursive") {
+            if (t.node === undefined) {
+                throw new Error("RecursiveType must have SCC size 1: nested RecursiveTypes with cross-references are not supported. " +
+                    "Each RecursiveType can only reference itself, not other recursive scopes.");
+            }
+            else {
+                // Recurse into the recursive type's body, with t as the new root
+                validateNotMutuallyRecursive(t.node, t);
+            }
+        }
+        else if (t.type === "Struct") {
+            for (const [_, field_type] of Object.entries(t.fields)) {
+                check(field_type);
+            }
+        }
+        else if (t.type === "Variant") {
+            for (const [_, case_type] of Object.entries(t.cases)) {
+                check(case_type);
+            }
+        }
+        else if (t.type === "Array") {
+            check(t.value);
+        }
+        else if (t.type === "Set") {
+            check(t.key);
+        }
+        else if (t.type === "Dict") {
+            check(t.key);
+            check(t.value);
+        }
+        else if (t.type === "Function") {
+            t.inputs.forEach(check);
+            check(t.output);
+        }
+        // Primitive types don't need recursion
+    }
+    check(type);
+}
+/**
+ * Constructs a recursive type with the specified node structure.
+ *
+ * @typeParam F - Function type that defines the recursive structure
+ * @param f - Function that receives a self-reference marker and returns the node type
+ * @returns A RecursiveType representing the recursive structure
+ * @throws When the type contains functions or has SCC size > 1 (mutual recursion)
+ *
+ * @remarks
+ * The function `f` receives a `RecursiveTypeMarker` representing the recursive
+ * reference point. This marker should be used wherever the type recursively refers to itself.
+ *
+ * Only simple recursion is supported - the type can reference itself multiple times, but
+ * nested RecursiveTypes with cross-references (mutual recursion) are not allowed.
+ *
+ * @example
+ * ```ts
+ * // Linked list
+ * const ListType = RecursiveType(self =>
+ *   VariantType({
+ *     nil: NullType,
+ *     cons: StructType({ head: IntegerType, tail: self })
+ *   })
+ * );
+ *
+ * // Binary tree
+ * const TreeType = RecursiveType(self =>
+ *   StructType({
+ *     value: IntegerType,
+ *     left: OptionType(self),
+ *     right: OptionType(self)
+ *   })
+ * );
+ * ```
+ */
+export function RecursiveType(f) {
+    const ret = { type: "Recursive", node: undefined };
+    const type = f(ret);
+    ret.node = type;
+    // Validate SCC size 1 (no nested RecursiveTypes with cross-references)
+    validateNotMutuallyRecursive(type, ret);
+    if (typeof type !== "string" && !isDataType(type)) {
+        throw new Error(`Recursive node type must be a (non-function) data type, got ${printType(type)}`);
+    }
+    return ret;
+}
+;
+/**
+ * Constructs a Function type with the specified input and output types.
+ *
+ * @typeParam I - Tuple type of input parameter types
+ * @typeParam O - The output/return type
+ * @param inputs - Array of {@link EastType} instances for each parameter
+ * @param output - The {@link EastType} of the return value
+ * @returns A Function type
+ */
+export function FunctionType(inputs, output, platforms) {
+    // TODO - for the moment we default function types to being pure, meaning users may need to annotate their higher-order functions.
+    // In future we may want to track side-effects more precisely.
+    return { type: "Function", inputs, output, platforms };
+}
+;
+/**
+ * Checks if a type is a pure data type (excludes functions).
+ *
+ * @param type - The {@link EastType} to check
+ * @param recursive_type - Internal parameter for tracking the current recursive type being checked
+ * @returns `true` if the type is a pure data type, `false` if it contains functions
+ *
+ * @remarks
+ * Data types can be fully serialized and transmitted between runtimes.
+ * This recursively checks {@link StructType}, {@link VariantType}, and {@link RecursiveType} fields.
+ */
+export function isDataType(type, recursive_type) {
+    // Avoid infinite loops
+    if (type === recursive_type) {
+        return true;
+    }
+    if (type.type === "Ref") {
+        // Ref constructors check their value type are data types
+        return true;
+    }
+    else if (type.type === "Array") {
+        // Array constructors check their value type are data types
+        return true;
+    }
+    else if (type.type === "Set") {
+        // Set constructors check their value type are (immutable) data types
+        return true;
+    }
+    else if (type.type === "Dict") {
+        // Dict constructors check their key and value types are data types
+        return true;
+    }
+    else if (type.type === "Struct") {
+        for (const field_type of Object.values(type.fields)) {
+            if (!isDataType(field_type, recursive_type)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else if (type.type === "Variant") {
+        for (const variant of Object.values(type.cases)) {
+            if (!isDataType(variant, recursive_type)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else if (type.type === "Recursive") {
+        return type.node === recursive_type ? true : isDataType(type.node, type);
+    }
+    else if (type.type === "Function") {
+        return false;
+    }
+    else {
+        // Primitive types are data types
+        return true;
+    }
+}
+/**
+ * Checks if a type is immutable (can be used as dict keys or set elements).
+ *
+ * @param type - The {@link EastType} to check
+ * @param recursive_type - Internal parameter for tracking the current recursive type being checked
+ * @returns `true` if the type is immutable, `false` if it contains mutable collections or functions
+ *
+ * @remarks
+ * Immutable types exclude {@link ArrayType}, {@link SetType}, {@link DictType}, and {@link FunctionType}.
+ * This recursively checks {@link StructType}, {@link VariantType}, and {@link RecursiveType} fields.
+ */
+export function isImmutableType(type, recursive_type) {
+    // Avoid infinite loops
+    if (type === recursive_type) {
+        return true;
+    }
+    if (type.type === "Ref") {
+        // Refs are mutable
+        return false;
+    }
+    else if (type.type === "Array") {
+        // Arrays are mutable
+        return false;
+    }
+    else if (type.type === "Set") {
+        // Set are mutable
+        return false;
+    }
+    else if (type.type === "Dict") {
+        // Dict are mutable
+        return false;
+    }
+    else if (type.type === "Struct") {
+        for (const field_type of Object.values(type.fields)) {
+            if (!isImmutableType(field_type, recursive_type)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else if (type.type === "Variant") {
+        for (const variant of Object.values(type.cases)) {
+            if (!isImmutableType(variant, recursive_type)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else if (type.type === "Recursive") {
+        return type.node === recursive_type ? true : isImmutableType(type.node, type);
+    }
+    else if (type.type === "Function") {
+        // Functions are not data types, and "immutable data" is a subset of "data"
+        return false;
+    }
+    else {
+        // Primitive types are immutable
+        return true;
+    }
+}
+/**
+ * Infers the East type from a runtime JavaScript value.
+ *
+ * @typeParam V - The TypeScript type of the value
+ * @param value - The JavaScript value to analyze
+ * @returns The corresponding {@link EastType}
+ * @throws When the value is a JavaScript function or cannot be typed
+ *
+ * @remarks
+ * This is the runtime version of the {@link EastTypeOf} type.
+ * For arrays, it infers the element type from the first element.
+ */
+export function EastTypeOf(value) {
+    if (value === null) {
+        return NullType;
+    }
+    else if (typeof value === "boolean") {
+        return BooleanType;
+    }
+    else if (typeof value === "bigint") {
+        return IntegerType;
+    }
+    else if (typeof value === "number") {
+        return FloatType;
+    }
+    else if (typeof value === "string") {
+        return StringType;
+    }
+    if (value instanceof Date) {
+        return DateTimeType;
+    }
+    else if (value instanceof Uint8Array) {
+        return BlobType;
+    }
+    else if (Array.isArray(value)) {
+        if (value.length === 0) {
+            throw new Error(`Cannot infer East type of empty array`);
+        }
+        return ArrayType(EastTypeOf(value[0]));
+    }
+    else if (value instanceof Set || value instanceof SortedSet) {
+        if (value.size === 0) {
+            throw new Error(`Cannot infer East type of empty set`);
+        }
+        const first = value.values().next().value;
+        return SetType(EastTypeOf(first));
+    }
+    else if (value instanceof Map || value instanceof SortedMap) {
+        if (value.size === 0) {
+            throw new Error(`Cannot infer East type of empty map`);
+        }
+        const first = value.entries().next().value;
+        return DictType(EastTypeOf(first[0]), EastTypeOf(first[1]));
+    }
+    else if (typeof value === "function") {
+        throw new Error(`Javascript functions cannot be converted to East functions`);
+    }
+    else if (typeof value === "object") {
+        return StructType(Object.fromEntries(Object.entries(value).map(([k, v]) => [k, EastTypeOf(v)])));
+    }
+    else {
+        throw new Error(`Cannot determine East type for value ${value}`);
+    }
+}
+/**
+ * Checks if two East types are structurally equal.
+ *
+ * @param t1 - First {@link EastType} to compare
+ * @param t2 - Second {@link EastType} to compare
+ * @param r1 - Internal parameter for tracking the first recursive type being compared
+ * @param r2 - Internal parameter for tracking the second recursive type being compared
+ * @returns `true` if the types are equal, `false` otherwise
+ *
+ * @remarks
+ * Performs structural equality checking, recursively comparing compound types.
+ * For {@link StructType} and {@link VariantType}, field/case order matters.
+ * For {@link RecursiveType}, uses cycle tracking to handle recursive references.
+ */
+export function isTypeEqual(t1, t2, r1 = t1, r2 = t2) {
+    if (t1.type === "Recursive") {
+        if (t2.type === "Recursive") {
+            if (t1.node === r1) {
+                return t2.node === r2;
+            }
+            else if (t2.node === r2) {
+                return false;
+            }
+            else {
+                return isTypeEqual(t1.node, t2.node, t1.node, t2.node);
+            }
+        }
+        else {
+            // The RecursiveType wrapper is transparent
+            return isTypeEqual(t1.node, t2, t1.node, r2);
+        }
+    }
+    else if (t2.type === "Recursive") {
+        // The RecursiveType wrapper is transparent
+        return isTypeEqual(t1, t2.node, r1, t2.node);
+    }
+    else if (t1.type === "Never") {
+        return t2.type === "Never";
+    }
+    else if (t1.type === "Null") {
+        return t2.type === "Null";
+    }
+    else if (t1.type === "Boolean") {
+        return t2.type === "Boolean";
+    }
+    else if (t1.type === "Integer") {
+        return t2.type === "Integer";
+    }
+    else if (t1.type === "Float") {
+        return t2.type === "Float";
+    }
+    else if (t1.type === "String") {
+        return t2.type === "String";
+    }
+    else if (t1.type === "DateTime") {
+        return t2.type === "DateTime";
+    }
+    else if (t1.type === "Blob") {
+        return t2.type === "Blob";
+    }
+    else if (t1.type === "Ref") {
+        if (t2.type === "Ref") {
+            return isTypeEqual(t1.value, t2.value, r1, r2);
+        }
+        else {
+            return false;
+        }
+    }
+    else if (t1.type === "Array") {
+        if (t2.type === "Array") {
+            return isTypeEqual(t1.value, t2.value, r1, r2);
+        }
+        else {
+            return false;
+        }
+    }
+    else if (t1.type === "Set") {
+        if (t2.type === "Set") {
+            return isTypeEqual(t1.key, t2.key, r1, r2);
+        }
+        else {
+            return false;
+        }
+    }
+    else if (t1.type === "Dict") {
+        if (t2.type === "Dict") {
+            return isTypeEqual(t1.key, t2.key, r1, r2) && isTypeEqual(t1.value, t2.value, r1, r2);
+        }
+        else {
+            return false;
+        }
+    }
+    else if (t1.type === "Struct") {
+        if (t2.type === "Struct") {
+            const e1 = Object.entries(t1.fields);
+            const e2 = Object.entries(t2.fields);
+            if (e1.length !== e2.length)
+                return false;
+            let i = 0;
+            for (const [k1, f1] of e1) {
+                const [k2, f2] = e2[i];
+                if (k1 !== k2)
+                    return false;
+                if (!isTypeEqual(f1, f2, r1, r2))
+                    return false;
+                i += 1;
+            }
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    else if (t1.type === "Variant") {
+        if (t2.type === "Variant") {
+            const e1 = Object.entries(t1.cases);
+            const e2 = Object.entries(t2.cases);
+            if (e1.length !== e2.length)
+                return false;
+            let i = 0;
+            for (const [k1, f1] of e1) {
+                const [k2, f2] = e2[i];
+                if (k1 !== k2)
+                    return false;
+                if (!isTypeEqual(f1, f2, r1, r2))
+                    return false;
+                i += 1;
+            }
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    else if (t1.type === "Function") {
+        if (t2.type !== "Function") {
+            return false;
+        }
+        // Check input types match
+        if (t1.inputs.length !== t2.inputs.length) {
+            return false;
+        }
+        for (let i = 0; i < t1.inputs.length; i++) {
+            if (!isTypeEqual(t1.inputs[i], t2.inputs[i], r1, r2)) {
+                return false;
+            }
+        }
+        // Check output type matches
+        if (!isTypeEqual(t1.output, t2.output, r1, r2)) {
+            return false;
+        }
+        // Check platform requirements match
+        if (t1.platforms === null && t2.platforms === null) {
+            return true;
+        }
+        if (t1.platforms === null || t2.platforms === null) {
+            return false;
+        }
+        if (t1.platforms.length !== t2.platforms.length) {
+            return false;
+        }
+        for (let i = 0; i < t1.platforms.length; i++) {
+            if (t1.platforms[i] !== t2.platforms[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else {
+        throw new Error(`Unknown type encountered during type equality check: ${t1.type}`);
+    }
+}
+/**
+ * Checks if a JavaScript value conforms to an East type.
+ *
+ * @param value - The JavaScript value to check
+ * @param type - The {@link EastType} to validate against
+ * @param node_type - Internal parameter for tracking the current recursive type node
+ * @param nodes_visited - Internal parameter for tracking visited nodes to detect cycles
+ * @returns `true` if the value matches the type, `false` otherwise
+ *
+ * @remarks
+ * Performs runtime type checking, recursively validating compound types.
+ * Accepts both native JavaScript `Set`/`Map` and {@link SortedSet}/{@link SortedMap}.
+ * For {@link RecursiveType}, uses cycle detection to handle recursive values.
+ */
+export function isValueOf(value, type, node_type, nodes_visited) {
+    if (type.type === "Never") {
+        return false;
+    }
+    else if (type.type === "Null") {
+        return value === null;
+    }
+    else if (type.type === "Boolean") {
+        return typeof value === "boolean";
+    }
+    else if (type.type === "Integer") {
+        return typeof value === "bigint";
+    }
+    else if (type.type === "Float") {
+        return typeof value === "number";
+    }
+    else if (type.type === "String") {
+        return typeof value === "string";
+    }
+    else if (type.type === "DateTime") {
+        return value instanceof Date;
+    }
+    else if (type.type === "Blob") {
+        return value instanceof Uint8Array;
+    }
+    else if (type.type === "Ref") {
+        if (!isRef(value)) {
+            return false;
+        }
+        return isValueOf(value.value, type.value, node_type, nodes_visited);
+    }
+    else if (type.type === "Array") {
+        if (!Array.isArray(value)) {
+            return false;
+        }
+        for (const x of value) {
+            if (!isValueOf(x, type.value, node_type, nodes_visited)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else if (type.type === "Set") {
+        if (!(value instanceof Set || value instanceof SortedSet)) {
+            return false;
+        }
+        for (const x of value) {
+            if (!isValueOf(x, type.key, node_type, nodes_visited)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else if (type.type === "Dict") {
+        if (!(value instanceof Map || value instanceof SortedMap)) {
+            return false;
+        }
+        for (const [k, v] of value) {
+            if (!isValueOf(k, type.key, node_type, nodes_visited) || !isValueOf(v, type.value, node_type, nodes_visited)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else if (type.type === "Struct") {
+        if (typeof value !== "object" || value === null || Object.getPrototypeOf(value) !== Object.getPrototypeOf({}))
+            return false;
+        const vs = Object.entries(value);
+        const ts = Object.entries(type.fields);
+        if (vs.length !== ts.length)
+            return false;
+        let i = 0;
+        for (const [k1, ft] of ts) {
+            const [k2, fv] = vs[i];
+            if (k1 !== k2)
+                return false;
+            if (!isValueOf(fv, ft, node_type, nodes_visited))
+                return false;
+            i += 1;
+        }
+        return true;
+    }
+    else if (type.type === "Variant") {
+        if (typeof value !== "object" || value === null || value[variant_symbol] !== null)
+            return false;
+        const t = type.cases[value.type];
+        if (t === undefined) {
+            return false;
+        }
+        ;
+        return isValueOf(value.value, t, node_type, nodes_visited);
+    }
+    else if (type.type === "Recursive") {
+        if (node_type === type.node) {
+            if (nodes_visited.has(value)) {
+                return true; // already seen this object
+            }
+            nodes_visited.add(value);
+            return isValueOf(value, type.node, type.node, nodes_visited);
+        }
+        else {
+            // new recursive type, reset stack
+            return isValueOf(value, type.node, type.node, new Set([value]));
+        }
+    }
+    else if (type.type === "Function") {
+        throw new Error('Javascript functions cannot be converted to East functions');
+    }
+    else {
+        throw new Error(`Unknown type encountered during value type check: ${type.type}`);
+    }
+}
+/**
+ * Converts an East type to its string representation.
+ *
+ * @param type - The {@link EastType} to print
+ * @param stack - Internal parameter for tracking recursive types
+ * @returns A human-readable string representation of the type
+ *
+ * @remarks
+ * Uses East's value syntax with leading dots (e.g., `.Integer`, `.Array .String`).
+ */
+export function printType(type, stack = []) {
+    // Note this is essentially a bootstrap function.
+    // It should print the same output as printing an `EastType` as an `EastTypeType`, but
+    // printing values hasn't been defined by this stage and printType is crucial for
+    // internal debugging and `Expr` error messages.
+    // We do skip mutable aliasing of struct field or variant case lists for clarity.
+    // Types are intended to be immutable in any case.
+    if (type.type === "Never") {
+        return ".Never";
+    }
+    else if (type.type === "Null") {
+        return ".Null";
+    }
+    else if (type.type === "Boolean") {
+        return ".Boolean";
+    }
+    else if (type.type === "Integer") {
+        return ".Integer";
+    }
+    else if (type.type === "Float") {
+        return ".Float";
+    }
+    else if (type.type === "String") {
+        return ".String";
+    }
+    else if (type.type === "DateTime") {
+        return ".DateTime";
+    }
+    else if (type.type === "Blob") {
+        return ".Blob";
+    }
+    else if (type.type === "Ref") {
+        stack.push(type);
+        const ret = `.Ref ${printType(type.value, stack)}`;
+        stack.pop();
+        return ret;
+    }
+    else if (type.type === "Array") {
+        stack.push(type);
+        const ret = `.Array ${printType(type.value, stack)}`;
+        stack.pop();
+        return ret;
+    }
+    else if (type.type === "Set") {
+        stack.push(type);
+        const ret = `.Set ${printType(type.key, stack)}`;
+        stack.pop();
+        return ret;
+    }
+    else if (type.type === "Dict") {
+        stack.push(type);
+        const ret = `.Dict (key=${printType(type.key, stack)}, value=${printType(type.value, stack)})`;
+        stack.pop();
+        return ret;
+    }
+    else if (type.type === "Struct") {
+        stack.push(type);
+        const ret = `.Struct [${Object.entries(type.fields).map(([k, t]) => `(name=${JSON.stringify(k)}, type=${printType(t, stack)})`).join(", ")}]`;
+        stack.pop();
+        return ret;
+    }
+    else if (type.type === "Variant") {
+        stack.push(type);
+        const ret = `.Variant [${Object.entries(type.cases).map(([k, t]) => `(name=${JSON.stringify(k)}, type=${printType(t, stack)})`).join(", ")}]`;
+        stack.pop();
+        return ret;
+    }
+    else if (type.type === "Recursive") {
+        // TODO update for our new recursive type representation
+        const idx = stack.indexOf(type.node);
+        if (idx !== -1) {
+            // Recursive reference
+            return `.Recursive ${stack.length - idx}`;
+        }
+        return printType(type.node, stack);
+    }
+    else if (type.type === "Function") {
+        // Note: functions can't be inside recursive types
+        stack.push(type);
+        const ret = `.Function (inputs=[${type.inputs.map(t => printType(t, stack)).join(", ")}], output=${printType(type.output, stack)}, platforms=${type.platforms === null ? "null" : `[${type.platforms.map(p => JSON.stringify(p)).join(", ")}]`})`;
+        stack.pop();
+        return ret;
+    }
+    else {
+        throw new Error(`Unknown type encountered during type printing: ${type.type}`);
+    }
+}
+/**
+ * Checks if one East type is a subtype of another.
+ *
+ * @param t1 - The potential subtype
+ * @param t2 - The potential supertype
+ * @returns `true` if t1 is a subtype of t2, `false` otherwise
+ *
+ * @remarks
+ * Implements East's subtyping rules:
+ * - {@link NeverType} is a subtype of all types
+ * - Mutable collections ({@link ArrayType}, {@link SetType}, {@link DictType}) are invariant
+ * - {@link VariantType} supports width subtyping (more cases → fewer cases)
+ * - {@link FunctionType} uses contravariant inputs and covariant outputs
+ */
+export function isSubtype(t1, t2) {
+    // Equi-recursive type subtyping: unfold recursive types when only one side is recursive
+    if (t1.type === "Recursive") {
+        if (t2.type === "Recursive") {
+            // Recursive types are invariant - we want any compatible heap-allocated objects to have exactly the same layout
+            return isTypeEqual(t1.node, t2.node);
+        }
+        else {
+            // The recursive type wrapper is "transparent", but invariant
+            return isTypeEqual(t1.node, t2);
+        }
+    }
+    else if (t2.type === "Recursive") {
+        // The recursive type wrapper is "transparent"
+        // If the head is "on the stack" we can do head covariance by unfolding once
+        return isSubtype(t1, t2.node);
+    }
+    else if (t1.type === "Never") {
+        // t2 must be a supertype of Never
+        return true;
+    }
+    else if (t1.type === "Null") {
+        return t2.type === "Null";
+    }
+    else if (t1.type === "Boolean") {
+        return t2.type === "Boolean";
+    }
+    else if (t1.type === "Integer") {
+        return t2.type === "Integer";
+    }
+    else if (t1.type === "Float") {
+        return t2.type === "Float";
+    }
+    else if (t1.type === "String") {
+        return t2.type === "String";
+    }
+    else if (t1.type === "DateTime") {
+        return t2.type === "DateTime";
+    }
+    else if (t1.type === "Blob") {
+        return t2.type === "Blob";
+    }
+    else if (t1.type === "Ref") {
+        if (t2.type === "Ref") {
+            return isTypeEqual(t1.value, t2.value);
+        }
+        else {
+            return false;
+        }
+    }
+    else if (t1.type === "Array") {
+        if (t2.type === "Array") {
+            return isTypeEqual(t1.value, t2.value);
+        }
+        else {
+            return false;
+        }
+    }
+    else if (t1.type === "Set") {
+        if (t2.type === "Set") {
+            return isTypeEqual(t1.key, t2.key);
+        }
+        else {
+            return false;
+        }
+    }
+    else if (t1.type === "Dict") {
+        if (t2.type === "Dict") {
+            return isTypeEqual(t1.key, t2.key) && isTypeEqual(t1.value, t2.value);
+        }
+        else {
+            return false;
+        }
+    }
+    else if (t1.type === "Struct") {
+        if (t2.type === "Struct") {
+            const e1 = Object.entries(t1.fields);
+            const e2 = Object.entries(t2.fields);
+            if (e1.length !== e2.length)
+                return false;
+            let i = 0;
+            for (const [k1, f1] of e1) {
+                const [k2, f2] = e2[i];
+                if (k1 !== k2)
+                    return false;
+                if (!isSubtype(f1, f2))
+                    return false;
+                i += 1;
+            }
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    else if (t1.type === "Variant") {
+        if (t2.type === "Variant") {
+            // Unlike structs, we don't care about the order (they are sorted by name already) and we only need a subset of cases in t2
+            for (const [k, v1] of Object.entries(t1.cases)) {
+                const v2 = t2.cases[k] ?? NeverType;
+                if (!isSubtype(v1, v2))
+                    return false;
+            }
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    else if (t1.type === "Function") {
+        if (t2.type === "Function") {
+            return t1.inputs.length === t2.inputs.length && t1.inputs.every((t, i) => isSubtype(t2.inputs[i], t)) && isSubtype(t1.output, t2.output); // contravariant inputs and covariant output
+        }
+        else {
+            return false;
+        }
+    }
+    else {
+        throw new Error(`Unknown type encountered during subtype check: ${t1.type}`);
+    }
+}
+/**
+ * Computes the union of two East types at runtime.
+ *
+ * @typeParam T1 - First {@link EastType}
+ * @typeParam T2 - Second {@link EastType}
+ * @param t1 - First type
+ * @param t2 - Second type
+ * @returns The union type
+ * @throws {TypeMismatchError} When the types cannot be unified
+ *
+ * @remarks
+ * This is the runtime version of the {@link TypeUnion} type.
+ * Error messages include the full type path for debugging.
+ */
+export function TypeUnion(t1, t2) {
+    // TODO this is broken for recursive types (need to do cycle tracking in tandem with TypeEqual/TypeIntersect)
+    try {
+        if (t1.type === "Never") {
+            return t2;
+        }
+        else if (t2.type === "Never") {
+            return t1;
+        }
+        else if (t1.type === "Recursive") {
+            if (t2.type === "Recursive") {
+                // Both recursive - require exact match (heap invariance)
+                return TypeEqual(t1, t2);
+                // return RecursiveType(() => TypeEqual(t1.node, t2.node, t1.node, t2.node)) as TypeUnion<T1, T2>;
+            }
+            else {
+                // Rec(A) ∪ NonRec: If NonRec <: A, union is Rec(A) (NonRec can be widened to heap type)
+                if (isSubtype(t2, t1.node)) {
+                    return t1;
+                }
+                throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t2.type === "Recursive") {
+            // NonRec ∪ Rec(B): If NonRec <: B, union is Rec(B) (symmetric case)
+            if (isSubtype(t1, t2.node)) {
+                return t2;
+            }
+            throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: incompatible types`);
+        }
+        else if (t1.type === "Ref") {
+            if (t2.type === "Ref") {
+                return RefType(TypeEqual(t1.value, t2.value));
+            }
+            else {
+                throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Array") {
+            if (t2.type === "Array") {
+                return ArrayType(TypeEqual(t1.value, t2.value));
+            }
+            else {
+                throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Set") {
+            if (t2.type === "Set") {
+                return SetType(TypeEqual(t1.key, t2.key));
+            }
+            else {
+                throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Dict") {
+            if (t2.type === "Dict") {
+                return DictType(TypeEqual(t1.key, t2.key), TypeEqual(t1.value, t2.value));
+            }
+            else {
+                throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Struct") {
+            if (t2.type === "Struct") {
+                const e1 = Object.entries(t1.fields);
+                const e2 = Object.entries(t2.fields);
+                if (e1.length !== e2.length)
+                    throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: structs contain different number of fields`);
+                let i = 0;
+                const e = {};
+                for (const [k1, f1] of e1) {
+                    const [k2, f2] = e2[i];
+                    if (k1 !== k2)
+                        throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: struct field ${i} has mismatched names ${printIdentifier(k1)} and ${printIdentifier(k2)}`);
+                    e[k1] = TypeUnion(f1, f2);
+                    i += 1;
+                }
+                return StructType(e);
+            }
+            else {
+                throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Variant") {
+            if (t2.type === "Variant") {
+                const cases = {};
+                for (const [k1, f1] of Object.entries(t1.cases)) {
+                    const f2 = t2.cases[k1];
+                    if (f2 === undefined) {
+                        cases[k1] = f1;
+                    }
+                    else {
+                        cases[k1] = TypeUnion(f1, f2);
+                    }
+                }
+                for (const [k2, f2] of Object.entries(t2.cases)) {
+                    const f1 = t1.cases[k2];
+                    if (f1 === undefined) {
+                        cases[k2] = f2;
+                    }
+                }
+                return VariantType(cases);
+            }
+            else {
+                throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Function") {
+            if (t2.type === "Function") {
+                if (t1.inputs.length !== t2.inputs.length) {
+                    throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: functions take different number of arguments`);
+                }
+                let platforms;
+                if (t1.platforms === null) {
+                    platforms = null;
+                }
+                else if (t2.platforms === null) {
+                    platforms = null;
+                }
+                else {
+                    platforms = [...new Set([...t1.platforms, ...t2.platforms])].sort();
+                }
+                return FunctionType(t1.inputs.map((t, i) => TypeIntersect(t, t2.inputs[i])), TypeUnion(t1.output, t2.output), platforms);
+            }
+            else {
+                throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else {
+            if (t1.type === t2.type) {
+                return t1;
+            }
+            else {
+                throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+    }
+    catch (cause) {
+        if (cause instanceof TypeMismatchError) {
+            throw cause; // Don't wrap our own errors - they already have the full path
+        }
+        throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}`, { cause });
+    }
+}
+/**
+ * Computes the intersection of two East types at runtime.
+ *
+ * @typeParam T1 - First {@link EastType}
+ * @typeParam T2 - Second {@link EastType}
+ * @param t1 - First type
+ * @param t2 - Second type
+ * @returns The intersection type
+ * @throws {TypeMismatchError} When the types cannot be intersected
+ *
+ * @remarks
+ * This is the runtime version of the {@link TypeIntersect} type.
+ * For {@link VariantType}, returns {@link NeverType} if no common cases exist.
+ */
+export function TypeIntersect(t1, t2) {
+    // TODO this is broken for recursive types (need to do cycle tracking in tandem with TypeEqual/TypeUnion)
+    try {
+        if (t1.type === "Never") {
+            return NeverType;
+        }
+        else if (t2.type === "Never") {
+            return NeverType;
+        }
+        else if (t1.type === "Recursive") {
+            if (t2.type === "Recursive") {
+                // Both recursive - require exact match (heap invariance)
+                return RecursiveType(() => TypeEqual(t1.node, t2.node, t1.node, t2.node));
+            }
+            else {
+                // Rec(A) ∩ NonRec: If NonRec <: A, intersection is NonRec (the more specific type)
+                if (isSubtype(t2, t1.node)) {
+                    return t2;
+                }
+                throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t2.type === "Recursive") {
+            // NonRec ∩ Rec(B): If NonRec <: B, intersection is NonRec (symmetric case)
+            if (isSubtype(t1, t2.node)) {
+                return t1;
+            }
+            throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: incompatible types`);
+        }
+        else if (t1.type === "Ref") {
+            if (t2.type === "Ref") {
+                return RefType(TypeEqual(t1.value, t2.value));
+            }
+            else {
+                throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Array") {
+            if (t2.type === "Array") {
+                return ArrayType(TypeEqual(t1.value, t2.value));
+            }
+            else {
+                throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Set") {
+            if (t2.type === "Set") {
+                return SetType(TypeEqual(t1.key, t2.key));
+            }
+            else {
+                throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Dict") {
+            if (t2.type === "Dict") {
+                return DictType(TypeEqual(t1.key, t2.key), TypeEqual(t1.value, t2.value));
+            }
+            else {
+                throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Struct") {
+            if (t2.type === "Struct") {
+                const e1 = Object.entries(t1.fields);
+                const e2 = Object.entries(t2.fields);
+                if (e1.length !== e2.length)
+                    throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: structs contain different number of fields`);
+                let i = 0;
+                const e = {};
+                for (const [k1, f1] of e1) {
+                    const [k2, f2] = e2[i];
+                    if (k1 !== k2)
+                        throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: struct field ${i} has mismatched names ${printIdentifier(k1)} and ${printIdentifier(k2)}`);
+                    e[k1] = TypeIntersect(f1, f2);
+                    i += 1;
+                }
+                return StructType(e);
+            }
+            else {
+                throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Variant") {
+            if (t2.type === "Variant") {
+                const cases = {};
+                let empty = true;
+                for (const [k1, f1] of Object.entries(t1.cases)) {
+                    const f2 = t2.cases[k1];
+                    if (f2 !== undefined) {
+                        cases[k1] = TypeIntersect(f1, f2);
+                        empty = false;
+                    }
+                }
+                if (empty) {
+                    throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: variants have no overlapping cases`);
+                }
+                return VariantType(cases);
+            }
+            else {
+                throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Function") {
+            if (t2.type === "Function") {
+                if (t1.inputs.length !== t2.inputs.length) {
+                    throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: functions take different number of arguments`);
+                }
+                let platforms;
+                if (t1.platforms === null) {
+                    platforms = t2.platforms;
+                }
+                else if (t2.platforms === null) {
+                    platforms = t1.platforms;
+                }
+                else {
+                    platforms = t1.platforms.filter(p => t2.platforms.includes(p));
+                }
+                return FunctionType(t1.inputs.map((t, i) => TypeUnion(t, t2.inputs[i])), TypeIntersect(t1.output, t2.output), platforms);
+            }
+            else {
+                throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else {
+            if (t1.type === t2.type) {
+                return t1;
+            }
+            else {
+                throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+    }
+    catch (cause) {
+        if (cause instanceof TypeMismatchError) {
+            throw cause; // Don't wrap our own errors - they already have the full path
+        }
+        throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}`, { cause });
+    }
+}
+/**
+ * Asserts that two East types are equal, returning the first type.
+ *
+ * @typeParam T1 - First {@link EastType}
+ * @typeParam T2 - Second {@link EastType}
+ * @param t1 - First type
+ * @param t2 - Second type
+ * @param r1 - Internal parameter for tracking the first recursive type being compared
+ * @param r2 - Internal parameter for tracking the second recursive type being compared
+ * @returns The first type if types are equal
+ * @throws {TypeMismatchError} When the types are not equal
+ *
+ * @remarks
+ * This function recursively validates type equality and throws detailed errors
+ * on mismatch. Used to enforce type constraints in compound type constructors.
+ * Unlike {@link isTypeEqual}, this throws rather than returning a boolean.
+ */
+export function TypeEqual(t1, t2, r1 = t1, r2 = t2) {
+    // TODO this is broken for recursive types (need to do cycle tracking in tandem with TypeUnion/TypeIntersect)
+    try {
+        if (t1.type === "Ref") {
+            if (t2.type === "Ref") {
+                return RefType(TypeEqual(t1.value, t2.value, r1, r2));
+            }
+            else {
+                throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Array") {
+            if (t2.type === "Array") {
+                return ArrayType(TypeEqual(t1.value, t2.value, r1, r2));
+            }
+            else {
+                throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Set") {
+            if (t2.type === "Set") {
+                return SetType(TypeEqual(t1.key, t2.key, r1, r2));
+            }
+            else {
+                throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Dict") {
+            if (t2.type === "Dict") {
+                return DictType(TypeEqual(t1.key, t2.key, r1, r2), TypeEqual(t1.value, t2.value, r1, r2));
+            }
+            else {
+                throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Struct") {
+            if (t2.type === "Struct") {
+                const e1 = Object.entries(t1.fields);
+                const e2 = Object.entries(t2.fields);
+                if (e1.length !== e2.length)
+                    throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: structs contain different number of fields`);
+                let i = 0;
+                const e = {};
+                for (const [k1, f1] of e1) {
+                    const [k2, f2] = e2[i];
+                    if (k1 !== k2)
+                        throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: struct field ${i} has mismatched names ${printIdentifier(k1)} and ${printIdentifier(k2)}`);
+                    e[k1] = TypeEqual(f1, f2, r1, r2);
+                    i += 1;
+                }
+                return StructType(e);
+            }
+            else {
+                throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Variant") {
+            // We can reuse the logic for structs here, taking advantage of the ordering guarantees
+            if (t2.type === "Variant") {
+                const e1 = Object.entries(t1.cases);
+                const e2 = Object.entries(t2.cases);
+                if (e1.length !== e2.length)
+                    throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: variants contain different number of cases`);
+                let i = 0;
+                const e = {};
+                for (const [k1, f1] of e1) {
+                    const [k2, f2] = e2[i];
+                    if (k1 !== k2) {
+                        if (k1 < k2) {
+                            throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: variant case ${k1} is not present in both variants`);
+                        }
+                        else {
+                            throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: variant case ${k2} is not present in both variants`);
+                        }
+                    }
+                    e[k1] = TypeEqual(f1, f2, r1, r2);
+                    i += 1;
+                }
+                return VariantType(e);
+            }
+            else {
+                throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Recursive") {
+            if (t2.type === "Recursive") {
+                if (t1.node === r1) {
+                    if (t2.node === r2) {
+                        return t1; // both are references to the same recursive type
+                    }
+                    else {
+                        throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: recursive types do not match`);
+                    }
+                }
+                else if (t2.node === r2) {
+                    throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: recursive types do not match`);
+                }
+                // this is the root of a new recursive type - assert the node types are equal
+                return RecursiveType(() => TypeEqual(t1.node, t2.node, t1.node, t2.node));
+            }
+            else {
+                throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Function") {
+            if (t2.type === "Function") {
+                if (t1.inputs.length !== t2.inputs.length) {
+                    throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: functions take different number of arguments`);
+                }
+                if (t1.platforms === null) {
+                    if (t2.platforms !== null) {
+                        throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: functions have different platform effects`);
+                    }
+                }
+                else if (t2.platforms === null) {
+                    throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: functions have different platform effects`);
+                }
+                else {
+                    if (t1.platforms.length !== t2.platforms.length || !t1.platforms.every((p, i) => p === t2.platforms[i])) {
+                        throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: functions have different platform effects`);
+                    }
+                }
+                return FunctionType(t1.inputs.map((t, i) => TypeEqual(t, t2.inputs[i], r1, r2)), TypeEqual(t1.output, t2.output, r1, r2), t1.platforms);
+            }
+            else {
+                throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: incompatible types`);
+            }
+        }
+        else {
+            if (t1.type === t2.type) {
+                return t1;
+            }
+            else {
+                throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: incompatible types`);
+            }
+        }
+    }
+    catch (cause) {
+        if (cause instanceof TypeMismatchError) {
+            throw cause; // Don't wrap our own errors - they already have the full path
+        }
+        throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}`, { cause });
+    }
+}
+/**
+ * Create a type wide enough to hold values from two East types at runtime.
+ *
+ * @param t1 - First type
+ * @param t2 - Second type
+ * @returns The union type
+ * @throws {TypeMismatchError} When the types cannot be unified
+ *
+ * @remarks
+ * This is a more forgiving version of the {@link TypeUnion} type, designed for inferring types from values.
+ * Functions and recursive types are not supported.
+ * Error messages include the full type path for debugging.
+ */
+export function TypeWiden(t1, t2) {
+    try {
+        if (t1.type === "Never") {
+            return t2;
+        }
+        else if (t2.type === "Never") {
+            return t1;
+        }
+        else if (t1.type === "Recursive") {
+            throw new TypeMismatchError(`Cannot widen ${printType(t1)} with ${printType(t2)}: recursive types not supported`);
+        }
+        else if (t2.type === "Recursive") {
+            throw new TypeMismatchError(`Cannot widen ${printType(t1)} with ${printType(t2)}: recursive types not supported`);
+        }
+        else if (t1.type === "Ref") {
+            if (t2.type === "Ref") {
+                return RefType(TypeWiden(t1.value, t2.value));
+            }
+            else {
+                throw new TypeMismatchError(`Cannot widen ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Array") {
+            if (t2.type === "Array") {
+                return ArrayType(TypeWiden(t1.value, t2.value));
+            }
+            else {
+                throw new TypeMismatchError(`Cannot widen ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Set") {
+            if (t2.type === "Set") {
+                return SetType(TypeWiden(t1.key, t2.key));
+            }
+            else {
+                throw new TypeMismatchError(`Cannot widen ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Dict") {
+            if (t2.type === "Dict") {
+                return DictType(TypeWiden(t1.key, t2.key), TypeWiden(t1.value, t2.value));
+            }
+            else {
+                throw new TypeMismatchError(`Cannot widen ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Struct") {
+            if (t2.type === "Struct") {
+                const e1 = Object.entries(t1.fields);
+                const e2 = Object.entries(t2.fields);
+                if (e1.length !== e2.length)
+                    throw new TypeMismatchError(`Cannot widen ${printType(t1)} with ${printType(t2)}: structs contain different number of fields`);
+                let i = 0;
+                const e = {};
+                for (const [k1, f1] of e1) {
+                    const [k2, f2] = e2[i];
+                    if (k1 !== k2)
+                        throw new TypeMismatchError(`Cannot widen ${printType(t1)} with ${printType(t2)}: struct field ${i} has mismatched names ${printIdentifier(k1)} and ${printIdentifier(k2)}`);
+                    e[k1] = TypeWiden(f1, f2);
+                    i += 1;
+                }
+                return StructType(e);
+            }
+            else {
+                throw new TypeMismatchError(`Cannot widen ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Variant") {
+            if (t2.type === "Variant") {
+                const cases = {};
+                for (const [k1, f1] of Object.entries(t1.cases)) {
+                    const f2 = t2.cases[k1];
+                    if (f2 === undefined) {
+                        cases[k1] = f1;
+                    }
+                    else {
+                        cases[k1] = TypeWiden(f1, f2);
+                    }
+                }
+                for (const [k2, f2] of Object.entries(t2.cases)) {
+                    const f1 = t1.cases[k2];
+                    if (f1 === undefined) {
+                        cases[k2] = f2;
+                    }
+                }
+                return VariantType(cases);
+            }
+            else {
+                throw new TypeMismatchError(`Cannot widen ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "Function") {
+            throw new TypeMismatchError(`Cannot widen ${printType(t1)} with ${printType(t2)}: functions not supported`);
+        }
+        else {
+            if (t1.type === t2.type) {
+                return t1;
+            }
+            else {
+                throw new TypeMismatchError(`Cannot widen ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+    }
+    catch (cause) {
+        if (cause instanceof TypeMismatchError) {
+            throw cause; // Don't wrap our own errors - they already have the full path
+        }
+        throw new TypeMismatchError(`Cannot widen ${printType(t1)} with ${printType(t2)}`, { cause });
+    }
+}
+/**
+ * Formats an identifier for display in type strings.
+ *
+ * @param x - The identifier to format
+ * @returns The identifier, escaped with backticks if it contains special characters
+ *
+ * @remarks
+ * Used by {@link printType} to format field and case names.
+ * Identifiers matching `/^[a-zA-Z_][a-zA-Z0-9_]*$/` are returned as-is,
+ * others are wrapped in backticks with escaping.
+ */
+export function printIdentifier(x) {
+    if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(x)) {
+        return x;
+    }
+    else {
+        return `\`${x.replace('\\', '\\\\').replace('`', '\\`')}\``;
+    }
+}
+/** Singleton instance of {@link NoneType}. */
+export const NoneType = VariantType({ none: NullType });
+/**
+ * Constructs a Some type wrapping a value type.
+ *
+ * @typeParam T - The type of the wrapped value
+ * @param type - The {@link EastType} to wrap
+ * @returns A SomeType variant
+ */
+export function SomeType(type) {
+    return VariantType({ some: type });
+}
+/**
+ * Constructs an Option type for optional values.
+ *
+ * @typeParam T - The type of the value when present
+ * @param type - The {@link EastType} of the wrapped value
+ * @returns An OptionType variant with none and some cases
+ *
+ * @example
+ * ```ts
+ * const maybeInt = OptionType(IntegerType);
+ * // Type: VariantType<{ none: NullType, some: IntegerType }>
+ * ```
+ */
+export function OptionType(type) {
+    return VariantType({ none: NullType, some: type });
+}
+//# sourceMappingURL=types.js.map