@elaraai/east 0.0.1-beta.0

package/dist/src/compile.js

@@ -0,0 +1,3260 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { Builtins } from "./builtins.js";
+import { printLocationValue } from "./ir.js";
+import { compareFor, equalFor, greaterEqualFor, greaterFor, isFor, lessEqualFor, lessFor, notEqualFor } from "./comparison.js";
+import { printFor, parseFor } from "./serialization/east.js";
+import { variant } from "./containers/variant.js";
+import { EastError } from "./error.js";
+import { SortedSet } from "./containers/sortedset.js";
+import { SortedMap } from "./containers/sortedmap.js";
+import { BufferWriter } from "./serialization/binary-utils.js";
+import { decodeBeast2For, decodeBeastFor, encodeBeast2For, encodeBeastFor, fromJSONFor, toJSONFor } from "./serialization/index.js";
+import { formatDateTime } from "./datetime_format/print.js";
+import { parseDateTimeFormatted } from "./datetime_format/parse.js";
+import { EastTypeValueType, isTypeValueEqual, isSubtypeValue, toEastTypeValue, expandTypeValue } from "./type_of_type.js";
+import { ref } from "./containers/ref.js";
+export { isTypeValueEqual };
+export const printTypeValue = printFor(EastTypeValueType);
+/** @internal Track iteration locks to prevent concurrent modification */
+const iterationLocks = new WeakMap();
+/** @internal Lock a collection for iteration (prevents size/keyset modifications) */
+const lockForIteration = (obj) => {
+    iterationLocks.set(obj, (iterationLocks.get(obj) || 0) + 1);
+};
+/** @internal Unlock a collection after iteration */
+const unlockForIteration = (obj) => {
+    const count = iterationLocks.get(obj) || 0;
+    if (count > 1) {
+        iterationLocks.set(obj, count - 1);
+    }
+    else {
+        iterationLocks.delete(obj);
+    }
+};
+/** @internal An exception throw for the purpose of early function return */
+export class ReturnException {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+/** @internal An exception throw for the purpose of early loop continue */
+class ContinueException {
+    label;
+    constructor(label) {
+        this.label = label;
+    }
+}
+/** @internal An exception throw for the purpose of early loop break */
+class BreakException {
+    label;
+    constructor(label) {
+        this.label = label;
+    }
+}
+/** Compile `IR` into a JavaScript function using a closure-compiler technique.
+* This should execute faster than a simple tree-walking interpreter, but slower than hand-written Javascript.
+*
+* A "context" of the current variables in scope is given. For toplevel function IR, provide `{}`.
+* A "platform" is provided with JavaScript functions to perform effects, like logging. If no effects are needed, simply provide `{}`.
+*
+* @internal
+*/
+export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx = true, compilingNodes = new Set()) {
+    // Detect circular IR
+    if (compilingNodes.has(ir)) {
+        throw new Error(`Circular IR reference detected at ${printLocationValue(ir.value?.location || { file: "unknown", line: 0, column: 0 })}. `);
+    }
+    // Track this node (exception-safe with try-finally)
+    compilingNodes.add(ir);
+    try {
+        return compileNodeInternal(ir, ctx, platform, asyncPlatformFns, fresh_ctx, compilingNodes);
+    }
+    finally {
+        compilingNodes.delete(ir);
+    }
+}
+/** Internal helper that does the actual compilation work */
+function compileNodeInternal(ir, ctx, platform, asyncPlatformFns, fresh_ctx, compilingNodes = new Set()) {
+    if (ir.type === "Value") {
+        if (ir.value.type.type !== ir.value.value.type) {
+            throw new Error(`Value node expected value of type .${ir.value.type.type} but got .${ir.value.value.type} at ${printLocationValue(ir.value.location)}`);
+        }
+        const v = ir.value.value.value;
+        return (_ctx) => v;
+    }
+    else if (ir.type === "Error") {
+        const message_compiled = compile_internal(ir.value.message, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const location = ir.value.location;
+        if (ir.value.isAsync) {
+            return async (ctx) => { throw new EastError(await message_compiled(ctx), { location: location }); };
+        }
+        else {
+            return (ctx) => { throw new EastError(message_compiled(ctx), { location: location }); };
+        }
+    }
+    else if (ir.type === "TryCatch") {
+        const try_body = compile_internal(ir.value.try_body, Object.create(ctx), platform, asyncPlatformFns, true, compilingNodes);
+        const new_ctx = Object.create(ctx);
+        const message_name = ir.value.message.value.name;
+        const stack_name = ir.value.stack.value.name;
+        new_ctx[message_name] = ir.value.message.value.type;
+        new_ctx[stack_name] = ir.value.stack.value.type;
+        const catch_body = compile_internal(ir.value.catch_body, new_ctx, platform, asyncPlatformFns, true, compilingNodes);
+        // Don't include finally unless necessary (Value nodes are effect free)
+        const finally_body = ir.value.finally_body.type === "Value" ? undefined : compile_internal(ir.value.finally_body, Object.create(ctx), platform, asyncPlatformFns, true, compilingNodes);
+        if (ir.value.isAsync) {
+            if (finally_body === undefined) {
+                return async (ctx) => {
+                    try {
+                        return await try_body(Object.create(ctx));
+                    }
+                    catch (e) {
+                        if (e instanceof EastError) {
+                            const new_ctx = Object.create(ctx);
+                            new_ctx[message_name] = e.message;
+                            new_ctx[stack_name] = e.location;
+                            return await catch_body(new_ctx);
+                        }
+                        else {
+                            throw (e);
+                        }
+                    }
+                };
+            }
+            else {
+                return async (ctx) => {
+                    try {
+                        return await try_body(Object.create(ctx));
+                    }
+                    catch (e) {
+                        if (e instanceof EastError) {
+                            const new_ctx = Object.create(ctx);
+                            new_ctx[message_name] = e.message;
+                            new_ctx[stack_name] = e.location;
+                            return await catch_body(new_ctx);
+                        }
+                        else {
+                            throw (e);
+                        }
+                    }
+                    finally {
+                        await finally_body(Object.create(ctx));
+                    }
+                };
+            }
+        }
+        else {
+            if (finally_body === undefined) {
+                return (ctx) => {
+                    try {
+                        return try_body(Object.create(ctx));
+                    }
+                    catch (e) {
+                        if (e instanceof EastError) {
+                            const new_ctx = Object.create(ctx);
+                            new_ctx[message_name] = e.message;
+                            new_ctx[stack_name] = e.location;
+                            return catch_body(new_ctx);
+                        }
+                        else {
+                            throw (e);
+                        }
+                    }
+                };
+            }
+            else {
+                return (ctx) => {
+                    try {
+                        return try_body(Object.create(ctx));
+                    }
+                    catch (e) {
+                        if (e instanceof EastError) {
+                            const new_ctx = Object.create(ctx);
+                            new_ctx[message_name] = e.message;
+                            new_ctx[stack_name] = e.location;
+                            return catch_body(new_ctx);
+                        }
+                        else {
+                            throw (e);
+                        }
+                    }
+                    finally {
+                        finally_body(Object.create(ctx));
+                    }
+                };
+            }
+        }
+    }
+    else if (ir.type === "Variable") {
+        const name = ir.value.name;
+        const ctx_type = ctx[name];
+        if (ctx_type === undefined) {
+            throw new Error(`Variable defined at ${printLocationValue(ir.value.location)} is not in scope at ${printLocationValue(ir.value.location)}`);
+        }
+        if (!isTypeValueEqual(ctx_type, ir.value.type)) {
+            throw new Error(`Variable defined at ${printLocationValue(ir.value.location)} has type ${printTypeValue(ctx_type)} but expected ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        if (ir.value.mutable && ir.value.captured) {
+            return (ctx) => ctx[name].x;
+        }
+        else {
+            return (ctx) => ctx[name];
+        }
+    }
+    else if (ir.type === "Let") {
+        if (!isSubtypeValue(ir.value.value.value.type, ir.value.variable.value.type)) {
+            throw new Error(`Cannot initialize a variable defined at ${printLocationValue(ir.value.variable.value.location)} of type ${printTypeValue(ir.value.variable.value.type)} to a value of type ${printTypeValue(ir.value.value.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        const compiled_statement = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const name = ir.value.variable.value.name;
+        ctx[name] = ir.value.variable.value.type;
+        if (ir.value.variable.value.mutable && ir.value.variable.value.captured) {
+            if (ir.value.isAsync) {
+                return async (ctx) => {
+                    ctx[name] = { x: await compiled_statement(ctx) };
+                    return null;
+                };
+            }
+            else {
+                return (ctx) => {
+                    ctx[name] = { x: compiled_statement(ctx) };
+                    return null;
+                };
+            }
+        }
+        else {
+            if (ir.value.isAsync) {
+                return async (ctx) => {
+                    ctx[name] = await compiled_statement(ctx);
+                    return null;
+                };
+            }
+            else {
+                return (ctx) => {
+                    ctx[name] = compiled_statement(ctx);
+                    return null;
+                };
+            }
+        }
+    }
+    else if (ir.type === "Assign") {
+        const name = ir.value.variable.value.name;
+        if (ctx[name] === undefined) {
+            throw new Error(`Attempting to reassign to a variable defined at ${printLocationValue(ir.value.variable.value.location)} which is not in scope at ${printLocationValue(ir.value.location)} at ${printLocationValue(ir.value.location)}`);
+        }
+        if (!isSubtypeValue(ir.value.value.value.type, ctx[name])) {
+            throw new Error(`Cannot reassign to a variable defined at ${printLocationValue(ir.value.variable.value.location)} of type ${printTypeValue(ir.value.variable.value.type)} to a value of type ${printTypeValue(ir.value.value.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        if (!ir.value.variable.value.mutable) {
+            throw new Error(`Cannot reassign const variable ${name} at ${printLocationValue(ir.value.location)}`);
+        }
+        const compiled_statement = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        if (ir.value.variable.value.mutable && ir.value.variable.value.captured) {
+            if (ir.value.isAsync) {
+                return async (ctx) => {
+                    const value = await compiled_statement(ctx);
+                    ctx[name].x = value;
+                    return null;
+                };
+            }
+            else {
+                return (ctx) => {
+                    const value = compiled_statement(ctx);
+                    ctx[name].x = value;
+                    return null;
+                };
+            }
+        }
+        else {
+            if (ir.value.isAsync) {
+                return async (ctx) => {
+                    const value = await compiled_statement(ctx);
+                    // We need to check in which prototype the variable lives
+                    while (!Object.hasOwn(ctx, name))
+                        ctx = Object.getPrototypeOf(ctx);
+                    ctx[name] = value;
+                    return null;
+                };
+            }
+            else {
+                return (ctx) => {
+                    const value = compiled_statement(ctx);
+                    // We need to check in which prototype the variable lives
+                    while (!Object.hasOwn(ctx, name))
+                        ctx = Object.getPrototypeOf(ctx);
+                    ctx[name] = value;
+                    return null;
+                };
+            }
+        }
+    }
+    else if (ir.type === "As") {
+        if (!isSubtypeValue(ir.value.value.value.type, ir.value.type)) {
+            throw new Error(`Cannot cast value of type ${printTypeValue(ir.value.value.value.type)} to type ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        // in dynamically typed runtimes like Javascript, this is a no-op
+        // (for statically typed runtimes this assists in unifying types in branches)
+        return compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, fresh_ctx, compilingNodes);
+    }
+    else if (ir.type === "UnwrapRecursive") {
+        // TODO there seems to be cases of Wrap / Unwrap that could be optimized away during compilation
+        if (!isTypeValueEqual(ir.value.value.value.type, ir.value.type)) {
+            throw new Error(`Cannot unwrap recursive value of type ${printTypeValue(ir.value.value.value.type)} to type ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        // in dynamically typed runtimes like Javascript, this is a no-op
+        // (for statically typed runtimes this assists in e.g. typing a reference or pointer)
+        return compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, fresh_ctx, compilingNodes);
+    }
+    else if (ir.type === "WrapRecursive") {
+        // TODO there seems to be cases of Wrap / Unwrap that could be optimized away during compilation
+        if (!isSubtypeValue(ir.value.value.value.type, ir.value.type)) {
+            throw new Error(`Cannot wrap value of type ${printTypeValue(ir.value.value.value.type)} to recursive type ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        // in dynamically typed runtimes like Javascript, this is a no-op
+        // (for statically typed runtimes this assists in e.g. typing a heap allocation)
+        return compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, false, compilingNodes);
+    }
+    else if (ir.type === "Function") {
+        if (ir.value.type.type !== "Function") {
+            throw new Error(`Expected Function type, got ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        const ctx2 = {};
+        for (const variable of ir.value.captures) {
+            const ctx_type = ctx[variable.value.name];
+            if (ctx_type === undefined) {
+                throw new Error(`Captured variable defined at ${printLocationValue(variable.value.location)} is not in scope at ${printLocationValue(ir.value.location)}`);
+            }
+            if (!isTypeValueEqual(ctx_type, variable.value.type)) {
+                throw new Error(`Captured variable defined at ${printLocationValue(variable.value.location)} has type ${printTypeValue(ctx_type)} but expected ${printTypeValue(variable.value.type)} at ${printLocationValue(ir.value.location)}`);
+            }
+            ctx2[variable.value.name] = variable.value.type;
+        }
+        for (const parameter of ir.value.parameters) {
+            const parameter_name = parameter.value.name;
+            ctx2[parameter_name] = parameter.value.type;
+        }
+        // Function return values are covariant
+        // TODO what is the semantics here in a static language? Should we use `As` here?
+        // Note: this requires unreachability analysis to be correct, since early terminating programs might have a final statement that produces never
+        if (!isSubtypeValue(ir.value.body.value.type, ir.value.type.value.output)) {
+            throw new Error(`Expected Function to return type ${printTypeValue(ir.value.type.value.output)}, got ${printTypeValue(ir.value.body.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+        const bodyIsAsync = ir.value.type.value.platforms.some(p => asyncPlatformFns.has(p));
+        const capture_names = ir.value.captures.map(v => v.value.name);
+        const parameter_names = ir.value.parameters.map(v => v.value.name);
+        return (ctx) => {
+            const ctx2 = {};
+            for (const name of capture_names) {
+                ctx2[name] = ctx[name];
+            }
+            // If body is async, create an async function that awaits internally
+            if (bodyIsAsync) {
+                return async (...args) => {
+                    const ctx3 = { ...ctx2 };
+                    parameter_names.forEach((name, i) => ctx3[name] = args[i]);
+                    return await compiled_body(ctx3);
+                };
+            }
+            else {
+                return (...args) => {
+                    const ctx3 = { ...ctx2 };
+                    parameter_names.forEach((name, i) => ctx3[name] = args[i]);
+                    return compiled_body(ctx3);
+                };
+            }
+        };
+    }
+    else if (ir.type === "Call") {
+        if (ir.value.function.value.type.type !== "Function") {
+            throw new Error(`Call expected Function, got ${printTypeValue(ir.value.function.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        if (ir.value.function.value.type.value.inputs.length !== ir.value.arguments.length) {
+            throw new Error(`Function expected ${ir.value.function.value.type.value.inputs.length} arguments, got ${ir.value.arguments.length} at ${printLocationValue(ir.value.location)}`);
+        }
+        for (const [i, t] of ir.value.function.value.type.value.inputs.entries()) {
+            // TODO what is the semantics here in a static language? Should we use `As` here?
+            if (!isSubtypeValue(t, ir.value.arguments[i].value.type)) {
+                throw new Error(`Function expected argument ${i + 1} of type ${printTypeValue(t)}, got ${printTypeValue(ir.value.arguments[i].value.type)} at ${printLocationValue(ir.value.location)}`);
+            }
+        }
+        const compiled_f = compile_internal(ir.value.function, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const compiled_args = ir.value.arguments.map(argument => compile_internal(argument, ctx, platform, asyncPlatformFns, false, compilingNodes));
+        const location = ir.value.location;
+        if (ir.value.function.value.type.value.isAsync) {
+            return async (ctx) => {
+                try {
+                    const args = [];
+                    for (const compiled_arg of compiled_args) {
+                        args.push(await compiled_arg(ctx));
+                    }
+                    return (await compiled_f(ctx))(...args);
+                }
+                catch (e) {
+                    if (e instanceof ReturnException) {
+                        return e.value;
+                    }
+                    else if (e instanceof EastError) {
+                        e.location.push(location); // The fact that we need to push the call location not the definition location means we need to handle this here
+                        throw (e);
+                    }
+                    else if (e instanceof ContinueException) {
+                        throw new Error(`continue failed to find label ${e.label} at ${printLocationValue(ir.value.location)}`);
+                    }
+                    else if (e instanceof BreakException) {
+                        throw new Error(`break failed to find label ${e.label} at ${printLocationValue(ir.value.location)}`);
+                    }
+                    else {
+                        throw (e);
+                    }
+                }
+            };
+        }
+        else {
+            return (ctx) => {
+                try {
+                    return compiled_f(ctx)(...compiled_args.map(arg => arg(ctx)));
+                }
+                catch (e) {
+                    if (e instanceof ReturnException) {
+                        return e.value;
+                    }
+                    else if (e instanceof EastError) {
+                        e.location.push(location); // The fact that we need to push the call location not the definition location means we need to handle this here
+                        throw (e);
+                    }
+                    else if (e instanceof ContinueException) {
+                        throw new Error(`continue failed to find label ${e.label} at ${printLocationValue(ir.value.location)}`);
+                    }
+                    else if (e instanceof BreakException) {
+                        throw new Error(`break failed to find label ${e.label} at ${printLocationValue(ir.value.location)}`);
+                    }
+                    else {
+                        throw (e);
+                    }
+                }
+            };
+        }
+    }
+    else if (ir.type === "IfElse") {
+        const ifs = [];
+        for (const { predicate, body } of ir.value.ifs) {
+            ifs.push({
+                predicate: compile_internal(predicate, ctx, platform, asyncPlatformFns, false, compilingNodes),
+                body: compile_internal(body, Object.create(ctx), platform, asyncPlatformFns, true, compilingNodes),
+            });
+        }
+        const else_body = compile_internal(ir.value.else_body, Object.create(ctx), platform, asyncPlatformFns, true, compilingNodes);
+        if (ir.value.isAsync) {
+            return async (ctx) => {
+                for (const { predicate, body } of ifs) {
+                    if (await predicate(ctx)) {
+                        return body(Object.create(ctx));
+                    }
+                }
+                return else_body(Object.create(ctx));
+            };
+        }
+        else {
+            return (ctx) => {
+                for (const { predicate, body } of ifs) {
+                    if (predicate(ctx)) {
+                        return body(Object.create(ctx));
+                    }
+                }
+                return else_body(Object.create(ctx));
+            };
+        }
+    }
+    else if (ir.type === "Match") {
+        const compiled_variant = compile_internal(ir.value.variant, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const compiled_cases = {};
+        const data_names = {};
+        for (const { case: k, variable, body } of ir.value.cases) {
+            const ctx2 = Object.create(ctx);
+            const data_name = variable.value.name;
+            data_names[k] = data_name;
+            ctx2[data_name] = variable.value.type;
+            compiled_cases[k] = compile_internal(body, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+        }
+        if (ir.value.isAsync) {
+            return async (ctx) => {
+                const v = await compiled_variant(ctx);
+                const ctx2 = Object.create(ctx);
+                ctx2[data_names[v.type]] = v.value;
+                return compiled_cases[v.type](ctx2);
+            };
+        }
+        else {
+            return (ctx) => {
+                const v = compiled_variant(ctx);
+                const ctx2 = Object.create(ctx);
+                ctx2[data_names[v.type]] = v.value;
+                return compiled_cases[v.type](ctx2);
+            };
+        }
+    }
+    else if (ir.type === "While") {
+        const compiled_predicate = compile_internal(ir.value.predicate, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const ctx2 = Object.create(ctx);
+        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+        const label = ir.value.label.name;
+        if (ir.value.isAsync) {
+            return async (ctx) => {
+                while (await compiled_predicate(ctx)) {
+                    try {
+                        const ctx2 = Object.create(ctx);
+                        await compiled_body(ctx2);
+                    }
+                    catch (e) {
+                        if (e instanceof ContinueException && e.label === label) {
+                            continue;
+                        }
+                        else if (e instanceof BreakException && e.label === label) {
+                            break;
+                        }
+                        else {
+                            throw e;
+                        }
+                    }
+                }
+                return null;
+            };
+        }
+        else {
+            return (ctx) => {
+                while (compiled_predicate(ctx)) {
+                    try {
+                        const ctx2 = Object.create(ctx);
+                        compiled_body(ctx2);
+                    }
+                    catch (e) {
+                        if (e instanceof ContinueException && e.label === label) {
+                            continue;
+                        }
+                        else if (e instanceof BreakException && e.label === label) {
+                            break;
+                        }
+                        else {
+                            throw e;
+                        }
+                    }
+                }
+                return null;
+            };
+        }
+    }
+    else if (ir.type === "ForArray") {
+        const value_type = expandTypeValue(ir.value.array.value.type).value;
+        const compiled_array = compile_internal(ir.value.array, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const ctx2 = Object.create(ctx);
+        const key_name = ir.value.key.value.name;
+        const value_name = ir.value.value.value.name;
+        ctx2[key_name] = variant("Integer", null);
+        ctx2[value_name] = value_type;
+        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+        const label = ir.value.label.name;
+        if (ir.value.isAsync) {
+            return async (ctx) => {
+                const array = await compiled_array(ctx);
+                lockForIteration(array);
+                try {
+                    for (const [key, value] of array.entries()) {
+                        const ctx2 = Object.create(ctx);
+                        ctx2[key_name] = BigInt(key);
+                        ctx2[value_name] = value;
+                        try {
+                            await compiled_body(ctx2);
+                        }
+                        catch (e) {
+                            if (e instanceof ContinueException && e.label === label) {
+                                continue;
+                            }
+                            else if (e instanceof BreakException && e.label === label) {
+                                break;
+                            }
+                            else {
+                                throw e;
+                            }
+                        }
+                    }
+                    return null;
+                }
+                finally {
+                    unlockForIteration(array);
+                }
+            };
+        }
+        else {
+            return (ctx) => {
+                const array = compiled_array(ctx);
+                lockForIteration(array);
+                try {
+                    for (const [key, value] of array.entries()) {
+                        const ctx2 = Object.create(ctx);
+                        ctx2[key_name] = BigInt(key);
+                        ctx2[value_name] = value;
+                        try {
+                            compiled_body(ctx2);
+                        }
+                        catch (e) {
+                            if (e instanceof ContinueException && e.label === label) {
+                                continue;
+                            }
+                            else if (e instanceof BreakException && e.label === label) {
+                                break;
+                            }
+                            else {
+                                throw e;
+                            }
+                        }
+                    }
+                    return null;
+                }
+                finally {
+                    unlockForIteration(array);
+                }
+            };
+        }
+    }
+    else if (ir.type === "ForSet") {
+        const key_type = expandTypeValue(ir.value.set.value.type).value;
+        const compiled_set = compile_internal(ir.value.set, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const ctx2 = Object.create(ctx);
+        const key_name = ir.value.key.value.name;
+        ctx2[key_name] = key_type;
+        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+        const label = ir.value.label.name;
+        if (ir.value.isAsync) {
+            return async (ctx) => {
+                const set = await compiled_set(ctx);
+                lockForIteration(set);
+                try {
+                    for (const key of set) {
+                        const ctx2 = Object.create(ctx);
+                        ctx2[key_name] = key;
+                        try {
+                            await compiled_body(ctx2);
+                        }
+                        catch (e) {
+                            if (e instanceof ContinueException && e.label === label) {
+                                continue;
+                            }
+                            else if (e instanceof BreakException && e.label === label) {
+                                break;
+                            }
+                            else {
+                                throw e;
+                            }
+                        }
+                    }
+                    return null;
+                }
+                finally {
+                    unlockForIteration(set);
+                }
+            };
+        }
+        else {
+            return (ctx) => {
+                const set = compiled_set(ctx);
+                lockForIteration(set);
+                try {
+                    for (const key of set) {
+                        const ctx2 = Object.create(ctx);
+                        ctx2[key_name] = key;
+                        try {
+                            compiled_body(ctx2);
+                        }
+                        catch (e) {
+                            if (e instanceof ContinueException && e.label === label) {
+                                continue;
+                            }
+                            else if (e instanceof BreakException && e.label === label) {
+                                break;
+                            }
+                            else {
+                                throw e;
+                            }
+                        }
+                    }
+                    return null;
+                }
+                finally {
+                    unlockForIteration(set);
+                }
+            };
+        }
+    }
+    else if (ir.type === "ForDict") {
+        const key_type = expandTypeValue(ir.value.dict.value.type).value.key;
+        const value_type = expandTypeValue(ir.value.dict.value.type).value.value;
+        const compiled_dict = compile_internal(ir.value.dict, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const ctx2 = Object.create(ctx);
+        const key_name = ir.value.key.value.name;
+        const value_name = ir.value.value.value.name;
+        ctx2[key_name] = key_type;
+        ctx2[value_name] = value_type;
+        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+        const label = ir.value.label.name;
+        if (ir.value.isAsync) {
+            return async (ctx) => {
+                const dict = await compiled_dict(ctx);
+                lockForIteration(dict);
+                try {
+                    for (const [key, value] of dict) {
+                        const ctx2 = Object.create(ctx);
+                        ctx2[key_name] = key;
+                        ctx2[value_name] = value;
+                        try {
+                            await compiled_body(ctx2);
+                        }
+                        catch (e) {
+                            if (e instanceof ContinueException && e.label === label) {
+                                continue;
+                            }
+                            else if (e instanceof BreakException && e.label === label) {
+                                break;
+                            }
+                            else {
+                                throw e;
+                            }
+                        }
+                    }
+                    return null;
+                }
+                finally {
+                    unlockForIteration(dict);
+                }
+            };
+        }
+        else {
+            return (ctx) => {
+                const dict = compiled_dict(ctx);
+                lockForIteration(dict);
+                try {
+                    for (const [key, value] of dict) {
+                        const ctx2 = Object.create(ctx);
+                        ctx2[key_name] = key;
+                        ctx2[value_name] = value;
+                        try {
+                            compiled_body(ctx2);
+                        }
+                        catch (e) {
+                            if (e instanceof ContinueException && e.label === label) {
+                                continue;
+                            }
+                            else if (e instanceof BreakException && e.label === label) {
+                                break;
+                            }
+                            else {
+                                throw e;
+                            }
+                        }
+                    }
+                    return null;
+                }
+                finally {
+                    unlockForIteration(dict);
+                }
+            };
+        }
+    }
+    else if (ir.type === "Block") {
+        // The pattern of creating a new context (e.g. a function) and then immediately invoking a block (e.g. as the function body) is very common.
+        // Here we avoid creating a second context when possible, as an optimization.
+        if (fresh_ctx) {
+            let last_type = variant("Null", null);
+            const compiled_statements = [];
+            for (const statement of ir.value.statements) {
+                const compiled_statement = compile_internal(statement, ctx, platform, asyncPlatformFns, true, compilingNodes);
+                compiled_statements.push(compiled_statement);
+                last_type = statement.value.type;
+            }
+            if (!isSubtypeValue(last_type, ir.value.type)) {
+                throw new Error(`Block evaluates to type ${printTypeValue(last_type)} but expected ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+            }
+            if (ir.value.isAsync) {
+                return async (ctx) => {
+                    let ret = null;
+                    for (const statement of compiled_statements) {
+                        ret = await statement(ctx);
+                    }
+                    return ret;
+                };
+            }
+            else {
+                return (ctx) => {
+                    let ret = null;
+                    for (const statement of compiled_statements) {
+                        ret = statement(ctx);
+                    }
+                    return ret;
+                };
+            }
+        }
+        else {
+            const ctx2 = Object.create(ctx);
+            let last_type = variant("Null", null);
+            const compiled_statements = [];
+            for (const statement of ir.value.statements) {
+                const compiled_statement = compile_internal(statement, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+                compiled_statements.push(compiled_statement);
+                last_type = statement.value.type;
+            }
+            if (!isSubtypeValue(last_type, ir.value.type)) {
+                throw new Error(`Block evaluates to type ${printTypeValue(last_type)} but expected ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+            }
+            if (ir.value.isAsync) {
+                return async (ctx) => {
+                    const ctx2 = Object.create(ctx);
+                    let ret = null;
+                    for (const statement of compiled_statements) {
+                        ret = await statement(ctx2);
+                    }
+                    return ret;
+                };
+            }
+            else {
+                return (ctx) => {
+                    const ctx2 = Object.create(ctx);
+                    let ret = null;
+                    for (const statement of compiled_statements) {
+                        ret = statement(ctx2);
+                    }
+                    return ret;
+                };
+            }
+        }
+    }
+    else if (ir.type === "GetField") {
+        if (ir.value.struct.value.type.type !== "Struct") {
+            throw new Error(`GetField expected Struct, got ${printTypeValue(ir.value.struct.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        const struct_field = expandTypeValue(ir.value.struct.value.type).value.find(f => f.name === ir.value.field);
+        if (!struct_field) {
+            throw new Error(`GetField field ${ir.value.field} not found in struct ${printTypeValue(ir.value.struct.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        if (!isTypeValueEqual(struct_field.type, ir.value.type)) {
+            throw new Error(`GetField expected to have type ${printTypeValue(ir.value.type)}, got ${printTypeValue(struct_field.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        const struct = compile_internal(ir.value.struct, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const field = ir.value.field;
+        if (ir.value.isAsync) {
+            return async (ctx) => (await struct(ctx))[field];
+        }
+        else {
+            return (ctx) => struct(ctx)[field];
+        }
+    }
+    else if (ir.type === "Struct") {
+        if (ir.value.type.type !== "Struct") {
+            throw new Error(`Expected Struct output type, got ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        const fields = ir.value.fields.map((f, i) => {
+            const struct_field = expandTypeValue(ir.value.type).value[i];
+            if (!struct_field || struct_field.name !== f.name) {
+                throw new Error(`Struct field ${f.name} not found at position ${i} in struct type ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+            }
+            if (!isSubtypeValue(f.value.value.type, struct_field.type)) {
+                throw new Error(`Struct field ${f.name} expected to have type ${printTypeValue(struct_field.type)}, got ${printTypeValue(f.value.value.type)} at ${printLocationValue(ir.value.location)}`);
+            }
+            return compile_internal(f.value, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        });
+        const keys = ir.value.fields.map(f => f.name);
+        if (ir.value.isAsync) {
+            return async (ctx) => {
+                const fs = [];
+                for (const [i, a] of fields.entries()) {
+                    fs.push([keys[i], await a(ctx)]);
+                }
+                return Object.fromEntries(fs);
+            };
+        }
+        else {
+            return (ctx) => Object.fromEntries(fields.map((a, i) => [keys[i], a(ctx)]));
+        }
+    }
+    else if (ir.type === "Variant") {
+        if (ir.value.type.type !== "Variant") {
+            throw new Error(`Expected Variant output type, got ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        const k = ir.value.case;
+        const variant_case = expandTypeValue(ir.value.type).value.find(c => c.name === k);
+        if (!variant_case) {
+            throw new Error(`Variant case ${k} not found in variant type ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        if (!isSubtypeValue(ir.value.value.value.type, variant_case.type)) {
+            throw new Error(`Variant case ${k} expected to have type ${printTypeValue(variant_case.type)}, got ${printTypeValue(ir.value.value.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        const v = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        if (ir.value.isAsync) {
+            return async (ctx) => variant(k, await v(ctx));
+        }
+        else {
+            return (ctx) => variant(k, v(ctx));
+        }
+    }
+    else if (ir.type === "NewRef") {
+        if (ir.value.type.type !== "Ref") {
+            throw new Error(`Expected Ref output type, got ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        if (!isSubtypeValue(ir.value.value.value.type, expandTypeValue(ir.value.type).value)) {
+            throw new Error(`NewRef value expected to have type ${printTypeValue(ir.value.type.value)}, got ${printTypeValue(ir.value.value.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        const value = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        if (ir.value.isAsync) {
+            return async (ctx) => ref(await value(ctx));
+        }
+        else {
+            return (ctx) => ref(value(ctx));
+        }
+    }
+    else if (ir.type === "NewArray") {
+        if (ir.value.type.type !== "Array") {
+            throw new Error(`Expected Array output type, got ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        const values = ir.value.values.map(a => {
+            if (!isSubtypeValue(a.value.type, expandTypeValue(ir.value.type).value)) {
+                throw new Error(`NewArray element expected to have type ${printTypeValue(ir.value.type.value)}, got ${printTypeValue(a.value.type)} at ${printLocationValue(ir.value.location)}`);
+            }
+            return compile_internal(a, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        });
+        if (ir.value.isAsync) {
+            return async (ctx) => {
+                let vals = [];
+                for (const a of values) {
+                    vals.push(await a(ctx));
+                }
+                return vals;
+            };
+        }
+        else {
+            return (ctx) => values.map(a => a(ctx));
+        }
+    }
+    else if (ir.type === "NewSet") {
+        if (ir.value.type.type !== "Set") {
+            throw new Error(`Expected Set output type, got ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        const values = ir.value.values.map(a => {
+            if (!isSubtypeValue(a.value.type, expandTypeValue(ir.value.type).value)) {
+                throw new Error(`NewSet element expected to have type ${printTypeValue(ir.value.type.value)}, got ${printTypeValue(a.value.type)} at ${printLocationValue(ir.value.location)}`);
+            }
+            return compile_internal(a, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        });
+        const keyComparer = compareFor(ir.value.type.value);
+        if (ir.value.isAsync) {
+            return (ctx) => {
+                const keys = [];
+                for (const a of values) {
+                    keys.push(a(ctx));
+                }
+                return new SortedSet(keys, keyComparer);
+            };
+        }
+        else {
+            return (ctx) => new SortedSet(values.map(a => a(ctx)), keyComparer);
+        }
+    }
+    else if (ir.type === "NewDict") {
+        if (ir.value.type.type !== "Dict") {
+            throw new Error(`Expected Dict output type, got ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        const values = ir.value.values.map(({ key, value }) => {
+            if (!isSubtypeValue(key.value.type, expandTypeValue(ir.value.type).value.key)) {
+                throw new Error(`NewDict key expected to have type ${printTypeValue(ir.value.type.value.key)}, got ${printTypeValue(key.value.type)} at ${printLocationValue(ir.value.location)}`);
+            }
+            if (!isSubtypeValue(value.value.type, expandTypeValue(ir.value.type).value.value)) {
+                throw new Error(`NewDict value expected to have type ${printTypeValue(ir.value.type.value.value)}, got ${printTypeValue(value.value.type)} at ${printLocationValue(ir.value.location)}`);
+            }
+            return [compile_internal(key, ctx, platform, asyncPlatformFns, false, compilingNodes), compile_internal(value, ctx, platform, asyncPlatformFns, false, compilingNodes)];
+        });
+        const keyComparer = compareFor(ir.value.type.value.key);
+        if (ir.value.isAsync) {
+            return async (ctx) => {
+                const entries = [];
+                for (const [k, v] of values) {
+                    entries.push([await k(ctx), await v(ctx)]);
+                }
+                return new SortedMap(entries, keyComparer);
+            };
+        }
+        else {
+            return (ctx) => new SortedMap(values.map(([k, v]) => [k(ctx), v(ctx)]), keyComparer);
+        }
+    }
+    else if (ir.type === "Return") {
+        if (ir.value.type.type !== "Never") {
+            throw new Error(`Return must have Never type, got ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        // TODO pipe through return type context so we can check it here
+        const compiled_value = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        if (ir.value.isAsync) {
+            return async (ctx) => {
+                throw new ReturnException(await compiled_value(ctx));
+            };
+        }
+        else {
+            return (ctx) => {
+                throw new ReturnException(compiled_value(ctx));
+            };
+        }
+    }
+    else if (ir.type === "Continue") {
+        if (ir.value.type.type !== "Never") {
+            throw new Error(`Continue must have Never type, got ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        const label = ir.value.label;
+        // TODO pipe through local label context so we can check it here
+        return (_ctx) => {
+            throw new ContinueException(label.name);
+        };
+    }
+    else if (ir.type === "Break") {
+        if (ir.value.type.type !== "Never") {
+            throw new Error(`Break must have Never type, got ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        const label = ir.value.label;
+        // TODO pipe through local label context so we can check it here
+        return (_ctx) => {
+            throw new BreakException(label.name);
+        };
+    }
+    else if (ir.type === "Builtin") {
+        // TODO - I haven't dealt with builtins implementations yet
+        // check types match
+        let b = Builtins[ir.value.builtin];
+        if (b === undefined) {
+            throw new Error(`Builtin ${JSON.stringify(ir.value.builtin)} not found at ${printLocationValue(ir.value.location)}`);
+        }
+        if (b.type_parameters.length !== ir.value.type_parameters.length) {
+            throw new Error(`Builtin ${JSON.stringify(ir.value.builtin)} expected ${b.type_parameters.length} type parameters, got ${ir.value.type_parameters.length} type parameters at ${printLocationValue(ir.value.location)}`);
+        }
+        if (b.inputs.length !== ir.value.arguments.length) {
+            throw new Error(`Builtin ${JSON.stringify(ir.value.builtin)} expected ${b.inputs.length} arguments, got ${ir.value.arguments.length} arguments at ${printLocationValue(ir.value.location)}`);
+        }
+        const type_params = new Map(b.type_parameters.map((T, i) => [T, ir.value.type_parameters[i]]));
+        let argsAsync = false;
+        const args = ir.value.arguments.map((a, _i) => {
+            // TODO these checks seem to fail for some builtins - particularly comparisons with recursive types
+            // The issue appears to be that the type parameters in ir.value.type_parameters have been expanded too much
+            // The Expr machinery and UnionType are possibly places to investigate why the identity of types is getting lost (or else we might need a more structural, not identity-based, approach to toEastTypeValue)
+            // The failures here do not cause faults, but it might make life harder for a static compiler
+            // const builtin_arg_type = b.inputs[i]!;
+            // const expected_type = applyTypeParameters(toEastTypeValue(builtin_arg_type), type_params);
+            // TODO what is the semantics here in a static language? Should we use `As` here?
+            // if (!isSubtypeValue(a.value.type, expected_type)) {
+            //   throw new Error(`Argument ${i+1} to builtin ${JSON.stringify(ir.value.builtin)} with type parameters [${ir.value.type_parameters.map(t => printTypeValue(t)).join(", ")}] expected to have type ${printTypeValue(expected_type)}, got ${printTypeValue(a.value.type)} at ${printLocationValue(a.value.location)}`)
+            // }
+            if (a.value.isAsync) {
+                argsAsync = true;
+            }
+            return compile_internal(a, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        });
+        const expected_output_type = applyTypeParameters(typeof b.output === "string" ? b.output : toEastTypeValue(b.output), type_params);
+        // TODO what is the semantics here in a static language? Should we use `As` here? What about variance?
+        if (!isTypeValueEqual(ir.value.type, expected_output_type)) {
+            throw new Error(`Builtin ${JSON.stringify(ir.value.builtin)} output type expected to have type ${printTypeValue(expected_output_type)}, got ${printTypeValue(ir.value.type)} at ${printLocationValue(ir.value.location)}`);
+        }
+        // Special optimization for regex builtins with literal pattern/flags
+        if ((ir.value.builtin === "RegexContains" || ir.value.builtin === "RegexIndexOf" || ir.value.builtin === "RegexReplace") &&
+            ir.value.arguments[1]?.type === "Value" &&
+            ir.value.arguments[2]?.type === "Value") {
+            if (ir.value.arguments[1].value.value.type !== "String") {
+                throw new Error(`Regex builtin pattern argument must be String literal at ${printLocationValue(ir.value.arguments[1].value.location)}`);
+            }
+            if (ir.value.arguments[2].value.value.type !== "String") {
+                throw new Error(`Regex builtin flags argument must be String literal at ${printLocationValue(ir.value.arguments[2].value.location)}`);
+            }
+            // Compile regex once at closure compilation time
+            const pattern = ir.value.arguments[1].value.value.value;
+            const flags = ir.value.arguments[2].value.value.value;
+            const textArg = args[0]; // Already compiled text argument
+            if (ir.value.builtin === "RegexContains") {
+                const compiledRegex = new RegExp(pattern, flags);
+                return (ctx) => compiledRegex.test(textArg(ctx));
+            }
+            else if (ir.value.builtin === "RegexIndexOf") {
+                const compiledRegex = new RegExp(pattern, flags);
+                return (ctx) => {
+                    const text = textArg(ctx);
+                    const codeUnitIndex = text.search(compiledRegex);
+                    if (codeUnitIndex === -1)
+                        return -1n;
+                    // Convert code unit index to codepoint index
+                    let codepointIndex = 0;
+                    let codeUnitPos = 0;
+                    for (const char of text) {
+                        if (codeUnitPos === codeUnitIndex) {
+                            return BigInt(codepointIndex);
+                        }
+                        codeUnitPos += char.length;
+                        codepointIndex++;
+                    }
+                    return -1n;
+                };
+            }
+            else { // RegexReplace
+                // Precompile regex with global flag for replaceAll semantics
+                const globalFlags = flags.includes('g') ? flags : flags + 'g';
+                const compiledRegex = new RegExp(pattern, globalFlags);
+                // Check if replacement is also constant for full optimization
+                if (ir.value.arguments[3]?.type === "Value") {
+                    if (ir.value.arguments[3].value.value.type !== "String") {
+                        throw new Error(`RegexReplace builtin replacement argument must be String literal at ${printLocationValue(ir.value.arguments[3].value.location)}`);
+                    }
+                    // FULL OPTIMIZATION: Pattern, flags, and replacement are all constant
+                    const replacement = ir.value.arguments[3].value.value.value;
+                    // Validate replacement string: only allow $$, $1-$9, and $<
+                    // This is stricter than JavaScript's native behavior but provides clear, consistent semantics
+                    // and avoids backend-specific features like $&, $`, $'
+                    let i = 0;
+                    while (i < replacement.length) {
+                        const char = replacement[i];
+                        if (char === '$') {
+                            i += char.length;
+                            let char2 = replacement[i];
+                            if (char2 === undefined) {
+                                return (_ctx) => { throw new EastError(`invalid regex replacement string: unescaped $ at end of string`, { location: ir.value.arguments[3].value.location }); };
+                            }
+                            else if (char2 === '$') {
+                                i += 1;
+                            }
+                            else if (char2 >= '1' && char2 <= '9') {
+                                i += 1;
+                                char2 = replacement[i];
+                                while (char2 !== undefined && char2 >= '0' && char2 <= '9') {
+                                    i += 1;
+                                    char2 = replacement[i];
+                                }
+                            }
+                            else if (char2 === '<') {
+                                // Scan until closing >
+                                i += 1;
+                                const init_i = i;
+                                char2 = replacement[i];
+                                while (true) {
+                                    if (char2 === undefined) {
+                                        return (_ctx) => { throw new EastError(`invalid regex replacement string: unterminated group name in $<...>`, { location: ir.value.arguments[3].value.location }); };
+                                    }
+                                    if (char2 === '>') {
+                                        break;
+                                    }
+                                    if (!((char2 >= '0' && char2 <= '9') || (char2 >= 'a' && char2 <= 'z') || (char2 >= 'A' && char2 <= 'Z') || char2 === '_')) {
+                                        return (_ctx) => { throw new EastError(`invalid regex replacement string: invalid character ${JSON.stringify(char2)} in group name in $<...>`, { location: ir.value.arguments[3].value.location }); };
+                                    }
+                                    i += 1;
+                                    char2 = replacement[i];
+                                }
+                                if (i === init_i) {
+                                    return (_ctx) => { throw new EastError(`invalid regex replacement string: empty group name in $<>`, { location: ir.value.arguments[3].value.location }); };
+                                }
+                                i += 1; // for closing >
+                            }
+                            else {
+                                return (_ctx) => { throw new EastError(`invalid regex replacement string: unescaped $ at $${char2}`, { location: ir.value.arguments[3].value.location }); };
+                            }
+                        }
+                        else {
+                            i += char.length;
+                        }
+                    }
+                    return (ctx) => {
+                        const text = textArg(ctx);
+                        return text.replaceAll(compiledRegex, replacement);
+                    };
+                }
+                else {
+                    // PARTIAL OPTIMIZATION: Pattern and flags constant, replacement dynamic
+                    const replacementArg = args[3];
+                    return (ctx) => {
+                        const text = textArg(ctx);
+                        const replacement = replacementArg(ctx);
+                        // Validate replacement string: only allow $$, $1-$9, and $<
+                        // This is stricter than JavaScript's native behavior but provides clear, consistent semantics
+                        // and avoids backend-specific features like $&, $`, $'
+                        let i = 0;
+                        while (i < replacement.length) {
+                            const char = replacement[i];
+                            if (char === '$') {
+                                i += char.length;
+                                let char2 = replacement[i];
+                                if (char2 === undefined) {
+                                    throw new EastError(`invalid regex replacement string: unescaped $ at end of string`, { location: ir.value.arguments[3].value.location });
+                                }
+                                else if (char2 === '$') {
+                                    i += 1;
+                                }
+                                else if (char2 >= '1' && char2 <= '9') {
+                                    i += 1;
+                                    char2 = replacement[i];
+                                    while (char2 !== undefined && char2 >= '0' && char2 <= '9') {
+                                        i += 1;
+                                        char2 = replacement[i];
+                                    }
+                                }
+                                else if (char2 === '<') {
+                                    // Scan until closing >
+                                    i += 1;
+                                    const init_i = i;
+                                    char2 = replacement[i];
+                                    while (true) {
+                                        if (char2 === undefined) {
+                                            throw new EastError(`invalid regex replacement string: unterminated group name in $<...>`, { location: ir.value.arguments[3].value.location });
+                                        }
+                                        if (char2 === '>') {
+                                            break;
+                                        }
+                                        if (!((char2 >= '0' && char2 <= '9') || (char2 >= 'a' && char2 <= 'z') || (char2 >= 'A' && char2 <= 'Z') || char2 === '_')) {
+                                            throw new EastError(`invalid regex replacement string: invalid character ${JSON.stringify(char2)} in group name in $<...>`, { location: ir.value.arguments[3].value.location });
+                                        }
+                                        i += 1;
+                                        char2 = replacement[i];
+                                    }
+                                    if (i === init_i) {
+                                        throw new EastError(`invalid regex replacement string: empty group name in $<>`, { location: ir.value.arguments[3].value.location });
+                                    }
+                                    i += 1; // for closing >
+                                }
+                                else {
+                                    throw new EastError(`invalid regex replacement string: unescaped $ at $${char2}`, { location: ir.value.arguments[3].value.location });
+                                }
+                            }
+                            else {
+                                i += char.length;
+                            }
+                        }
+                        return text.replaceAll(compiledRegex, replacement);
+                    };
+                }
+            }
+        }
+        const evaluator = builtin_evaluators[ir.value.builtin](ir.value.location, ...ir.value.type_parameters);
+        if (argsAsync) {
+            return async (ctx) => {
+                const args_resolved = [];
+                for (const a of args) {
+                    args_resolved.push(await a(ctx));
+                }
+                return evaluator(...args_resolved);
+            };
+        }
+        else {
+            return (ctx) => evaluator(...args.map(a => a(ctx)));
+        }
+    }
+    else if (ir.type === "Platform") {
+        // TODO check types match (would require having the platform's expected types here)
+        let argsAsync = false;
+        const args = ir.value.arguments.map(a => {
+            if (a.value.isAsync) {
+                argsAsync = true;
+            }
+            return compile_internal(a, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        });
+        const evaluator = platform[ir.value.name];
+        if (evaluator === undefined) {
+            throw new Error(`Evaluator for platform function ${JSON.stringify(ir.value.name)} not found at ${printLocationValue(ir.value.location)}`);
+        }
+        if (argsAsync) {
+            return async (ctx) => {
+                const args_resolved = [];
+                for (const a of args) {
+                    args_resolved.push(await a(ctx));
+                }
+                return evaluator(...args_resolved);
+            };
+        }
+        else {
+            return (ctx) => evaluator(...args.map(a => a(ctx)));
+        }
+    }
+    else {
+        throw new Error(`Unhandled IR type ${ir.type} at ${printLocationValue(ir.value.location)}`); // The `satisfies never` here ensures that this branch is unreachable if all IR types are handled
+    }
+}
+/** Used to call a compiled function with the given arguments and handle errors within builtin functions */
+function call_function(location, compiled_f, ...args) {
+    try {
+        return compiled_f(...args);
+    }
+    catch (e) {
+        if (e instanceof ReturnException) {
+            return e.value;
+        }
+        else if (e instanceof EastError) {
+            e.location.push(location); // The fact that we need to push the call location not the definition location means we need to handle this here
+            throw (e);
+        }
+        else if (e instanceof ContinueException) {
+            throw new Error(`continue failed to find label ${e.label} at ${printLocationValue(location)}`);
+        }
+        else if (e instanceof BreakException) {
+            throw new Error(`break failed to find label ${e.label} at ${printLocationValue(location)}`);
+        }
+        else {
+            throw (e);
+        }
+    }
+}
+/** @internal */
+const builtin_evaluators = {
+    Is: (_location, T) => isFor(T),
+    Equal: (_location, T) => equalFor(T),
+    NotEqual: (_location, T) => notEqualFor(T),
+    Less: (_location, T) => lessFor(T),
+    LessEqual: (_location, T) => lessEqualFor(T),
+    Greater: (_location, T) => greaterFor(T),
+    GreaterEqual: (_location, T) => greaterEqualFor(T),
+    BooleanNot: (_location) => (x) => !x,
+    BooleanOr: (_location) => (x, y) => x || y,
+    BooleanAnd: (_location) => (x, y) => x && y,
+    BooleanXor: (_location) => (x, y) => x !== y,
+    IntegerToFloat: (_location) => (x) => Number(x),
+    IntegerNegate: (_location) => (x) => BigInt.asIntN(64, -x),
+    IntegerAdd: (_location) => (x, y) => BigInt.asIntN(64, x + y),
+    IntegerSubtract: (_location) => (x, y) => BigInt.asIntN(64, x - y),
+    IntegerMultiply: (_location) => (x, y) => BigInt.asIntN(64, x * y),
+    IntegerDivide: (_location) => (x, y) => x === 0n ? 0n : x / y,
+    IntegerRemainder: (_location) => (x, y) => x === 0n ? 0n : x % y,
+    IntegerPow: (_location) => (x, y) => y >= 0n ? BigInt.asIntN(64, x ** y) : 0n,
+    IntegerAbs: (_location) => (x) => BigInt.asIntN(64, x < 0n ? -x : x),
+    IntegerSign: (_location) => (x) => x > 0n ? 1n : x < 0n ? -1n : 0n,
+    IntegerLog: (_location) => (value, base) => {
+        if (value === 0n)
+            return 0n;
+        if (base <= 1n)
+            return 0n; // Invalid base
+        let abs_value = value < 0n ? -value : value;
+        let result = 0n;
+        while (abs_value >= base) {
+            abs_value = abs_value / base;
+            result = result + 1n;
+        }
+        return result;
+    },
+    FloatToInteger: (location) => (x) => {
+        if (Number.isNaN(x))
+            throw new EastError("Cannot convert NaN to integer", { location });
+        if (x >= 9223372036854775808)
+            throw new EastError("Float too high to convert to integer", { location });
+        if (x < -9223372036854775808)
+            throw new EastError("Float too low to convert to integer", { location });
+        if (!Number.isInteger(x)) {
+            throw new EastError("Cannot convert non-integer float to integer", { location });
+        }
+        return BigInt(x);
+    },
+    FloatNegate: (_location) => (x) => -x,
+    FloatAdd: (_location) => (x, y) => x + y,
+    FloatSubtract: (_location) => (x, y) => x - y,
+    FloatMultiply: (_location) => (x, y) => x * y,
+    FloatDivide: (_location) => (x, y) => x / y,
+    FloatRemainder: (_location) => (x, y) => x % y,
+    FloatPow: (_location) => (x, y) => x ** y,
+    FloatAbs: (_location) => (x) => x < 0 ? -x : x,
+    FloatSign: (_location) => (x) => x > 0 ? 1 : x < 0 ? -1 : 0, // What sign is NaN?
+    FloatSqrt: (_location) => (value) => Math.sqrt(value),
+    FloatLog: (_location) => (value) => Math.log(value),
+    FloatExp: (_location) => (value) => Math.exp(value),
+    FloatSin: (_location) => (value) => Math.sin(value),
+    FloatCos: (_location) => (value) => Math.cos(value),
+    FloatTan: (_location) => (value) => Math.tan(value),
+    Print: (_location, T) => {
+        return printFor(T);
+    },
+    Parse: (location, T) => {
+        const p = parseFor(T);
+        return (x) => {
+            const result = p(x);
+            if (result.success) {
+                return result.value;
+            }
+            else {
+                throw new EastError(`Failed to parse ${printTypeValue(T)} at ${result.position}: ${result.error}`, { location });
+            }
+        };
+    },
+    StringConcat: (_location) => (x, y) => x + y,
+    StringRepeat: (_location) => (x, y) => y > 0n ? x.repeat(Number(y)) : "",
+    StringLength: (_location) => (x) => {
+        let len = 0;
+        for (const _ of x)
+            len++;
+        return BigInt(len);
+    },
+    StringSubstring: (_location) => (x, from, to) => {
+        // Convert bigint indices to numbers, handle forgiving semantics like JavaScript
+        let fromNum = Number(from);
+        let toNum = Number(to);
+        // Handle negative indices and lengths (forgiving semantics)
+        if (fromNum < 0)
+            fromNum = 0;
+        if (toNum < 0)
+            toNum = 0;
+        if (fromNum > toNum) {
+            toNum = fromNum;
+        }
+        // Convert codepoint indices to code unit indices
+        let codeUnitFrom = 0;
+        let codeUnitTo = 0;
+        let codepointIndex = 0;
+        for (const char of x) {
+            if (codepointIndex === fromNum) {
+                codeUnitFrom = codeUnitTo;
+            }
+            if (codepointIndex === toNum) {
+                break;
+            }
+            codeUnitTo += char.length;
+            codepointIndex++;
+        }
+        // If 'from' is beyond string length, return empty string
+        if (fromNum >= codepointIndex)
+            return "";
+        // If 'to' is beyond string length, use string end
+        if (toNum > codepointIndex) {
+            codeUnitTo = x.length;
+        }
+        return x.substring(codeUnitFrom, codeUnitTo);
+    },
+    StringUpperCase: (_location) => (x) => x.toUpperCase(),
+    StringLowerCase: (_location) => (x) => x.toLowerCase(),
+    StringSplit: (_location) => (x, delimiter) => {
+        if (delimiter === "") {
+            if (x === "") {
+                // Split always returns at least one element
+                return [""];
+            }
+            else {
+                // Split into individual codepoints
+                return [...x];
+            }
+        }
+        return x.split(delimiter);
+    },
+    StringTrim: (_location) => (x) => x.trim(),
+    StringTrimStart: (_location) => (x) => x.trimStart(),
+    StringTrimEnd: (_location) => (x) => x.trimEnd(),
+    StringStartsWith: (_location) => (x, prefix) => x.startsWith(prefix),
+    StringEndsWith: (_location) => (x, suffix) => x.endsWith(suffix),
+    StringContains: (_location) => (x, substring) => x.includes(substring),
+    StringIndexOf: (_location) => (x, substring) => {
+        const codeUnitIndex = x.indexOf(substring);
+        if (codeUnitIndex === -1)
+            return -1n;
+        // Special case for empty substring - it's always found at position 0
+        if (substring === "")
+            return BigInt(codeUnitIndex);
+        // Convert code unit index to codepoint index
+        let codepointIndex = 0;
+        let codeUnitPos = 0;
+        for (const char of x) {
+            if (codeUnitPos === codeUnitIndex) {
+                return BigInt(codepointIndex);
+            }
+            codeUnitPos += char.length;
+            codepointIndex++;
+        }
+        return -1n;
+    },
+    StringReplace: (_location) => (x, searchValue, replaceValue) => {
+        // Replace all occurrences (like JavaScript's string.replaceAll with string)
+        return x.replaceAll(searchValue, replaceValue);
+    },
+    RegexContains: (_location) => (text, pattern, flags) => {
+        const regex = new RegExp(pattern, flags);
+        return regex.test(text);
+    },
+    RegexIndexOf: (_location) => (text, pattern, flags) => {
+        const regex = new RegExp(pattern, flags);
+        const codeUnitIndex = text.search(regex);
+        if (codeUnitIndex === -1)
+            return -1n;
+        // Convert code unit index to codepoint index
+        let codepointIndex = 0;
+        let codeUnitPos = 0;
+        for (const char of text) {
+            if (codeUnitPos === codeUnitIndex) {
+                return BigInt(codepointIndex);
+            }
+            codeUnitPos += char.length;
+            codepointIndex++;
+        }
+        return -1n;
+    },
+    RegexReplace: (location) => (text, pattern, flags, replacement) => {
+        // Ensure global flag is set for replaceAll semantics
+        const globalFlags = flags.includes('g') ? flags : flags + 'g';
+        const regex = new RegExp(pattern, globalFlags);
+        // Validate replacement string: only allow $$, $1-$9, and $<
+        // This is stricter than JavaScript's native behavior but provides clear, consistent semantics
+        // and avoids backend-specific features like $&, $`, $'
+        let i = 0;
+        while (i < replacement.length) {
+            const char = replacement[i];
+            if (char === '$') {
+                i += char.length;
+                let char2 = replacement[i];
+                if (char2 === undefined) {
+                    throw new EastError(`invalid regex replacement string: unescaped $ at end of string`, { location });
+                }
+                else if (char2 === '$') {
+                    i += 1;
+                }
+                else if (char2 >= '1' && char2 <= '9') {
+                    i += 1;
+                    char2 = replacement[i];
+                    while (char2 !== undefined && char2 >= '0' && char2 <= '9') {
+                        i += 1;
+                        char2 = replacement[i];
+                    }
+                }
+                else if (char2 === '<') {
+                    // Scan until closing >
+                    i += 1;
+                    const init_i = i;
+                    char2 = replacement[i];
+                    while (true) {
+                        if (char2 === undefined) {
+                            throw new EastError(`invalid regex replacement string: unterminated group name in $<...>`, { location });
+                        }
+                        if (char2 === '>') {
+                            break;
+                        }
+                        if (!((char2 >= '0' && char2 <= '9') || (char2 >= 'a' && char2 <= 'z') || (char2 >= 'A' && char2 <= 'Z') || char2 === '_')) {
+                            throw new EastError(`invalid regex replacement string: invalid character ${JSON.stringify(char2)} in group name in $<...>`, { location });
+                        }
+                        i += 1;
+                        char2 = replacement[i];
+                    }
+                    if (i === init_i) {
+                        throw new EastError(`invalid regex replacement string: empty group name in $<>`, { location });
+                    }
+                    i += 1; // for closing >
+                }
+                else {
+                    throw new EastError(`invalid regex replacement string: unescaped $ at $${char2}`, { location });
+                }
+            }
+            else {
+                i += char.length;
+            }
+        }
+        return text.replaceAll(regex, replacement);
+    },
+    StringEncodeUtf8: (_location) => {
+        // do not add BOM for UTF-8
+        const encoder = new TextEncoder();
+        return (x) => {
+            return encoder.encode(x);
+        };
+    },
+    StringEncodeUtf16: (_location) => {
+        // always use little-endian with BOM (most common in practice)
+        return (x) => {
+            const buffer = new BufferWriter();
+            buffer.writeUint8(0xFF);
+            buffer.writeUint8(0xFE);
+            for (let i = 0; i < x.length; i++) {
+                const codeUnit = x.charCodeAt(i);
+                buffer.writeUint16LE(codeUnit);
+            }
+            return buffer.toUint8Array();
+        };
+    },
+    StringParseJSON: (location, type) => {
+        const fromJSON = fromJSONFor(type);
+        return (x) => {
+            let parsed;
+            try {
+                parsed = JSON.parse(x);
+            }
+            catch (e) {
+                throw new EastError(`Failed to parse JSON: ${e.message}`, { location });
+            }
+            try {
+                return fromJSON(parsed);
+            }
+            catch (e) {
+                throw new EastError(`Failed to convert JSON to ${printTypeValue(type)}: ${e.message}`, { location });
+            }
+        };
+    },
+    StringPrintJSON: (_location, type) => {
+        const toJSON = toJSONFor(type);
+        return (x) => JSON.stringify(toJSON(x));
+    },
+    DateTimeGetYear: (_location) => (date) => BigInt(date.getUTCFullYear()),
+    DateTimeGetMonth: (_location) => (date) => BigInt(date.getUTCMonth() + 1), // JavaScript months are 0-based, East uses 1-based
+    DateTimeGetDayOfMonth: (_location) => (date) => BigInt(date.getUTCDate()),
+    DateTimeGetHour: (_location) => (date) => BigInt(date.getUTCHours()),
+    DateTimeGetMinute: (_location) => (date) => BigInt(date.getUTCMinutes()),
+    DateTimeGetSecond: (_location) => (date) => BigInt(date.getUTCSeconds()),
+    DateTimeGetDayOfWeek: (_location) => (date) => {
+        const jsDay = date.getUTCDay(); // JavaScript: 0=Sunday, 1=Monday, ..., 6=Saturday
+        return BigInt(jsDay === 0 ? 7 : jsDay); // ISO 8601: 1=Monday, 2=Tuesday, ..., 7=Sunday
+    },
+    DateTimeGetMillisecond: (_location) => (date) => BigInt(date.getUTCMilliseconds()),
+    DateTimeAddMilliseconds: (_location) => (date, milliseconds) => new Date(date.getTime() + Number(milliseconds)),
+    DateTimeDurationMilliseconds: (_location) => (date1, date2) => BigInt(date1.getTime() - date2.getTime()),
+    DateTimeToEpochMilliseconds: (_location) => (date) => BigInt(date.getTime()),
+    DateTimeFromEpochMilliseconds: (_location) => (milliseconds) => new Date(Number(milliseconds)),
+    DateTimeFromComponents: (_location) => (year, month, day, hour, minute, second, millisecond) => new Date(Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second), Number(millisecond))),
+    DateTimePrintFormat: (_location) => (date, tokens) => {
+        return formatDateTime(date, tokens);
+    },
+    DateTimeParseFormat: (location) => (str, tokens) => {
+        const result = parseDateTimeFormatted(str, tokens);
+        if (result.success) {
+            return result.value;
+        }
+        else {
+            throw new EastError(`Failed to parse datetime at position ${result.position}: ${result.error}`, { location });
+        }
+    },
+    BlobSize: (_location) => (data) => BigInt(data.length),
+    BlobGetUint8: (location) => (data, index) => {
+        const i = Number(index);
+        if (i < 0 || i >= data.length) {
+            throw new EastError(`Blob index ${index} out of bounds`, { location });
+        }
+        else {
+            return BigInt(data[i]);
+        }
+    },
+    BlobDecodeUtf8: (location) => {
+        const decoder = new TextDecoder('utf-8', { fatal: true });
+        return (data) => {
+            try {
+                return decoder.decode(data);
+            }
+            catch {
+                throw new EastError("Blob is not valid UTF-8", { location });
+            }
+        };
+    },
+    BlobDecodeUtf16: (location) => {
+        const decoder_be = new TextDecoder('utf-16be', { fatal: true });
+        const decoder_le = new TextDecoder('utf-16le', { fatal: true });
+        return (data) => {
+            try {
+                if (data.length >= 2) {
+                    // Check for BOM
+                    if (data[0] === 0xFE && data[1] === 0xFF) {
+                        // Big-endian BOM
+                        return decoder_be.decode(data.subarray(2));
+                    }
+                    else if (data[0] === 0xFF && data[1] === 0xFE) {
+                        // Little-endian BOM
+                        return decoder_le.decode(data.subarray(2));
+                    }
+                }
+                // No BOM, default to little-endian (not unicode spec compliant, but more common in practice)
+                return decoder_le.decode(data);
+            }
+            catch {
+                throw new EastError("Blob is not valid UTF-16", { location });
+            }
+        };
+    },
+    BlobEncodeBeast: (_location, type) => {
+        const encodeBeast = encodeBeastFor(type);
+        return (value) => {
+            return encodeBeast(value);
+        };
+    },
+    BlobDecodeBeast: (location, type) => {
+        const decodeBeast = decodeBeastFor(type);
+        return (data) => {
+            try {
+                return decodeBeast(data);
+            }
+            catch (e) {
+                throw new EastError(`Failed to decode Beast data: ${e.message}`, { location });
+            }
+        };
+    },
+    BlobEncodeBeast2: (_location, type) => {
+        const encodeBeast2 = encodeBeast2For(type);
+        return (value) => {
+            return encodeBeast2(value);
+        };
+    },
+    BlobDecodeBeast2: (location, type) => {
+        const decodeBeast2 = decodeBeast2For(type);
+        return (data) => {
+            try {
+                return decodeBeast2(data);
+            }
+            catch (e) {
+                throw new EastError(`Failed to decode Beast2 data: ${e.message}`, { location });
+            }
+        };
+    },
+    RefGet: (_location, _T) => (ref) => {
+        return ref.value;
+    },
+    RefUpdate: (location, _T) => (ref, value) => {
+        if (Object.isFrozen(ref)) {
+            throw new EastError("Cannot modify frozen Ref", { location });
+        }
+        ref.value = value;
+        return null;
+    },
+    RefMerge: (location, _T) => (ref, value, merger) => {
+        if (Object.isFrozen(ref)) {
+            throw new EastError("Cannot modify frozen Ref", { location });
+        }
+        const new_value = call_function(location, merger, ref.value, value);
+        ref.value = new_value;
+        return null;
+    },
+    ArrayGenerate: (location, _T) => (size, f) => {
+        const result = [];
+        for (let i = 0n; i < size; i += 1n) {
+            const v = call_function(location, f, i);
+            result.push(v);
+        }
+        return result;
+    },
+    ArrayRange: (_location) => (start, end, step) => {
+        const result = [];
+        if (step === 0n) {
+            return result; // empty array
+        }
+        else if (step > 0n) {
+            for (let i = start; i < end; i += step) {
+                result.push(i);
+            }
+        }
+        else { // step < 0
+            for (let i = start; i > end; i += step) {
+                result.push(i);
+            }
+        }
+        return result;
+    },
+    ArrayLinspace: (_location) => (start, end, size) => {
+        const result = [];
+        if (size <= 0n) {
+            return result; // empty array
+        }
+        else if (size === 1n) {
+            return [start];
+        }
+        else {
+            const step = (end - start) / Number(size - 1n);
+            for (let i = 0n; i < size; i += 1n) {
+                result.push(start + Number(i) * step);
+            }
+        }
+        return result;
+    },
+    ArraySize: (_location, _T) => (array) => BigInt(array.length),
+    ArrayHas: (_location, _T) => (array, key) => {
+        const i = Number(key);
+        return i >= 0 && i < array.length;
+    },
+    ArrayGet: (location, _T) => (array, key) => {
+        const i = Number(key);
+        if (i < 0 || i >= array.length) {
+            throw new EastError(`Array index ${key} out of bounds`, { location });
+        }
+        else {
+            return array[i];
+        }
+    },
+    ArrayGetOrDefault: (location, _T) => (array, key, defaultFn) => {
+        const i = Number(key);
+        if (i < 0 || i >= array.length) {
+            return call_function(location, defaultFn, key);
+        }
+        else {
+            return array[i];
+        }
+    },
+    ArrayTryGet: (_location, _T) => (array, key) => {
+        const i = Number(key);
+        if (i < 0 || i >= array.length) {
+            return variant("none", null);
+        }
+        else {
+            return variant("some", array[i]);
+        }
+    },
+    ArrayUpdate: (location, _T) => (array, key, value) => {
+        if (Object.isFrozen(array)) {
+            throw new EastError("Cannot modify frozen Array", { location });
+        }
+        const i = Number(key);
+        if (i < 0 || i >= array.length) {
+            throw new EastError(`Array index ${key} out of bounds`, { location });
+        }
+        else {
+            array[i] = value;
+            return null;
+        }
+    },
+    ArrayMerge: (location, _T) => (array, key, value, merger) => {
+        if (Object.isFrozen(array)) {
+            throw new EastError("Cannot modify frozen Array", { location });
+        }
+        const i = Number(key);
+        if (i < 0 || i >= array.length) {
+            throw new EastError(`Array index ${key} out of bounds`, { location });
+        }
+        else {
+            const new_value = call_function(location, merger, array[i], value, key);
+            array[i] = new_value;
+            return null;
+        }
+    },
+    ArrayPushLast: (location, _T) => (array, value) => {
+        if (Object.isFrozen(array)) {
+            throw new EastError("Cannot modify frozen Array", { location });
+        }
+        if ((iterationLocks.get(array) || 0) > 0) {
+            throw new EastError("Cannot modify Array during iteration", { location });
+        }
+        array.push(value);
+        return null;
+    },
+    ArrayPopLast: (location, _T) => (array) => {
+        if (Object.isFrozen(array)) {
+            throw new EastError("Cannot modify frozen Array", { location });
+        }
+        if ((iterationLocks.get(array) || 0) > 0) {
+            throw new EastError("Cannot modify Array during iteration", { location });
+        }
+        if (array.length === 0) {
+            throw new EastError("Cannot pop from empty Array", { location });
+        }
+        else {
+            return array.pop();
+        }
+    },
+    ArrayPushFirst: (location, _T) => (array, value) => {
+        if (Object.isFrozen(array)) {
+            throw new EastError("Cannot modify frozen Array", { location });
+        }
+        if ((iterationLocks.get(array) || 0) > 0) {
+            throw new EastError("Cannot modify Array during iteration", { location });
+        }
+        array.unshift(value);
+        return null;
+    },
+    ArrayPopFirst: (location, _T) => (array) => {
+        if (Object.isFrozen(array)) {
+            throw new EastError("Cannot modify frozen Array", { location });
+        }
+        if ((iterationLocks.get(array) || 0) > 0) {
+            throw new EastError("Cannot modify Array during iteration", { location });
+        }
+        if (array.length === 0) {
+            throw new EastError("Cannot pop from empty Array", { location });
+        }
+        else {
+            return array.shift();
+        }
+    },
+    ArrayAppend: (location, _T) => (array, other) => {
+        if (Object.isFrozen(array)) {
+            throw new EastError("Cannot modify frozen Array", { location });
+        }
+        if ((iterationLocks.get(array) || 0) > 0) {
+            throw new EastError("Cannot modify Array during iteration", { location });
+        }
+        array.push(...other);
+        return null;
+    },
+    ArrayPrepend: (location, _T) => (array, other) => {
+        if (Object.isFrozen(array)) {
+            throw new EastError("Cannot modify frozen Array", { location });
+        }
+        if ((iterationLocks.get(array) || 0) > 0) {
+            throw new EastError("Cannot modify Array during iteration", { location });
+        }
+        array.unshift(...other);
+        return null;
+    },
+    ArrayMergeAll: (location, _T, _T2) => (array, other, merger) => {
+        if (Object.isFrozen(array)) {
+            throw new EastError("Cannot modify frozen Array", { location });
+        }
+        lockForIteration(array);
+        lockForIteration(other);
+        try {
+            for (let i = 0; i < other.length; i++) {
+                const key = BigInt(i);
+                if (i < array.length) {
+                    const new_value = call_function(location, merger, array[i], other[i], key);
+                    array[i] = new_value;
+                }
+                else {
+                    throw new EastError(`Array index ${key} out of bounds`, { location });
+                }
+            }
+        }
+        finally {
+            unlockForIteration(other);
+            unlockForIteration(array);
+        }
+        return null;
+    },
+    ArrayClear: (location, _T) => (array) => {
+        if (Object.isFrozen(array)) {
+            throw new EastError("Cannot modify frozen Array", { location });
+        }
+        if ((iterationLocks.get(array) || 0) > 0) {
+            throw new EastError("Cannot modify Array during iteration", { location });
+        }
+        array.length = 0;
+        return null;
+    },
+    ArraySortInPlace: (location, T, T2) => (array, by) => {
+        if (Object.isFrozen(array)) {
+            throw new EastError("Cannot modify frozen Array", { location });
+        }
+        if ((iterationLocks.get(array) || 0) > 0) {
+            throw new EastError("Cannot modify Array during iteration", { location });
+        }
+        lockForIteration(array);
+        try {
+            const cmp = compareFor(T2);
+            array.sort((a, b) => {
+                const projectedA = call_function(location, by, a);
+                const projectedB = call_function(location, by, b);
+                return cmp(projectedA, projectedB);
+            });
+        }
+        finally {
+            unlockForIteration(array);
+        }
+        return null;
+    },
+    ArrayReverseInPlace: (location, _T) => (array) => {
+        if (Object.isFrozen(array)) {
+            throw new EastError("Cannot modify frozen Array", { location });
+        }
+        if ((iterationLocks.get(array) || 0) > 0) {
+            throw new EastError("Cannot modify Array during iteration", { location });
+        }
+        array.reverse();
+        return null;
+    },
+    ArraySort: (location, T, T2) => (array, by) => {
+        const cmp = compareFor(T2);
+        const newArray = [...array];
+        newArray.sort((a, b) => {
+            const projectedA = call_function(location, by, a);
+            const projectedB = call_function(location, by, b);
+            return cmp(projectedA, projectedB);
+        });
+        return newArray;
+    },
+    ArrayReverse: (_location, _T) => (array) => {
+        const newArray = [...array];
+        newArray.reverse();
+        return newArray;
+    },
+    ArrayIsSorted: (location, T, T2) => {
+        const cmp = compareFor(T2);
+        return (array, by) => {
+            if (array.length < 2)
+                return true;
+            lockForIteration(array);
+            try {
+                let projectedPrev = call_function(location, by, array[0]);
+                for (let i = 1; i < array.length; i++) {
+                    const projectedCurr = call_function(location, by, array[i]);
+                    if (cmp(projectedPrev, projectedCurr) > 0) {
+                        return false;
+                    }
+                    projectedPrev = projectedCurr;
+                }
+            }
+            finally {
+                unlockForIteration(array);
+            }
+            return true;
+        };
+    },
+    ArrayFindSortedFirst: (location, T, T2) => {
+        const cmp = compareFor(T2);
+        return (array, key, by) => {
+            let low = 0;
+            let high = array.length;
+            lockForIteration(array);
+            try {
+                while (low < high) {
+                    const mid = Math.floor((low + high) / 2);
+                    const projectedMid = call_function(location, by, array[mid]);
+                    if (cmp(projectedMid, key) < 0) {
+                        low = mid + 1;
+                    }
+                    else {
+                        high = mid;
+                    }
+                }
+            }
+            finally {
+                unlockForIteration(array);
+            }
+            return BigInt(low);
+        };
+    },
+    ArrayFindSortedLast: (location, T, T2) => {
+        const cmp = compareFor(T2);
+        return (array, key, by) => {
+            let low = 0;
+            let high = array.length;
+            lockForIteration(array);
+            try {
+                while (low < high) {
+                    const mid = Math.floor((low + high) / 2);
+                    const projectedMid = call_function(location, by, array[mid]);
+                    if (cmp(projectedMid, key) <= 0) {
+                        low = mid + 1;
+                    }
+                    else {
+                        high = mid;
+                    }
+                }
+            }
+            finally {
+                unlockForIteration(array);
+            }
+            return BigInt(low);
+        };
+    },
+    ArrayFindSortedRange: (location, T, T2) => {
+        const cmp = compareFor(T2);
+        return (array, key, by) => {
+            let lo = -1;
+            let hi = array.length;
+            lockForIteration(array);
+            try {
+                // Main search loop - find any equal element or determine the range doesn't exist
+                while (lo < hi - 1) {
+                    const mid = Math.floor((lo + hi) / 2);
+                    const projectedMid = call_function(location, by, array[mid]);
+                    const cmpResult = cmp(projectedMid, key);
+                    if (cmpResult < 0) {
+                        lo = mid;
+                    }
+                    else if (cmpResult > 0) {
+                        hi = mid;
+                    }
+                    else {
+                        // Found an equal element! Now find the first and last positions
+                        // within the constrained range
+                        // Find first position in range [max(lo, -1), mid]
+                        let firstLo = Math.max(lo, -1);
+                        let firstHi = mid + 1;
+                        while (firstLo < firstHi - 1) {
+                            const firstMid = Math.floor((firstLo + firstHi) / 2);
+                            const projectedFirst = call_function(location, by, array[firstMid]);
+                            if (cmp(projectedFirst, key) < 0) {
+                                firstLo = firstMid;
+                            }
+                            else {
+                                firstHi = firstMid;
+                            }
+                        }
+                        // Find last position in range [mid, min(hi, array.length)]
+                        let lastLo = mid - 1;
+                        let lastHi = Math.min(hi, array.length);
+                        while (lastLo < lastHi - 1) {
+                            const lastMid = Math.floor((lastLo + lastHi) / 2);
+                            const projectedLast = call_function(location, by, array[lastMid]);
+                            if (cmp(projectedLast, key) <= 0) {
+                                lastLo = lastMid;
+                            }
+                            else {
+                                lastHi = lastMid;
+                            }
+                        }
+                        return { start: BigInt(firstLo + 1), end: BigInt(lastLo + 1) };
+                    }
+                }
+            }
+            finally {
+                unlockForIteration(array);
+            }
+            // No equal element found - return empty range
+            return { start: BigInt(lo + 1), end: BigInt(lo + 1) };
+        };
+    },
+    ArrayFindFirst: (location, T, T2) => {
+        const cmp = compareFor(T2);
+        return (array, value, by) => {
+            lockForIteration(array);
+            try {
+                for (let i = 0; i < array.length; i++) {
+                    const projected = call_function(location, by, array[i]);
+                    if (cmp(projected, value) === 0) {
+                        return variant("some", BigInt(i));
+                    }
+                }
+                return variant("none", null);
+            }
+            finally {
+                unlockForIteration(array);
+            }
+        };
+    },
+    ArrayConcat: (_location, _T) => (a1, a2) => {
+        return [...a1, ...a2];
+    },
+    ArraySlice: (_location, _T) => (array, start, end) => {
+        const startNum = Number(start);
+        const endNum = Number(end);
+        return array.slice(startNum, endNum);
+    },
+    ArrayGetKeys: (location, _T) => (array, keys, onMissing) => {
+        return keys.map(k => {
+            const i = Number(k);
+            if (i < 0 || i >= array.length) {
+                return call_function(location, onMissing, k);
+            }
+            else {
+                return array[i];
+            }
+        });
+    },
+    ArrayForEach: (location, _T, _T2) => (array, f) => {
+        lockForIteration(array);
+        try {
+            array.forEach((x, i) => {
+                return call_function(location, f, x, BigInt(i));
+            });
+            return null;
+        }
+        finally {
+            unlockForIteration(array);
+        }
+    },
+    ArrayCopy: (_location, _T) => (array) => {
+        return [...array];
+    },
+    ArrayMap: (location, _T, _T2) => (array, f) => {
+        lockForIteration(array);
+        try {
+            return array.map((x, i) => {
+                return call_function(location, f, x, BigInt(i));
+            });
+        }
+        finally {
+            unlockForIteration(array);
+        }
+    },
+    ArrayFilter: (location, _T, _T2) => (array, f) => {
+        lockForIteration(array);
+        try {
+            return array.filter((x, i) => {
+                return call_function(location, f, x, BigInt(i));
+            });
+        }
+        finally {
+            unlockForIteration(array);
+        }
+    },
+    ArrayFilterMap: (location, _T, _T2) => (array, f) => {
+        lockForIteration(array);
+        try {
+            const result = [];
+            for (let i = 0; i < array.length; i++) {
+                const v = call_function(location, f, array[i], BigInt(i));
+                if (v.type === "some") {
+                    result.push(v.value);
+                }
+            }
+            return result;
+        }
+        finally {
+            unlockForIteration(array);
+        }
+    },
+    ArrayFirstMap: (location, _T, _T2) => (array, f) => {
+        lockForIteration(array);
+        try {
+            for (let i = 0; i < array.length; i++) {
+                const v = call_function(location, f, array[i], BigInt(i));
+                if (v.type === "some") {
+                    return v;
+                }
+            }
+            return variant("none", null);
+        }
+        finally {
+            unlockForIteration(array);
+        }
+    },
+    ArrayFold: (location, _T, _T2) => (array, init, f) => {
+        lockForIteration(array);
+        try {
+            return array.reduce((acc, x, i) => {
+                return call_function(location, f, acc, x, BigInt(i));
+            }, init);
+        }
+        finally {
+            unlockForIteration(array);
+        }
+    },
+    ArrayMapReduce: (location, _T, _T2) => (array, mapFn, reduceFn) => {
+        if (array.length === 0) {
+            throw new EastError("Cannot reduce empty array with no initial value", { location });
+        }
+        lockForIteration(array);
+        try {
+            let acc = call_function(location, mapFn, array[0], 0n);
+            for (let i = 1; i < array.length; i++) {
+                const mapped = call_function(location, mapFn, array[i], BigInt(i));
+                acc = call_function(location, reduceFn, acc, mapped);
+            }
+            return acc;
+        }
+        finally {
+            unlockForIteration(array);
+        }
+    },
+    ArrayStringJoin: (_location) => (x, y) => x.join(y),
+    ArrayToSet: (location, _T, T2) => {
+        const compare = compareFor(T2);
+        return (array, f) => {
+            lockForIteration(array);
+            try {
+                const result = new SortedSet([], compare);
+                for (let i = 0; i < array.length; i++) {
+                    const v = call_function(location, f, array[i], BigInt(i));
+                    result.add(v);
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(array);
+            }
+        };
+    },
+    ArrayToDict: (location, _T, K2, _T2) => {
+        const compare = compareFor(K2);
+        return (array, keyFn, valueFn, onConflict) => {
+            const result = new SortedMap([], compare);
+            lockForIteration(array);
+            try {
+                for (let i = 0; i < array.length; i++) {
+                    const v = array[i];
+                    const k = call_function(location, keyFn, v, BigInt(i));
+                    let val = call_function(location, valueFn, v, BigInt(i));
+                    const existing = result.get(k);
+                    if (existing === undefined) {
+                        result.set(k, val);
+                    }
+                    else {
+                        val = call_function(location, onConflict, existing, val, k);
+                        result.set(k, val);
+                    }
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(array);
+            }
+        };
+    },
+    ArrayFlattenToArray: (location, _T) => (array, fn) => {
+        return array.flatMap(v => {
+            return call_function(location, fn, v);
+        });
+    },
+    ArrayFlattenToSet: (location, _T, K2) => {
+        const compare = compareFor(K2);
+        return (array, fn) => {
+            const result = new SortedSet([], compare);
+            lockForIteration(array);
+            try {
+                for (const v of array) {
+                    const subset = call_function(location, fn, v);
+                    for (const k of subset) {
+                        result.add(k);
+                    }
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(array);
+            }
+        };
+    },
+    ArrayFlattenToDict: (location, _T, K2, _T2) => {
+        const compare = compareFor(K2);
+        return (array, fn, onConflict) => {
+            const result = new SortedMap([], compare);
+            lockForIteration(array);
+            try {
+                for (const v of array) {
+                    const subdict = call_function(location, fn, v);
+                    for (const [k, val] of subdict.entries()) {
+                        const existing = result.get(k);
+                        if (existing === undefined) {
+                            result.set(k, val);
+                        }
+                        else {
+                            const new_val = call_function(location, onConflict, existing, val, k);
+                            result.set(k, new_val);
+                        }
+                    }
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(array);
+            }
+        };
+    },
+    ArrayGroupFold: (location, _T, K2, _V2) => {
+        const compare = compareFor(K2);
+        return (array, keyFn, init, folder) => {
+            const result = new SortedMap([], compare);
+            lockForIteration(array);
+            try {
+                for (let i = 0; i < array.length; i++) {
+                    const v = array[i];
+                    const k = call_function(location, keyFn, v, BigInt(i));
+                    let existing = result.get(k);
+                    if (existing === undefined) {
+                        existing = call_function(location, init, k);
+                    }
+                    const new_val = call_function(location, folder, existing, v, BigInt(i));
+                    result.set(k, new_val);
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(array);
+            }
+        };
+    },
+    SetGenerate: (location, K) => {
+        const keyComparer = compareFor(K);
+        return (size, keyFn, onConflict) => {
+            const result = new SortedSet([], keyComparer);
+            for (let i = 0n; i < size; i += 1n) {
+                const k = call_function(location, keyFn, i);
+                if (result.has(k)) {
+                    call_function(location, onConflict, k);
+                }
+                else {
+                    result.add(k);
+                }
+            }
+            return result;
+        };
+    },
+    SetSize: (_location, _K) => (s) => BigInt(s.size),
+    SetHas: (_location, _K) => (s, key) => s.has(key),
+    SetInsert: (location, K) => {
+        const print = printFor(K);
+        return (s, key) => {
+            if (Object.isFrozen(s)) {
+                throw new EastError("Cannot modify frozen Set", { location });
+            }
+            if ((iterationLocks.get(s) || 0) > 0) {
+                throw new EastError("Cannot modify Set during iteration", { location });
+            }
+            const size_before = s.size;
+            s.add(key);
+            if (s.size === size_before) {
+                throw new EastError(`Set already contains key ${print(key)}`, { location });
+            }
+            return null;
+        };
+    },
+    SetTryInsert: (location, _K) => (s, key) => {
+        if (Object.isFrozen(s)) {
+            throw new EastError("Cannot modify frozen Set", { location });
+        }
+        if ((iterationLocks.get(s) || 0) > 0) {
+            throw new EastError("Cannot modify Set during iteration", { location });
+        }
+        const size_before = s.size;
+        s.add(key);
+        return s.size > size_before;
+    },
+    SetDelete: (location, K) => {
+        const print = printFor(K);
+        return (s, key) => {
+            if (Object.isFrozen(s)) {
+                throw new EastError("Cannot modify frozen Set", { location });
+            }
+            if ((iterationLocks.get(s) || 0) > 0) {
+                throw new EastError("Cannot modify Set during iteration", { location });
+            }
+            if (!s.delete(key)) {
+                throw new EastError(`Set does not contain key ${print(key)}`, { location });
+            }
+            return null;
+        };
+    },
+    SetTryDelete: (location, _K) => (s, key) => {
+        if (Object.isFrozen(s)) {
+            throw new EastError("Cannot modify frozen Set", { location });
+        }
+        if ((iterationLocks.get(s) || 0) > 0) {
+            throw new EastError("Cannot modify Set during iteration", { location });
+        }
+        return s.delete(key);
+    },
+    SetClear: (location, _K) => (s) => {
+        if (Object.isFrozen(s)) {
+            throw new EastError("Cannot modify frozen Set", { location });
+        }
+        if ((iterationLocks.get(s) || 0) > 0) {
+            throw new EastError("Cannot modify Set during iteration", { location });
+        }
+        s.clear();
+        return null;
+    },
+    SetUnionInPlace: (location, _K) => (s1, s2) => {
+        if (Object.isFrozen(s1)) {
+            throw new EastError("Cannot modify frozen Set", { location });
+        }
+        if ((iterationLocks.get(s1) || 0) > 0) {
+            throw new EastError("Cannot modify Set during iteration", { location });
+        }
+        s2.forEach(v => s1.add(v));
+        return null;
+    },
+    SetUnion: (_location, _K) => (s1, s2) => s1.union(s2),
+    SetIntersect: (_location, _K) => (s1, s2) => s1.intersection(s2),
+    SetDiff: (_location, _K) => (s1, s2) => s1.difference(s2),
+    SetSymDiff: (_location, _K) => (s1, s2) => s1.symmetricDifference(s2),
+    SetIsSubset: (_location, _K) => (s1, s2) => s1.isSubsetOf(s2),
+    SetIsDisjoint: (_location, _K) => (s1, s2) => s1.isDisjointFrom(s2),
+    SetCopy: (_location, K) => {
+        const compare = compareFor(K);
+        return (s) => {
+            return new SortedSet([...s], compare);
+        };
+    },
+    SetForEach: (location, _K, _T2) => (s, f) => {
+        lockForIteration(s);
+        try {
+            s.forEach(x => {
+                call_function(location, f, x);
+            });
+            return null;
+        }
+        finally {
+            unlockForIteration(s);
+        }
+    },
+    SetFilter: (location, K) => {
+        const compare = compareFor(K);
+        return (s, f) => {
+            const result = new SortedSet([], compare);
+            lockForIteration(s);
+            try {
+                s.forEach(x => {
+                    const keep = call_function(location, f, x);
+                    if (keep) {
+                        result.add(x);
+                    }
+                });
+                return result;
+            }
+            finally {
+                unlockForIteration(s);
+            }
+        };
+    },
+    SetFilterMap: (location, K, _V2) => {
+        const compare = compareFor(K);
+        return (s, f) => {
+            const result = new SortedMap([], compare);
+            lockForIteration(s);
+            try {
+                s.forEach(k => {
+                    const v2 = call_function(location, f, k);
+                    if (v2.type === "some") {
+                        result.set(k, v2.value);
+                    }
+                });
+                return result;
+            }
+            finally {
+                unlockForIteration(s);
+            }
+        };
+    },
+    SetFirstMap: (location, _K, _T2) => (s, f) => {
+        lockForIteration(s);
+        try {
+            for (const k of s) {
+                const v = call_function(location, f, k);
+                if (v.type === "some") {
+                    return v;
+                }
+            }
+            return variant("none", null);
+        }
+        finally {
+            unlockForIteration(s);
+        }
+    },
+    SetMapReduce: (location, _K, _T2) => (s, mapFn, reduceFn) => {
+        if (s.size === 0) {
+            throw new EastError("Cannot reduce empty set with no initial value", { location });
+        }
+        lockForIteration(s);
+        try {
+            const iterator = s[Symbol.iterator]();
+            const first = iterator.next().value;
+            let acc = call_function(location, mapFn, first);
+            for (const k of iterator) {
+                const mapped = call_function(location, mapFn, k);
+                acc = call_function(location, reduceFn, acc, mapped);
+            }
+            return acc;
+        }
+        finally {
+            unlockForIteration(s);
+        }
+    },
+    SetMap: (location, K, _T2) => {
+        const compare = compareFor(K);
+        return (s, f) => {
+            const result = new SortedMap([], compare);
+            lockForIteration(s);
+            try {
+                s.forEach(x => {
+                    const v = call_function(location, f, x);
+                    result.set(x, v);
+                });
+                return result;
+            }
+            finally {
+                unlockForIteration(s);
+            }
+        };
+    },
+    SetReduce: (location, _K, _T2) => (s, f, init) => {
+        let acc = init;
+        lockForIteration(s);
+        try {
+            for (const x of s) {
+                acc = call_function(location, f, acc, x);
+            }
+            return acc;
+        }
+        finally {
+            unlockForIteration(s);
+        }
+    },
+    SetToArray: (location, _K, _T2) => (s, valueFn) => {
+        const ret = [];
+        lockForIteration(s);
+        try {
+            for (const k of s) {
+                const v = call_function(location, valueFn, k);
+                ret.push(v);
+            }
+            return ret;
+        }
+        finally {
+            unlockForIteration(s);
+        }
+    },
+    SetToSet: (location, K, K2) => {
+        const compare = compareFor(K2);
+        return (s, f) => {
+            const result = new SortedSet([], compare);
+            lockForIteration(s);
+            try {
+                for (const x of s) {
+                    const v = call_function(location, f, x);
+                    result.add(v);
+                }
+                ;
+                return result;
+            }
+            finally {
+                unlockForIteration(s);
+            }
+        };
+    },
+    SetToDict: (location, K, K2, _V2) => {
+        const compare = compareFor(K2);
+        return (s, keyFn, valueFn, onConflict) => {
+            const result = new SortedMap([], compare);
+            lockForIteration(s);
+            try {
+                for (const k of s) {
+                    const k2 = call_function(location, keyFn, k);
+                    let v2 = call_function(location, valueFn, k);
+                    const existing = result.get(k2);
+                    if (existing !== undefined) {
+                        v2 = call_function(location, onConflict, existing, v2, k2);
+                        result.set(k2, v2);
+                    }
+                    else {
+                        result.set(k2, v2);
+                    }
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(s);
+            }
+        };
+    },
+    SetFlattenToArray: (location, _K, _T2) => (s, fn) => {
+        const ret = [];
+        lockForIteration(s);
+        try {
+            for (const k of s) {
+                const subarray = call_function(location, fn, k);
+                ret.push(...subarray);
+            }
+            return ret;
+        }
+        finally {
+            unlockForIteration(s);
+        }
+    },
+    SetFlattenToSet: (location, _K, K2) => {
+        const compare = compareFor(K2);
+        return (s, fn) => {
+            const result = new SortedSet([], compare);
+            lockForIteration(s);
+            try {
+                for (const k of s) {
+                    const subset = call_function(location, fn, k);
+                    for (const k2 of subset) {
+                        result.add(k2);
+                    }
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(s);
+            }
+        };
+    },
+    SetFlattenToDict: (location, _K, K2, _V2) => {
+        const compare = compareFor(K2);
+        return (s, fn, onConflict) => {
+            const result = new SortedMap([], compare);
+            lockForIteration(s);
+            try {
+                for (const k of s) {
+                    const subdict = call_function(location, fn, k);
+                    for (const [k2, v2] of subdict.entries()) {
+                        const existing = result.get(k2);
+                        if (existing === undefined) {
+                            result.set(k2, v2);
+                        }
+                        else {
+                            const new_v2 = call_function(location, onConflict, existing, v2, k2);
+                            result.set(k2, new_v2);
+                        }
+                    }
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(s);
+            }
+        };
+    },
+    SetGroupFold: (location, _K, K2, _T2) => {
+        const compare = compareFor(K2);
+        return (s, keyFn, init, folder) => {
+            const result = new SortedMap([], compare);
+            lockForIteration(s);
+            try {
+                for (const k of s) {
+                    const k2 = call_function(location, keyFn, k);
+                    let existing = result.get(k2);
+                    if (existing === undefined) {
+                        existing = call_function(location, init, k2);
+                    }
+                    const new_val = call_function(location, folder, existing, k);
+                    result.set(k2, new_val);
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(s);
+            }
+        };
+    },
+    DictGenerate: (location, K, _V) => {
+        const keyComparer = compareFor(K);
+        return (size, keyFn, valueFn, onConflict) => {
+            const result = new SortedMap([], keyComparer);
+            for (let i = 0n; i < size; i += 1n) {
+                const k = call_function(location, keyFn, i);
+                const v = call_function(location, valueFn, i);
+                const existing = result.get(k);
+                if (existing !== undefined) {
+                    const v2 = call_function(location, onConflict, existing, v, k);
+                    result.set(k, v2);
+                }
+                else {
+                    result.set(k, v);
+                }
+            }
+            return result;
+        };
+    },
+    DictSize: (_location, _K, _V) => (d) => BigInt(d.size),
+    DictHas: (_location, _K, _V) => (d, key) => d.has(key),
+    DictGet: (location, K, _V) => {
+        const print = printFor(K);
+        return (d, key) => {
+            const result = d.get(key);
+            if (result === undefined) {
+                throw new EastError(`Dict does not contain key ${print(key)}`, { location });
+            }
+            else {
+                return result;
+            }
+        };
+    },
+    DictGetOrDefault: (location, _K, _V) => (d, key, onMissingFn) => {
+        const result = d.get(key);
+        if (result === undefined) {
+            return call_function(location, onMissingFn, key);
+        }
+        else {
+            return result;
+        }
+    },
+    DictTryGet: (_location, _K, _V) => (d, key) => {
+        const result = d.get(key);
+        if (result === undefined) {
+            return variant("none", null);
+        }
+        else {
+            return variant("some", result);
+        }
+    },
+    DictInsert: (location, K, _V) => {
+        const print = printFor(K);
+        return (d, key, value) => {
+            if (Object.isFrozen(d)) {
+                throw new EastError("Cannot modify frozen Dict", { location });
+            }
+            if ((iterationLocks.get(d) || 0) > 0) {
+                throw new EastError("Cannot modify Dict during iteration", { location });
+            }
+            const existing = d.get(key);
+            if (existing !== undefined) {
+                throw new EastError(`Dict already contains key ${print(key)}`, { location });
+            }
+            else {
+                d.set(key, value);
+            }
+            return null;
+        };
+    },
+    DictGetOrInsert: (location, _K, _V) => (d, key, onMissing) => {
+        if (Object.isFrozen(d)) {
+            throw new EastError("Cannot modify frozen Dict", { location });
+        }
+        if ((iterationLocks.get(d) || 0) > 0) {
+            throw new EastError("Cannot modify Dict during iteration", { location });
+        }
+        const existing = d.get(key);
+        if (existing === undefined) {
+            const newValue = call_function(location, onMissing, key);
+            d.set(key, newValue);
+            return newValue;
+        }
+        else {
+            return existing;
+        }
+    },
+    DictInsertOrUpdate: (location, _K, _V) => (d, key, value, onConflictFn) => {
+        if (Object.isFrozen(d)) {
+            throw new EastError("Cannot modify frozen Dict", { location });
+        }
+        if ((iterationLocks.get(d) || 0) > 0) {
+            throw new EastError("Cannot modify Dict during iteration", { location });
+        }
+        const existing = d.get(key);
+        if (existing !== undefined) {
+            const result = call_function(location, onConflictFn, existing, value, key);
+            d.set(key, result);
+        }
+        else {
+            d.set(key, value);
+        }
+        return null;
+    },
+    DictUpdate: (location, K, _V) => {
+        const print = printFor(K);
+        return (d, key, value) => {
+            if (Object.isFrozen(d)) {
+                throw new EastError("Cannot modify frozen Dict", { location });
+            }
+            if (d.has(key)) {
+                d.set(key, value);
+                return null;
+            }
+            else {
+                throw new EastError(`Dict does not contain key ${print(key)}`, { location });
+            }
+        };
+    },
+    DictSwap: (location, K, _V) => {
+        const print = printFor(K);
+        return (d, key, value) => {
+            if (Object.isFrozen(d)) {
+                throw new EastError("Cannot modify frozen Dict", { location });
+            }
+            let existing = d.get(key);
+            if (existing === undefined) {
+                throw new EastError(`Dict does not contain key ${print(key)}`, { location });
+            }
+            d.set(key, value);
+            return existing;
+        };
+    },
+    DictMerge: (location, _K, _V) => (d, key, value, mergeFn, initialFn) => {
+        if (Object.isFrozen(d)) {
+            throw new EastError("Cannot modify frozen Dict", { location });
+        }
+        if ((iterationLocks.get(d) || 0) > 0) {
+            throw new EastError("Cannot modify Dict during iteration", { location });
+        }
+        let existing = d.get(key);
+        if (existing === undefined) {
+            existing = call_function(location, initialFn, key);
+        }
+        const new_value = call_function(location, mergeFn, existing, value, key);
+        d.set(key, new_value);
+        return null;
+    },
+    DictDelete: (location, K, _V) => {
+        const print = printFor(K);
+        return (d, key) => {
+            if (Object.isFrozen(d)) {
+                throw new EastError("Cannot modify frozen Dict", { location });
+            }
+            if ((iterationLocks.get(d) || 0) > 0) {
+                throw new EastError("Cannot modify Dict during iteration", { location });
+            }
+            const existed = d.delete(key);
+            if (!existed) {
+                throw new EastError(`Dict does not contain key ${print(key)}`, { location });
+            }
+            return null;
+        };
+    },
+    DictTryDelete: (location, _K, _V) => (d, key) => {
+        if (Object.isFrozen(d)) {
+            throw new EastError("Cannot modify frozen Dict", { location });
+        }
+        if ((iterationLocks.get(d) || 0) > 0) {
+            throw new EastError("Cannot modify Dict during iteration", { location });
+        }
+        return d.delete(key);
+    },
+    DictPop: (location, K, _V) => {
+        const print = printFor(K);
+        return (d, key) => {
+            if (Object.isFrozen(d)) {
+                throw new EastError("Cannot modify frozen Dict", { location });
+            }
+            if ((iterationLocks.get(d) || 0) > 0) {
+                throw new EastError("Cannot modify Dict during iteration", { location });
+            }
+            const existing = d.get(key);
+            if (existing === undefined) {
+                throw new EastError(`Dict does not contain key ${print(key)}`, { location });
+            }
+            else {
+                d.delete(key);
+                return existing;
+            }
+        };
+    },
+    DictClear: (location, _K, _V) => (d) => {
+        if (Object.isFrozen(d)) {
+            throw new EastError("Cannot modify frozen Dict", { location });
+        }
+        if ((iterationLocks.get(d) || 0) > 0) {
+            throw new EastError("Cannot modify Dict during iteration", { location });
+        }
+        d.clear();
+        return null;
+    },
+    DictUnionInPlace: (location, _K, _V) => (d1, d2, onConflict) => {
+        if (Object.isFrozen(d1)) {
+            throw new EastError("Cannot modify frozen Dict", { location });
+        }
+        if ((iterationLocks.get(d1) || 0) > 0) {
+            throw new EastError("Cannot modify Dict during iteration", { location });
+        }
+        d2.forEach((v2, k) => {
+            const v1 = d1.get(k);
+            if (v1 === undefined) {
+                d1.set(k, v2);
+            }
+            else {
+                const new_value = call_function(location, onConflict, v1, v2, k);
+                d1.set(k, new_value);
+            }
+        });
+        return null;
+    },
+    DictMergeAll: (location, _K, _V) => (d1, d2, mergeFn, initialFn) => {
+        if (Object.isFrozen(d1)) {
+            throw new EastError("Cannot modify frozen Dict", { location });
+        }
+        if ((iterationLocks.get(d1) || 0) > 0) {
+            throw new EastError("Cannot modify Dict during iteration", { location });
+        }
+        d2.forEach((v2, k) => {
+            let v1 = d1.get(k);
+            if (v1 === undefined) {
+                v1 = call_function(location, initialFn, k);
+            }
+            const new_value = call_function(location, mergeFn, v1, v2, k);
+            d1.set(k, new_value);
+        });
+        return null;
+    },
+    DictKeys: (_location, K, _V) => {
+        const compare = compareFor(K);
+        return (d) => {
+            return new SortedSet([...d.keys()], compare);
+        };
+    },
+    DictGetKeys: (location, K, _V) => {
+        const compare = compareFor(K);
+        return (d, keys, onMissing) => {
+            const result = new SortedMap([], compare);
+            for (const k of keys) {
+                const v = d.get(k);
+                if (v !== undefined) {
+                    result.set(k, v);
+                }
+                else {
+                    const new_v = call_function(location, onMissing, k);
+                    result.set(k, new_v);
+                }
+            }
+            return result;
+        };
+    },
+    DictForEach: (location, _K, _V, _T2) => (d, f) => {
+        lockForIteration(d);
+        try {
+            d.forEach((v, k) => {
+                call_function(location, f, v, k);
+            });
+            return null;
+        }
+        finally {
+            unlockForIteration(d);
+        }
+    },
+    DictCopy: (_location, K, _V) => {
+        const compare = compareFor(K);
+        return (d) => {
+            return new SortedMap([...d], compare);
+        };
+    },
+    DictMap: (location, K, _V, _V2) => {
+        const compare = compareFor(K);
+        return (d, f) => {
+            const result = new SortedMap([], compare);
+            lockForIteration(d);
+            try {
+                for (const [k, v] of d) {
+                    const v2 = call_function(location, f, v, k);
+                    result.set(k, v2);
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(d);
+            }
+        };
+    },
+    DictFilter: (location, K, _V) => {
+        const compare = compareFor(K);
+        return (d, f) => {
+            const result = new SortedMap([], compare);
+            lockForIteration(d);
+            try {
+                for (const [k, v] of d) {
+                    const keep = call_function(location, f, v, k);
+                    if (keep) {
+                        result.set(k, v);
+                    }
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(d);
+            }
+        };
+    },
+    DictFilterMap: (location, K, _V, _V2) => {
+        const compare = compareFor(K);
+        return (d, f) => {
+            const result = new SortedMap([], compare);
+            lockForIteration(d);
+            try {
+                for (const [k, v] of d) {
+                    const v2 = call_function(location, f, v, k);
+                    if (v2.type === "some") {
+                        result.set(k, v2.value);
+                    }
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(d);
+            }
+        };
+    },
+    DictFirstMap: (location, _K, _V, _T2) => (d, f) => {
+        lockForIteration(d);
+        try {
+            for (const [k, v] of d) {
+                const result = call_function(location, f, v, k);
+                if (result.type === "some") {
+                    return result;
+                }
+            }
+            return variant("none", null);
+        }
+        finally {
+            unlockForIteration(d);
+        }
+    },
+    DictMapReduce: (location, _K, _V, _T2) => (d, mapFn, reduceFn) => {
+        if (d.size === 0) {
+            throw new EastError("Cannot reduce empty dictionary with no initial value", { location });
+        }
+        lockForIteration(d);
+        try {
+            const iterator = d[Symbol.iterator]();
+            const first = iterator.next().value;
+            let acc = call_function(location, mapFn, first[1], first[0]);
+            for (const [k, v] of iterator) {
+                const mapped = call_function(location, mapFn, v, k);
+                acc = call_function(location, reduceFn, acc, mapped);
+            }
+            return acc;
+        }
+        finally {
+            unlockForIteration(d);
+        }
+    },
+    DictReduce: (location, _K, _V, _T2) => (d, f, init) => {
+        let acc = init;
+        lockForIteration(d);
+        try {
+            for (const [k, v] of d) {
+                acc = call_function(location, f, acc, v, k);
+            }
+            return acc;
+        }
+        finally {
+            unlockForIteration(d);
+        }
+    },
+    DictToArray: (location, _K, _V, _T2) => (d, valueFn) => {
+        const ret = [];
+        lockForIteration(d);
+        try {
+            for (const [k, v] of d) {
+                const v2 = call_function(location, valueFn, v, k);
+                ret.push(v2);
+            }
+            return ret;
+        }
+        finally {
+            unlockForIteration(d);
+        }
+    },
+    DictToSet: (location, _K, _V, K2) => {
+        const compare = compareFor(K2);
+        return (d, fn) => {
+            const result = new SortedSet([], compare);
+            lockForIteration(d);
+            try {
+                for (const [k, v] of d) {
+                    const k2 = call_function(location, fn, v, k);
+                    result.add(k2);
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(d);
+            }
+        };
+    },
+    DictToDict: (location, K, _V, K2, _V2) => {
+        const compare = compareFor(K2);
+        return (d, keyFn, valueFn, onConflict) => {
+            const result = new SortedMap([], compare);
+            lockForIteration(d);
+            try {
+                for (const [k, v] of d) {
+                    const k2 = call_function(location, keyFn, v, k);
+                    const v2 = call_function(location, valueFn, v, k);
+                    const existing = result.get(k2);
+                    if (existing !== undefined) {
+                        const v3 = call_function(location, onConflict, existing, v2, k2);
+                        result.set(k2, v3);
+                    }
+                    else {
+                        result.set(k2, v2);
+                    }
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(d);
+            }
+        };
+    },
+    DictFlattenToArray: (location, _K, _V, _T2) => (d, fn) => {
+        const ret = [];
+        lockForIteration(d);
+        try {
+            for (const [k, v] of d.entries()) {
+                const subarray = call_function(location, fn, v, k);
+                for (const item of subarray) {
+                    ret.push(item);
+                }
+            }
+            return ret;
+        }
+        finally {
+            unlockForIteration(d);
+        }
+    },
+    DictFlattenToSet: (location, _K, _V, K2) => {
+        const compare = compareFor(K2);
+        return (d, fn) => {
+            const result = new SortedSet([], compare);
+            lockForIteration(d);
+            try {
+                for (const [k, v] of d.entries()) {
+                    const subset = call_function(location, fn, v, k);
+                    for (const k2 of subset) {
+                        result.add(k2);
+                    }
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(d);
+            }
+        };
+    },
+    DictFlattenToDict: (location, _K, _V, K2, _V2) => {
+        const compare = compareFor(K2);
+        return (d, fn, onConflict) => {
+            const result = new SortedMap([], compare);
+            lockForIteration(d);
+            try {
+                for (const [k, v] of d.entries()) {
+                    const subdict = call_function(location, fn, v, k);
+                    for (const [k2, v2] of subdict.entries()) {
+                        const existing = result.get(k2);
+                        if (existing === undefined) {
+                            result.set(k2, v2);
+                        }
+                        else {
+                            const new_v2 = call_function(location, onConflict, existing, v2, k2);
+                            result.set(k2, new_v2);
+                        }
+                    }
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(d);
+            }
+        };
+    },
+    DictGroupFold: (location, _K, _V, K2, _T2) => {
+        const compare = compareFor(K2);
+        return (d, keyFn, init, folder) => {
+            const result = new SortedMap([], compare);
+            lockForIteration(d);
+            try {
+                for (const [k, v] of d.entries()) {
+                    const k2 = call_function(location, keyFn, v, k);
+                    let existing = result.get(k2);
+                    if (existing === undefined) {
+                        existing = call_function(location, init, k2);
+                    }
+                    const new_val = call_function(location, folder, existing, v, k);
+                    result.set(k2, new_val);
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(d);
+            }
+        };
+    },
+};
+/** @internal */
+export function applyTypeParameters(t, params) {
+    if (typeof (t) === "string") {
+        let ret = params.get(t);
+        if (ret === undefined) {
+            throw new Error(`Unable to find type parameter ${JSON.stringify(t)}`);
+        }
+        return ret;
+    }
+    else if (t.type === "Null" || t.type === "Boolean" || t.type === "Integer" || t.type === "Float" || t.type === "String" || t.type === "DateTime" || t.type === "Blob" || t.type === "Never") {
+        return t;
+    }
+    else if (t.type === "Ref") {
+        return variant("Ref", applyTypeParameters(t.value, params));
+    }
+    else if (t.type === "Array") {
+        return variant("Array", applyTypeParameters(t.value, params));
+    }
+    else if (t.type === "Set") {
+        return variant("Set", applyTypeParameters(t.value, params));
+    }
+    else if (t.type === "Dict") {
+        return variant("Dict", { key: applyTypeParameters(t.value.key, params), value: applyTypeParameters(t.value.value, params) });
+    }
+    else if (t.type === "Struct") {
+        return variant("Struct", t.value.map(({ name, type }) => ({ name, type: applyTypeParameters(type, params) })));
+    }
+    else if (t.type === "Variant") {
+        return variant("Variant", t.value.map(({ name, type }) => ({ name, type: applyTypeParameters(type, params) })));
+    }
+    else if (t.type === "Recursive") {
+        return t;
+    }
+    else if (t.type === "Function") {
+        // TODO platforms?
+        return variant("Function", { inputs: t.value.inputs.map(i => applyTypeParameters(i, params)), output: applyTypeParameters(t.value.output, params), platforms: [] });
+    }
+    else {
+        throw new Error(`Unhandled type ${t.type}`);
+    }
+}
+//# sourceMappingURL=compile.js.map