@elaraai/east 1.0.79 → 1.0.80

package/dist/src/compile.js

@@ -2,4419 +2,12 @@
  * Copyright (c) 2025 Elara AI Pty Ltd
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
-import {} from "./builtins.js";
-import {} from "./ir.js";
-import { compareFor, equalFor, greaterEqualFor, greaterFor, isFor, lessEqualFor, lessFor, notEqualFor } from "./comparison.js";
-import { diffFor } from "./patch/diff.js";
-import { applyFor } from "./patch/apply.js";
-import { composeFor } from "./patch/compose.js";
-import { invertFor } from "./patch/invert.js";
-import { ConflictError } from "./patch/index.js";
-import { printFor, parseFor } from "./serialization/east.js";
-import { variant } from "./containers/variant.js";
-import { isFrozenValue } from "./frozen.js";
-import { EastError, InternalError } from "./error.js";
-import { get_current_source_map } from "./location.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, decodeCsvFor, encodeCsvFor, openBeast2LazyFor, isBeast2LazySafe, readBeast2Extents, readBeast2Type } from "./serialization/index.js";
-import { formatDateTime } from "./datetime_format/print.js";
-import { parseDateTimeFormatted } from "./datetime_format/parse.js";
-import { EastTypeValueType, isTypeValueEqual, expandTypeValue } from "./type_of_type.js";
-import { ref } from "./containers/ref.js";
-import { matrix } from "./containers/matrix.js";
-export { isTypeValueEqual };
-export const printTypeValue = printFor(EastTypeValueType);
-/**
- * Symbol used to attach source IR to compiled functions.
- * This enables serialization of free functions (functions with no captures).
- */
-export const EAST_IR_SYMBOL = Symbol.for("east.ir");
-/**
- * Symbol used to attach capture values to compiled functions.
- * This enables serialization of closures (functions with captures).
- */
-export const EAST_CAPTURES_SYMBOL = Symbol.for("east.captures");
-/**
- * Symbol used to attach source map to compiled functions.
- * Enables encoding location stacks into beast2 source_map_section.
- */
-export const EAST_SOURCE_MAP_SYMBOL = Symbol.for("east.source_map");
-/** Determines if a variable requires boxing (mutable + captured) */
-export function requiresBoxing(variable) {
-    return variable.mutable && variable.captured;
-}
-/** Get a context value, throwing InternalError if missing */
-function getContextValue(ctx, name) {
-    const value = ctx[name];
-    if (value === undefined) {
-        throw new InternalError(`Variable '${name}' not found in runtime context`);
-    }
-    return value;
-}
-// =============================================================================
-/** @internal The frozen-mutation error message — identical across the TS, C
- * and Python runtimes (compliance-tested), so a body that mutates a frozen
- * task input fails the same way everywhere. */
-const FROZEN_MESSAGE = "cannot mutate a frozen value (task inputs are immutable) — copy first";
-/** @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
-*/
-// Captured once per top-level compile; all closures share the same SourceMap.
-let _compile_source_map = null;
-export function compile_internal(ir, ctx, platform, asyncPlatformFns, platformDef, fresh_ctx = true, compilingNodes = new Set()) {
-    // Capture source map from the active scope on first call
-    if (fresh_ctx)
-        _compile_source_map = get_current_source_map();
-    const source_map = _compile_source_map;
-    // The IR is checked prior to compilation, so we can assume it's valid here.
-    // The compiler needs to take care that Promises are properly awaited, so most IR nodes need both sync and async implementations.
-    // We assume unnecessary `async` functions degrade performance but unnecessary `await`s are not too bad, so while we could be more "specific" in our awaits we do not bother
-    if (ir.type === "Value") {
-        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, platformDef, false, compilingNodes);
-        if (ir.value.isAsync) {
-            const err_location = source_map?.resolve(ir.value.loc_id) ?? [];
-            return async (ctx) => { throw new EastError(await message_compiled(ctx), { location: err_location }); };
-        }
-        else {
-            const err_location = source_map?.resolve(ir.value.loc_id) ?? [];
-            return (ctx) => { throw new EastError(message_compiled(ctx), { location: err_location }); };
-        }
-    }
-    else if (ir.type === "TryCatch") {
-        const try_body = compile_internal(ir.value.try_body, Object.create(ctx), platform, asyncPlatformFns, platformDef, 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, platformDef, 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, platformDef, 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] = variant("value", e.message);
-                            new_ctx[stack_name] = variant("value", e.location.map(l => ({ filename: l.filename, line: l.line, column: l.column })));
-                            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] = variant("value", e.message);
-                            new_ctx[stack_name] = variant("value", e.location.map(l => ({ filename: l.filename, line: l.line, column: l.column })));
-                            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] = variant("value", e.message);
-                            new_ctx[stack_name] = variant("value", e.location.map(l => ({ filename: l.filename, line: l.line, column: l.column })));
-                            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] = variant("value", e.message);
-                            new_ctx[stack_name] = variant("value", e.location.map(l => ({ filename: l.filename, line: l.line, column: l.column })));
-                            return catch_body(new_ctx);
-                        }
-                        else {
-                            throw (e);
-                        }
-                    }
-                    finally {
-                        finally_body(Object.create(ctx));
-                    }
-                };
-            }
-        }
-    }
-    else if (ir.type === "Variable") {
-        const name = ir.value.name;
-        // All context values are variants - read via .value
-        return (ctx) => getContextValue(ctx, name).value;
-    }
-    else if (ir.type === "Let") {
-        const compiled_statement = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
-        const name = ir.value.variable.value.name;
-        ctx[name] = ir.value.variable.value.type;
-        const boxed = requiresBoxing(ir.value.variable.value);
-        if (ir.value.isAsync) {
-            return async (ctx) => {
-                ctx[name] = boxed
-                    ? variant("boxed", await compiled_statement(ctx))
-                    : variant("value", await compiled_statement(ctx));
-                return null;
-            };
-        }
-        else {
-            return (ctx) => {
-                ctx[name] = boxed
-                    ? variant("boxed", compiled_statement(ctx))
-                    : variant("value", compiled_statement(ctx));
-                return null;
-            };
-        }
-    }
-    else if (ir.type === "Assign") {
-        const name = ir.value.variable.value.name;
-        const compiled_statement = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
-        if (requiresBoxing(ir.value.variable.value)) {
-            // Boxed variables: mutate in place via .value
-            if (ir.value.isAsync) {
-                return async (ctx) => {
-                    getContextValue(ctx, name).value = await compiled_statement(ctx);
-                    return null;
-                };
-            }
-            else {
-                return (ctx) => {
-                    getContextValue(ctx, name).value = compiled_statement(ctx);
-                    return null;
-                };
-            }
-        }
-        else {
-            // Non-boxed variables: replace the variant
-            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] = variant("value", 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] = variant("value", value);
-                    return null;
-                };
-            }
-        }
-    }
-    else if (ir.type === "As") {
-        // 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, platformDef, fresh_ctx, compilingNodes);
-    }
-    else if (ir.type === "UnwrapRecursive") {
-        // 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, platformDef, fresh_ctx, compilingNodes);
-    }
-    else if (ir.type === "WrapRecursive") {
-        // 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, platformDef, false, compilingNodes);
-    }
-    else if (ir.type === "Function") {
-        // Compile-time type context for body compilation
-        const typeCtx = {};
-        for (const variable of ir.value.captures) {
-            typeCtx[variable.value.name] = variable.value.type;
-        }
-        for (const parameter of ir.value.parameters) {
-            typeCtx[parameter.value.name] = parameter.value.type;
-        }
-        const compiled_body = compile_internal(ir.value.body, typeCtx, platform, asyncPlatformFns, platformDef, true, compilingNodes);
-        const capture_names = ir.value.captures.map(v => v.value.name);
-        const parameter_names = ir.value.parameters.map(v => v.value.name);
-        // Store original IR for potential serialization
-        const originalIR = ir;
-        return (ctx) => {
-            // Runtime context for captured values
-            const captureCtx = {};
-            for (const name of capture_names) {
-                captureCtx[name] = getContextValue(ctx, name);
-            }
-            const fn = (...args) => {
-                const fnCtx = { ...captureCtx };
-                parameter_names.forEach((name, i) => fnCtx[name] = variant("value", args[i]));
-                return compiled_body(fnCtx);
-            };
-            // Attach IR to function for serialization support
-            Object.defineProperty(fn, EAST_IR_SYMBOL, {
-                value: originalIR,
-                writable: false,
-                enumerable: false,
-                configurable: false
-            });
-            // Attach capture values for serialization support
-            Object.defineProperty(fn, EAST_CAPTURES_SYMBOL, {
-                value: captureCtx,
-                writable: false,
-                enumerable: false,
-                configurable: false
-            });
-            // Propagate source map from enclosing compilation scope
-            if (source_map) {
-                Object.defineProperty(fn, EAST_SOURCE_MAP_SYMBOL, {
-                    value: source_map,
-                    writable: false,
-                    enumerable: false,
-                    configurable: false
-                });
-            }
-            return fn;
-        };
-    }
-    else if (ir.type === "AsyncFunction") {
-        // Compile-time type context for body compilation
-        const typeCtx = {};
-        for (const variable of ir.value.captures) {
-            typeCtx[variable.value.name] = variable.value.type;
-        }
-        for (const parameter of ir.value.parameters) {
-            typeCtx[parameter.value.name] = parameter.value.type;
-        }
-        const compiled_body = compile_internal(ir.value.body, typeCtx, platform, asyncPlatformFns, platformDef, true, compilingNodes);
-        const capture_names = ir.value.captures.map(v => v.value.name);
-        const parameter_names = ir.value.parameters.map(v => v.value.name);
-        // Store original IR for potential serialization
-        const originalIR = ir;
-        return (ctx) => {
-            // Runtime context for captured values
-            const captureCtx = {};
-            for (const name of capture_names) {
-                captureCtx[name] = getContextValue(ctx, name);
-            }
-            const fn = (...args) => {
-                const fnCtx = { ...captureCtx };
-                parameter_names.forEach((name, i) => fnCtx[name] = variant("value", args[i]));
-                return compiled_body(fnCtx); // Promise can pass through in tail position
-            };
-            // Attach IR to function for serialization support
-            Object.defineProperty(fn, EAST_IR_SYMBOL, {
-                value: originalIR,
-                writable: false,
-                enumerable: false,
-                configurable: false
-            });
-            // Attach capture values for serialization support
-            Object.defineProperty(fn, EAST_CAPTURES_SYMBOL, {
-                value: captureCtx,
-                writable: false,
-                enumerable: false,
-                configurable: false
-            });
-            // Propagate source map from enclosing compilation scope
-            if (source_map) {
-                Object.defineProperty(fn, EAST_SOURCE_MAP_SYMBOL, {
-                    value: source_map,
-                    writable: false,
-                    enumerable: false,
-                    configurable: false
-                });
-            }
-            return fn;
-        };
-    }
-    else if (ir.type === "Call") {
-        const compiled_f = compile_internal(ir.value.function, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
-        const compiled_args = ir.value.arguments.map(argument => compile_internal(argument, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes));
-        const loc_id = ir.value.loc_id;
-        if (ir.value.isAsync) {
-            // need to await the arguments
-            return async (ctx) => {
-                try {
-                    const args = [];
-                    for (const compiled_arg of compiled_args) {
-                        args.push(await compiled_arg(ctx));
-                    }
-                    return compiled_f(ctx)(...args);
-                }
-                catch (e) {
-                    if (e instanceof ReturnException) {
-                        return e.value;
-                    }
-                    else if (e instanceof EastError) {
-                        // TODO: push loc_id to EastError once SourceMap resolution is wired up
-                        throw (e);
-                    }
-                    else if (e instanceof ContinueException) {
-                        throw new Error(`continue failed to find label ${e.label} at loc_id ${loc_id}`);
-                    }
-                    else if (e instanceof BreakException) {
-                        throw new Error(`break failed to find label ${e.label} at loc_id ${loc_id}`);
-                    }
-                    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) {
-                        // TODO: push loc_id to EastError once SourceMap resolution is wired up
-                        throw (e);
-                    }
-                    else if (e instanceof ContinueException) {
-                        throw new Error(`continue failed to find label ${e.label} at loc_id ${loc_id}`);
-                    }
-                    else if (e instanceof BreakException) {
-                        throw new Error(`break failed to find label ${e.label} at loc_id ${loc_id}`);
-                    }
-                    else {
-                        throw (e);
-                    }
-                }
-            };
-        }
-    }
-    else if (ir.type === "CallAsync") {
-        const compiled_f = compile_internal(ir.value.function, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
-        const compiled_args = ir.value.arguments.map(argument => compile_internal(argument, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes));
-        const loc_id = ir.value.loc_id;
-        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) {
-                    // TODO: push loc_id to EastError once SourceMap resolution is wired up
-                    throw (e);
-                }
-                else if (e instanceof ContinueException) {
-                    throw new Error(`continue failed to find label ${e.label} at loc_id ${loc_id}`);
-                }
-                else if (e instanceof BreakException) {
-                    throw new Error(`break failed to find label ${e.label} at loc_id ${loc_id}`);
-                }
-                else {
-                    throw (e);
-                }
-            }
-        };
-    }
-    else if (ir.type === "IfElse") {
-        const ifs = [];
-        let asyncPredicate = false;
-        for (const { predicate, body } of ir.value.ifs) {
-            if (predicate.value.isAsync) {
-                asyncPredicate = true;
-            }
-            ifs.push({
-                predicate: compile_internal(predicate, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes),
-                body: compile_internal(body, Object.create(ctx), platform, asyncPlatformFns, platformDef, true, compilingNodes),
-            });
-        }
-        const else_body = compile_internal(ir.value.else_body, Object.create(ctx), platform, asyncPlatformFns, platformDef, true, compilingNodes);
-        if (ir.value.isAsync) {
-            if (asyncPredicate) {
-                return async (ctx) => {
-                    for (const { predicate, body } of ifs) {
-                        if (await predicate(ctx)) {
-                            return await body(Object.create(ctx));
-                        }
-                    }
-                    return await else_body(Object.create(ctx));
-                };
-            }
-            else {
-                return async (ctx) => {
-                    for (const { predicate, body } of ifs) {
-                        if (predicate(ctx)) {
-                            return await body(Object.create(ctx));
-                        }
-                    }
-                    return await 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, platformDef, 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, platformDef, true, compilingNodes);
-        }
-        if (ir.value.isAsync) {
-            if (ir.value.variant.value.isAsync) {
-                return async (ctx) => {
-                    const v = await compiled_variant(ctx);
-                    const ctx2 = Object.create(ctx);
-                    ctx2[data_names[v.type]] = variant("value", v.value);
-                    return await compiled_cases[v.type](ctx2);
-                };
-            }
-            else {
-                return async (ctx) => {
-                    const v = compiled_variant(ctx);
-                    const ctx2 = Object.create(ctx);
-                    ctx2[data_names[v.type]] = variant("value", v.value);
-                    return await compiled_cases[v.type](ctx2);
-                };
-            }
-        }
-        else {
-            return (ctx) => {
-                const v = compiled_variant(ctx);
-                const ctx2 = Object.create(ctx);
-                ctx2[data_names[v.type]] = variant("value", v.value);
-                return compiled_cases[v.type](ctx2);
-            };
-        }
-    }
-    else if (ir.type === "While") {
-        const compiled_predicate = compile_internal(ir.value.predicate, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
-        const ctx2 = Object.create(ctx);
-        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, platformDef, 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, platformDef, 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, platformDef, 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] = variant("value", BigInt(key));
-                        ctx2[value_name] = variant("value", 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] = variant("value", BigInt(key));
-                        ctx2[value_name] = variant("value", 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, platformDef, 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, platformDef, 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] = variant("value", 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] = variant("value", 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, platformDef, 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, platformDef, 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] = variant("value", key);
-                        ctx2[value_name] = variant("value", 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] = variant("value", key);
-                        ctx2[value_name] = variant("value", 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) {
-            const compiled_statements = [];
-            for (const statement of ir.value.statements) {
-                const compiled_statement = compile_internal(statement, ctx, platform, asyncPlatformFns, platformDef, true, compilingNodes);
-                compiled_statements.push(compiled_statement);
-            }
-            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);
-            const compiled_statements = [];
-            for (const statement of ir.value.statements) {
-                const compiled_statement = compile_internal(statement, ctx2, platform, asyncPlatformFns, platformDef, true, compilingNodes);
-                compiled_statements.push(compiled_statement);
-            }
-            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") {
-        const struct = compile_internal(ir.value.struct, ctx, platform, asyncPlatformFns, platformDef, 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") {
-        const fields = ir.value.fields.map(f => {
-            return compile_internal(f.value, ctx, platform, asyncPlatformFns, platformDef, 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") {
-        const k = ir.value.case;
-        const v = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, platformDef, 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") {
-        const value = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
-        if (ir.value.isAsync) {
-            return async (ctx) => ref(await value(ctx));
-        }
-        else {
-            return (ctx) => ref(value(ctx));
-        }
-    }
-    else if (ir.type === "NewArray") {
-        const values = ir.value.values.map(a => {
-            return compile_internal(a, ctx, platform, asyncPlatformFns, platformDef, 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") {
-        const values = ir.value.values.map(a => {
-            return compile_internal(a, ctx, platform, asyncPlatformFns, platformDef, 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") {
-        const values = ir.value.values.map(({ key, value }) => {
-            return [compile_internal(key, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes), compile_internal(value, ctx, platform, asyncPlatformFns, platformDef, 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 === "NewVector") {
-        const elementType = ir.value.type.value; // element EastTypeValue
-        const values = ir.value.values.map(a => {
-            return compile_internal(a, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
-        });
-        if (ir.value.isAsync) {
-            return async (ctx) => {
-                const vals = [];
-                for (const a of values) {
-                    vals.push(await a(ctx));
-                }
-                return createTypedArray(elementType, vals);
-            };
-        }
-        else {
-            return (ctx) => {
-                const vals = values.map(a => a(ctx));
-                return createTypedArray(elementType, vals);
-            };
-        }
-    }
-    else if (ir.type === "NewMatrix") {
-        const elementType = ir.value.type.value;
-        const rows = Number(ir.value.rows);
-        const cols = Number(ir.value.cols);
-        const values = ir.value.values.map(a => {
-            return compile_internal(a, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
-        });
-        if (ir.value.isAsync) {
-            return async (ctx) => {
-                const vals = [];
-                for (const a of values) {
-                    vals.push(await a(ctx));
-                }
-                return matrix(createTypedArray(elementType, vals), rows, cols);
-            };
-        }
-        else {
-            return (ctx) => {
-                const vals = values.map(a => a(ctx));
-                return matrix(createTypedArray(elementType, vals), rows, cols);
-            };
-        }
-    }
-    else if (ir.type === "Return") {
-        const compiled_value = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, platformDef, 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") {
-        const label = ir.value.label;
-        return (_ctx) => {
-            throw new ContinueException(label.name);
-        };
-    }
-    else if (ir.type === "Break") {
-        const label = ir.value.label;
-        return (_ctx) => {
-            throw new BreakException(label.name);
-        };
-    }
-    else if (ir.type === "Builtin") {
-        let argsAsync = false;
-        const args = ir.value.arguments.map((a, _i) => {
-            if (a.value.isAsync) {
-                argsAsync = true;
-            }
-            return compile_internal(a, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
-        });
-        // Special optimization for regex builtins with literal pattern/flags
-        const loc_id = ir.value.loc_id;
-        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 loc_id ${ir.value.arguments[1].value.loc_id}`);
-            }
-            if (ir.value.arguments[2].value.value.type !== "String") {
-                throw new Error(`Regex builtin flags argument must be String literal at loc_id ${ir.value.arguments[2].value.loc_id}`);
-            }
-            // 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 loc_id ${ir.value.arguments[3].value.loc_id}`);
-                    }
-                    // 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: (source_map?.resolve(loc_id) ?? []) }); };
-                            }
-                            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: (source_map?.resolve(loc_id) ?? []) }); };
-                                    }
-                                    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: (source_map?.resolve(loc_id) ?? []) }); };
-                                    }
-                                    i += 1;
-                                    char2 = replacement[i];
-                                }
-                                if (i === init_i) {
-                                    return (_ctx) => { throw new EastError(`invalid regex replacement string: empty group name in $<>`, { location: (source_map?.resolve(loc_id) ?? []) }); };
-                                }
-                                i += 1; // for closing >
-                            }
-                            else {
-                                return (_ctx) => { throw new EastError(`invalid regex replacement string: unescaped $ at $${char2}`, { location: (source_map?.resolve(loc_id) ?? []) }); };
-                            }
-                        }
-                        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: (source_map?.resolve(loc_id) ?? []) });
-                                }
-                                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: (source_map?.resolve(loc_id) ?? []) });
-                                        }
-                                        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: (source_map?.resolve(loc_id) ?? []) });
-                                        }
-                                        i += 1;
-                                        char2 = replacement[i];
-                                    }
-                                    if (i === init_i) {
-                                        throw new EastError(`invalid regex replacement string: empty group name in $<>`, { location: (source_map?.resolve(loc_id) ?? []) });
-                                    }
-                                    i += 1; // for closing >
-                                }
-                                else {
-                                    throw new EastError(`invalid regex replacement string: unescaped $ at $${char2}`, { location: (source_map?.resolve(loc_id) ?? []) });
-                                }
-                            }
-                            else {
-                                i += char.length;
-                            }
-                        }
-                        return text.replaceAll(compiledRegex, replacement);
-                    };
-                }
-            }
-        }
-        const evaluator = builtin_evaluators[ir.value.builtin](ir.value.loc_id, source_map, platformDef, ...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") {
-        const loc_id = ir.value.loc_id;
-        let argsAsync = false;
-        const args = ir.value.arguments.map(a => {
-            if (a.value.isAsync) {
-                argsAsync = true;
-            }
-            return compile_internal(a, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
-        });
-        // Look up platform function definition to check if generic
-        const platformFn = platformDef.find(p => p.name === ir.value.name);
-        const typeParams = ir.value.type_parameters ?? [];
-        // Get evaluator - for generic functions, call factory with type params
-        let evaluator;
-        if (typeParams.length > 0 && platformFn?.type_parameters && platformFn.type_parameters.length > 0) {
-            // Generic platform function - fn is a factory that takes type params
-            if (!platformFn.fn) {
-                // Missing generic platform function - create stub that throws at runtime
-                const name = ir.value.name;
-                evaluator = () => {
-                    throw new EastError(`Platform function '${name}' is not available`, { location: (source_map?.resolve(loc_id) ?? []) });
-                };
-            }
-            else {
-                evaluator = platformFn.fn(...typeParams);
-            }
-        }
-        else {
-            // Non-generic - use platform map for backwards compatibility
-            const platformEvaluator = platform[ir.value.name];
-            if (platformEvaluator === undefined) {
-                // Missing platform function - create stub that throws at runtime
-                const name = ir.value.name;
-                evaluator = () => {
-                    throw new EastError(`Platform function '${name}' is not available`, { location: (source_map?.resolve(loc_id) ?? []) });
-                };
-            }
-            else {
-                evaluator = platformEvaluator;
-            }
-        }
-        if (argsAsync) {
-            return async (ctx) => {
-                const args_resolved = [];
-                for (const a of args) {
-                    args_resolved.push(await a(ctx));
-                }
-                return evaluator(...args_resolved); // evaluator can return Promise unconditionally in tail position if the platform function is async
-            };
-        }
-        else {
-            return (ctx) => evaluator(...args.map(a => a(ctx))); // evaluator can return Promise unconditionally in tail position if the platform function is async
-        }
-    }
-    else {
-        throw new Error(`Unhandled IR type ${ir.type} at loc_id ${ir.value.loc_id}`); // 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(loc_id, source_map, compiled_f, ...args) {
-    try {
-        return compiled_f(...args);
-    }
-    catch (e) {
-        if (e instanceof ReturnException) {
-            return e.value;
-        }
-        else if (e instanceof EastError) {
-            // TODO: push loc_id to EastError once SourceMap resolution is wired up
-            throw (e);
-        }
-        else if (e instanceof ContinueException) {
-            throw new Error(`continue failed to find label ${e.label} at loc_id ${loc_id}`);
-        }
-        else if (e instanceof BreakException) {
-            throw new Error(`break failed to find label ${e.label} at loc_id ${loc_id}`);
-        }
-        else {
-            throw (e);
-        }
-    }
-}
-/** Allocates an empty TypedArray of the given length for a given element type */
-function allocateTypedArray(elementType, length) {
-    if (elementType.type === "Float")
-        return new Float64Array(length);
-    if (elementType.type === "Integer")
-        return new BigInt64Array(length);
-    if (elementType.type === "Boolean")
-        return new Uint8ClampedArray(length);
-    throw new Error(`Unsupported vector element type: ${elementType.type}`);
-}
-/** Wraps to East's 64-bit Integer semantics */
-function wrapI64(x) {
-    return BigInt.asIntN(64, x);
-}
-/** Throws unless the vector/matrix element type parameter is Float or Integer */
-function requireNumericElem(builtin, T, loc_id, source_map) {
-    if (T.type !== "Float" && T.type !== "Integer") {
-        throw new EastError(`${builtin} requires Float or Integer elements`, { location: (source_map?.resolve(loc_id) ?? []) });
-    }
-    return T.type;
-}
-/** Throws the shared length-mismatch error for elementwise vector operands */
-function requireSameLength(a, b, loc_id, source_map) {
-    if (a.length !== b.length) {
-        throw new EastError(`Vector length mismatch (${a.length} vs ${b.length})`, { location: (source_map?.resolve(loc_id) ?? []) });
-    }
-}
-/** Throws the shared dimension-mismatch error for elementwise matrix operands */
-function requireSameDims(a, b, loc_id, source_map) {
-    if (a.rows !== b.rows || a.cols !== b.cols) {
-        throw new EastError(`Matrix dimension mismatch (${a.rows}x${a.cols} vs ${b.rows}x${b.cols})`, { location: (source_map?.resolve(loc_id) ?? []) });
-    }
-}
-/** Validates the sparse-accumulator invariant: parallel lengths and strictly ascending indices */
-function requireSparse(ix, v, loc_id, source_map) {
-    if (ix.length !== v.length) {
-        throw new EastError(`Sparse index and value lengths differ (${ix.length} vs ${v.length})`, { location: (source_map?.resolve(loc_id) ?? []) });
-    }
-    for (let i = 1; i < ix.length; i++) {
-        if (ix[i] <= ix[i - 1]) {
-            throw new EastError(`Sparse index vector must be strictly ascending`, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-    }
-}
-/** Creates the appropriate TypedArray for a given element type */
-function createTypedArray(elementType, values) {
-    if (elementType.type === "Float") {
-        const arr = new Float64Array(values.length);
-        for (let i = 0; i < values.length; i++)
-            arr[i] = values[i];
-        return arr;
-    }
-    else if (elementType.type === "Integer") {
-        const arr = new BigInt64Array(values.length);
-        for (let i = 0; i < values.length; i++)
-            arr[i] = values[i];
-        return arr;
-    }
-    else if (elementType.type === "Boolean") {
-        const arr = new Uint8ClampedArray(values.length);
-        for (let i = 0; i < values.length; i++)
-            arr[i] = values[i] ? 1 : 0;
-        return arr;
-    }
-    else {
-        throw new Error(`Unsupported vector element type: ${elementType.type}`);
-    }
-}
-/** @internal */
-const builtin_evaluators = {
-    Is: (loc_id, source_map, _platformDef, T) => isFor(T),
-    Equal: (loc_id, source_map, _platformDef, T) => equalFor(T),
-    NotEqual: (loc_id, source_map, _platformDef, T) => notEqualFor(T),
-    Less: (loc_id, source_map, _platformDef, T) => lessFor(T),
-    LessEqual: (loc_id, source_map, _platformDef, T) => lessEqualFor(T),
-    Greater: (loc_id, source_map, _platformDef, T) => greaterFor(T),
-    GreaterEqual: (loc_id, source_map, _platformDef, T) => greaterEqualFor(T),
-    Diff: (loc_id, source_map, _platformDef, T) => diffFor(T),
-    ApplyPatch: (loc_id, source_map, _platformDef, T) => {
-        const apply = applyFor(T);
-        return (base, patch) => {
-            try {
-                return apply(base, patch);
-            }
-            catch (e) {
-                if (e instanceof ConflictError) {
-                    throw new EastError(e.message, { location: (source_map?.resolve(loc_id) ?? []) });
-                }
-                throw e;
-            }
-        };
-    },
-    ComposePatch: (loc_id, source_map, _platformDef, T) => {
-        const compose = composeFor(T);
-        return (first, second) => {
-            try {
-                return compose(first, second);
-            }
-            catch (e) {
-                if (e instanceof ConflictError) {
-                    throw new EastError(e.message, { location: (source_map?.resolve(loc_id) ?? []) });
-                }
-                throw e;
-            }
-        };
-    },
-    InvertPatch: (loc_id, source_map, _platformDef, T) => invertFor(T),
-    BooleanNot: (_loc_id, _source_map) => (x) => !x,
-    BooleanOr: (_loc_id, _source_map) => (x, y) => x || y,
-    BooleanAnd: (_loc_id, _source_map) => (x, y) => x && y,
-    BooleanXor: (_loc_id, _source_map) => (x, y) => x !== y,
-    IntegerToFloat: (_loc_id, _source_map) => (x) => Number(x),
-    IntegerNegate: (_loc_id, _source_map) => (x) => BigInt.asIntN(64, -x),
-    IntegerAdd: (_loc_id, _source_map) => (x, y) => BigInt.asIntN(64, x + y),
-    IntegerSubtract: (_loc_id, _source_map) => (x, y) => BigInt.asIntN(64, x - y),
-    IntegerMultiply: (_loc_id, _source_map) => (x, y) => BigInt.asIntN(64, x * y),
-    IntegerDivide: (loc_id, source_map) => (x, y) => {
-        if (y === 0n)
-            throw new EastError("Division by zero", { location: (source_map?.resolve(loc_id) ?? []) });
-        return BigInt.asIntN(64, x / y);
-    },
-    IntegerRemainder: (loc_id, source_map) => (x, y) => {
-        if (y === 0n)
-            throw new EastError("Division by zero", { location: (source_map?.resolve(loc_id) ?? []) });
-        return x % y;
-    },
-    IntegerPow: (_loc_id, _source_map) => (x, y) => y >= 0n ? BigInt.asIntN(64, x ** y) : 0n,
-    IntegerAbs: (_loc_id, _source_map) => (x) => BigInt.asIntN(64, x < 0n ? -x : x),
-    IntegerSign: (_loc_id, _source_map) => (x) => x > 0n ? 1n : x < 0n ? -1n : 0n,
-    IntegerLog: (_loc_id, _source_map) => (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: (loc_id, source_map) => (x) => {
-        if (Number.isNaN(x))
-            throw new EastError("Cannot convert NaN to integer", { location: (source_map?.resolve(loc_id) ?? []) });
-        if (x >= 9223372036854775808)
-            throw new EastError("Float too high to convert to integer", { location: (source_map?.resolve(loc_id) ?? []) });
-        if (x < -9223372036854775808)
-            throw new EastError("Float too low to convert to integer", { location: (source_map?.resolve(loc_id) ?? []) });
-        if (!Number.isInteger(x)) {
-            throw new EastError("Cannot convert non-integer float to integer", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        return BigInt(x);
-    },
-    FloatNegate: (_loc_id, _source_map) => (x) => -x,
-    FloatAdd: (_loc_id, _source_map) => (x, y) => x + y,
-    FloatSubtract: (_loc_id, _source_map) => (x, y) => x - y,
-    FloatMultiply: (_loc_id, _source_map) => (x, y) => x * y,
-    FloatDivide: (_loc_id, _source_map) => (x, y) => x / y,
-    FloatRemainder: (_loc_id, _source_map) => (x, y) => x % y,
-    FloatPow: (_loc_id, _source_map) => (x, y) => x ** y,
-    FloatAbs: (_loc_id, _source_map) => (x) => x < 0 ? -x : x,
-    FloatSign: (_loc_id, _source_map) => (x) => x > 0 ? 1 : x < 0 ? -1 : 0, // What sign is NaN?
-    FloatSqrt: (_loc_id, _source_map) => (value) => Math.sqrt(value),
-    FloatLog: (_loc_id, _source_map) => (value) => Math.log(value),
-    FloatExp: (_loc_id, _source_map) => (value) => Math.exp(value),
-    FloatSin: (_loc_id, _source_map) => (value) => Math.sin(value),
-    FloatCos: (_loc_id, _source_map) => (value) => Math.cos(value),
-    FloatTan: (_loc_id, _source_map) => (value) => Math.tan(value),
-    Print: (loc_id, source_map, _platformDef, T) => {
-        return printFor(T);
-    },
-    Parse: (loc_id, source_map, _platformDef, 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: (source_map?.resolve(loc_id) ?? []) });
-            }
-        };
-    },
-    StringConcat: (_loc_id, _source_map) => (x, y) => x + y,
-    StringRepeat: (_loc_id, _source_map) => (x, y) => y > 0n ? x.repeat(Number(y)) : "",
-    StringLength: (_loc_id, _source_map) => (x) => {
-        let len = 0;
-        for (const _ of x)
-            len++;
-        return BigInt(len);
-    },
-    StringSubstring: (_loc_id, _source_map) => (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: (_loc_id, _source_map) => (x) => x.toUpperCase(),
-    StringLowerCase: (_loc_id, _source_map) => (x) => x.toLowerCase(),
-    StringSplit: (_loc_id, _source_map) => (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: (_loc_id, _source_map) => (x) => x.trim(),
-    StringTrimStart: (_loc_id, _source_map) => (x) => x.trimStart(),
-    StringTrimEnd: (_loc_id, _source_map) => (x) => x.trimEnd(),
-    StringStartsWith: (_loc_id, _source_map) => (x, prefix) => x.startsWith(prefix),
-    StringEndsWith: (_loc_id, _source_map) => (x, suffix) => x.endsWith(suffix),
-    StringContains: (_loc_id, _source_map) => (x, substring) => x.includes(substring),
-    StringIndexOf: (_loc_id, _source_map) => (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: (_loc_id, _source_map) => (x, searchValue, replaceValue) => {
-        // Replace all occurrences (like JavaScript's string.replaceAll with string)
-        return x.replaceAll(searchValue, replaceValue);
-    },
-    RegexContains: (_loc_id, _source_map) => (text, pattern, flags) => {
-        const regex = new RegExp(pattern, flags);
-        return regex.test(text);
-    },
-    RegexIndexOf: (_loc_id, _source_map) => (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: (loc_id, source_map) => (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: (source_map?.resolve(loc_id) ?? []) });
-                }
-                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: (source_map?.resolve(loc_id) ?? []) });
-                        }
-                        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: (source_map?.resolve(loc_id) ?? []) });
-                        }
-                        i += 1;
-                        char2 = replacement[i];
-                    }
-                    if (i === init_i) {
-                        throw new EastError(`invalid regex replacement string: empty group name in $<>`, { location: (source_map?.resolve(loc_id) ?? []) });
-                    }
-                    i += 1; // for closing >
-                }
-                else {
-                    throw new EastError(`invalid regex replacement string: unescaped $ at $${char2}`, { location: (source_map?.resolve(loc_id) ?? []) });
-                }
-            }
-            else {
-                i += char.length;
-            }
-        }
-        return text.replaceAll(regex, replacement);
-    },
-    StringEncodeUtf8: (_loc_id, _source_map) => {
-        // do not add BOM for UTF-8
-        const encoder = new TextEncoder();
-        return (x) => {
-            return encoder.encode(x);
-        };
-    },
-    StringEncodeUtf16: (_loc_id, _source_map) => {
-        // 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: (loc_id, source_map, _platformDef, 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: (source_map?.resolve(loc_id) ?? []) });
-            }
-            try {
-                return fromJSON(parsed);
-            }
-            catch (e) {
-                throw new EastError(`Failed to convert JSON to ${printTypeValue(type)}: ${e.message}`, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-        };
-    },
-    StringPrintJSON: (loc_id, source_map, _platformDef, type) => {
-        const toJSON = toJSONFor(type);
-        return (x) => JSON.stringify(toJSON(x));
-    },
-    DateTimeGetYear: (_loc_id, _source_map) => (date) => BigInt(date.getUTCFullYear()),
-    DateTimeGetMonth: (_loc_id, _source_map) => (date) => BigInt(date.getUTCMonth() + 1), // JavaScript months are 0-based, East uses 1-based
-    DateTimeGetDayOfMonth: (_loc_id, _source_map) => (date) => BigInt(date.getUTCDate()),
-    DateTimeGetHour: (_loc_id, _source_map) => (date) => BigInt(date.getUTCHours()),
-    DateTimeGetMinute: (_loc_id, _source_map) => (date) => BigInt(date.getUTCMinutes()),
-    DateTimeGetSecond: (_loc_id, _source_map) => (date) => BigInt(date.getUTCSeconds()),
-    DateTimeGetDayOfWeek: (_loc_id, _source_map) => (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: (_loc_id, _source_map) => (date) => BigInt(date.getUTCMilliseconds()),
-    DateTimeAddMilliseconds: (_loc_id, _source_map) => (date, milliseconds) => new Date(date.getTime() + Number(milliseconds)),
-    DateTimeDurationMilliseconds: (_loc_id, _source_map) => (date1, date2) => BigInt(date1.getTime() - date2.getTime()),
-    DateTimeToEpochMilliseconds: (_loc_id, _source_map) => (date) => BigInt(date.getTime()),
-    DateTimeFromEpochMilliseconds: (_loc_id, _source_map) => (milliseconds) => new Date(Number(milliseconds)),
-    DateTimeFromComponents: (_loc_id, _source_map) => (year, month, day, hour, minute, second, millisecond) => {
-        const y = Number(year);
-        const date = new Date(Date.UTC(y, Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second), Number(millisecond)));
-        // `Date.UTC` applies JavaScript's legacy two-digit-year rule, remapping a
-        // year of 0-99 to 1900-1999. East years mean what they say (east-c sets
-        // `tm_year = year - 1900` and does no remapping), so undo it — on the
-        // ROLLED year, since an out-of-range month or day may have carried into
-        // it and the normalisation is part of the contract.
-        if (y >= 0 && y <= 99)
-            date.setUTCFullYear(date.getUTCFullYear() - 1900);
-        return date;
-    },
-    DateTimePrintFormat: (_loc_id, _source_map) => (date, tokens) => {
-        return formatDateTime(date, tokens);
-    },
-    DateTimeParseFormat: (loc_id, source_map) => (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: (source_map?.resolve(loc_id) ?? []) });
-        }
-    },
-    BlobSize: (_loc_id, _source_map) => (data) => BigInt(data.length),
-    BlobGetUint8: (loc_id, source_map) => (data, index) => {
-        const i = Number(index);
-        if (i < 0 || i >= data.length) {
-            throw new EastError(`Blob index ${index} out of bounds`, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        else {
-            return BigInt(data[i]);
-        }
-    },
-    BlobDecodeUtf8: (loc_id, source_map) => {
-        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: (source_map?.resolve(loc_id) ?? []) });
-            }
-        };
-    },
-    BlobDecodeUtf16: (loc_id, source_map) => {
-        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: (source_map?.resolve(loc_id) ?? []) });
-            }
-        };
-    },
-    BlobEncodeBeast: (loc_id, source_map, _platformDef, type) => {
-        const encodeBeast = encodeBeastFor(type);
-        return (value) => {
-            return encodeBeast(value);
-        };
-    },
-    BlobDecodeBeast: (loc_id, source_map, _platformDef, type) => {
-        const decodeBeast = decodeBeastFor(type);
-        return (data) => {
-            try {
-                return decodeBeast(data);
-            }
-            catch (e) {
-                throw new EastError(`Failed to decode Beast data: ${e.message}`, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-        };
-    },
-    BlobEncodeBeast2: (loc_id, source_map, _platformDef, type) => {
-        const encodeBeast2 = encodeBeast2For(type);
-        return (value) => {
-            return encodeBeast2(value);
-        };
-    },
-    BlobDecodeBeast2: (loc_id, source_map, platformDef, type) => {
-        const decodeBeast2 = decodeBeast2For(type, { platform: platformDef });
-        return (data) => {
-            try {
-                return decodeBeast2(data);
-            }
-            catch (e) {
-                throw new EastError(`Failed to decode Beast2 data: ${e.message}`, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-        };
-    },
-    BlobOpenBeast2: (loc_id, source_map, platformDef, type) => {
-        // The frozen lazy open a runner gives a task input, at the expression
-        // level. The header names the wire type (both container versions), and
-        // paging or decoding by any other type would read garbage, so a mismatch
-        // is an error rather than a decode by the declared type. Whatever cannot
-        // page — a v4 container, an index-less blob, cross-segment aliasing, a
-        // gated element shape — decodes whole, frozen, with the same semantics.
-        // The whole decoder is built on first use: a paged blob never needs it.
-        let whole = null;
-        const open = openBeast2LazyFor(type, { platform: platformDef, frozen: true });
-        const lazySafe = isBeast2LazySafe(type, { frozen: true });
-        return (data) => {
-            try {
-                // One geometry read answers everything the open needs: the wire
-                // type, whether an index exists (it throws otherwise) and whether
-                // the segments are self-contained.
-                let extents = null;
-                try {
-                    extents = readBeast2Extents(data);
-                }
-                catch {
-                    extents = null;
-                }
-                const wire = extents !== null ? extents.typeValue : readBeast2Type(data);
-                if (!isTypeValueEqual(wire, type)) {
-                    throw new Error(`beast2: cannot open a blob of type ${printTypeValue(wire)} as ${printTypeValue(type)}`);
-                }
-                if (lazySafe && extents !== null && extents.selfContained)
-                    return open(data);
-                whole ??= decodeBeast2For(type, { platform: platformDef, frozen: true });
-                return whole(data);
-            }
-            catch (e) {
-                throw new EastError(`Failed to open Beast2 data: ${e.message}`, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-        };
-    },
-    BlobDecodeCsv: (loc_id, source_map, _platformDef, structType, _configType) => {
-        return (data, config) => {
-            try {
-                const decoder = decodeCsvFor(structType, config);
-                return decoder(data);
-            }
-            catch (e) {
-                throw new EastError(`Failed to decode CSV data: ${e.message}`, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-        };
-    },
-    ArrayEncodeCsv: (loc_id, source_map, _platformDef, structType, _configType) => {
-        return (data, config) => {
-            try {
-                const encoder = encodeCsvFor(structType, config);
-                return encoder(data);
-            }
-            catch (e) {
-                throw new EastError(`Failed to encode CSV data: ${e.message}`, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-        };
-    },
-    RefGet: (_loc_id, _source_map, _platformDef, _T) => (ref) => {
-        return ref.value;
-    },
-    RefUpdate: (loc_id, source_map, _platformDef, _T) => (ref, value) => {
-        if (isFrozenValue(ref)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        ref.value = value;
-        return null;
-    },
-    RefMerge: (loc_id, source_map, _platformDef, _T) => (ref, value, merger) => {
-        if (isFrozenValue(ref)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        const new_value = call_function(loc_id, source_map, merger, ref.value, value);
-        ref.value = new_value;
-        return null;
-    },
-    ArrayGenerate: (loc_id, source_map, _platformDef, _T) => (size, f) => {
-        const result = [];
-        for (let i = 0n; i < size; i += 1n) {
-            const v = call_function(loc_id, source_map, f, i);
-            result.push(v);
-        }
-        return result;
-    },
-    ArrayRange: (_loc_id, _source_map) => (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: (_loc_id, _source_map) => (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: (_loc_id, _source_map, _platformDef, _T) => (array) => BigInt(array.length),
-    ArrayHas: (_loc_id, _source_map, _platformDef, _T) => (array, key) => {
-        const i = Number(key);
-        return i >= 0 && i < array.length;
-    },
-    ArrayGet: (loc_id, source_map, _platformDef, _T) => (array, key) => {
-        const i = Number(key);
-        if (i < 0 || i >= array.length) {
-            throw new EastError(`Array index ${key} out of bounds`, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        else {
-            return array[i];
-        }
-    },
-    ArrayGetOrDefault: (loc_id, source_map, _platformDef, _T) => (array, key, defaultFn) => {
-        const i = Number(key);
-        if (i < 0 || i >= array.length) {
-            return call_function(loc_id, source_map, defaultFn, key);
-        }
-        else {
-            return array[i];
-        }
-    },
-    ArrayTryGet: (_loc_id, _source_map, _platformDef, _T) => (array, key) => {
-        const i = Number(key);
-        if (i < 0 || i >= array.length) {
-            return variant("none", null);
-        }
-        else {
-            return variant("some", array[i]);
-        }
-    },
-    ArrayUpdate: (loc_id, source_map, _platformDef, _T) => (array, key, value) => {
-        if (isFrozenValue(array)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        const i = Number(key);
-        if (i < 0 || i >= array.length) {
-            throw new EastError(`Array index ${key} out of bounds`, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        else {
-            array[i] = value;
-            return null;
-        }
-    },
-    ArrayMerge: (loc_id, source_map, _platformDef, _T) => (array, key, value, merger) => {
-        if (isFrozenValue(array)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        const i = Number(key);
-        if (i < 0 || i >= array.length) {
-            throw new EastError(`Array index ${key} out of bounds`, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        else {
-            const new_value = call_function(loc_id, source_map, merger, array[i], value, key);
-            array[i] = new_value;
-            return null;
-        }
-    },
-    ArrayPushLast: (loc_id, source_map, _platformDef, _T) => (array, value) => {
-        if (isFrozenValue(array)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(array) || 0) > 0) {
-            throw new EastError("Cannot modify Array during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        array.push(value);
-        return null;
-    },
-    ArrayPopLast: (loc_id, source_map, _platformDef, _T) => (array) => {
-        if (isFrozenValue(array)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(array) || 0) > 0) {
-            throw new EastError("Cannot modify Array during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if (array.length === 0) {
-            throw new EastError("Cannot pop from empty Array", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        else {
-            return array.pop();
-        }
-    },
-    ArrayPushFirst: (loc_id, source_map, _platformDef, _T) => (array, value) => {
-        if (isFrozenValue(array)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(array) || 0) > 0) {
-            throw new EastError("Cannot modify Array during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        array.unshift(value);
-        return null;
-    },
-    ArrayPopFirst: (loc_id, source_map, _platformDef, _T) => (array) => {
-        if (isFrozenValue(array)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(array) || 0) > 0) {
-            throw new EastError("Cannot modify Array during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if (array.length === 0) {
-            throw new EastError("Cannot pop from empty Array", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        else {
-            return array.shift();
-        }
-    },
-    ArrayAppend: (loc_id, source_map, _platformDef, _T) => (array, other) => {
-        if (isFrozenValue(array)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(array) || 0) > 0) {
-            throw new EastError("Cannot modify Array during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        array.push(...other);
-        return null;
-    },
-    ArrayPrepend: (loc_id, source_map, _platformDef, _T) => (array, other) => {
-        if (isFrozenValue(array)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(array) || 0) > 0) {
-            throw new EastError("Cannot modify Array during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        array.unshift(...other);
-        return null;
-    },
-    ArrayMergeAll: (loc_id, source_map, _platformDef, _T, _T2) => (array, other, merger) => {
-        if (isFrozenValue(array)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        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(loc_id, source_map, merger, array[i], other[i], key);
-                    array[i] = new_value;
-                }
-                else {
-                    throw new EastError(`Array index ${key} out of bounds`, { location: (source_map?.resolve(loc_id) ?? []) });
-                }
-            }
-        }
-        finally {
-            unlockForIteration(other);
-            unlockForIteration(array);
-        }
-        return null;
-    },
-    ArrayClear: (loc_id, source_map, _platformDef, _T) => (array) => {
-        if (isFrozenValue(array)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(array) || 0) > 0) {
-            throw new EastError("Cannot modify Array during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        array.length = 0;
-        return null;
-    },
-    ArraySortInPlace: (loc_id, source_map, _platformDef, T, T2) => (array, by) => {
-        if (isFrozenValue(array)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(array) || 0) > 0) {
-            throw new EastError("Cannot modify Array during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        lockForIteration(array);
-        try {
-            const cmp = compareFor(T2);
-            array.sort((a, b) => {
-                const projectedA = call_function(loc_id, source_map, by, a);
-                const projectedB = call_function(loc_id, source_map, by, b);
-                return cmp(projectedA, projectedB);
-            });
-        }
-        finally {
-            unlockForIteration(array);
-        }
-        return null;
-    },
-    ArrayReverseInPlace: (loc_id, source_map, _platformDef, _T) => (array) => {
-        if (isFrozenValue(array)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(array) || 0) > 0) {
-            throw new EastError("Cannot modify Array during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        array.reverse();
-        return null;
-    },
-    ArraySort: (loc_id, source_map, _platformDef, T, T2) => (array, by) => {
-        const cmp = compareFor(T2);
-        const newArray = [...array];
-        newArray.sort((a, b) => {
-            const projectedA = call_function(loc_id, source_map, by, a);
-            const projectedB = call_function(loc_id, source_map, by, b);
-            return cmp(projectedA, projectedB);
-        });
-        return newArray;
-    },
-    ArrayReverse: (_loc_id, _source_map, _platformDef, _T) => (array) => {
-        const newArray = [...array];
-        newArray.reverse();
-        return newArray;
-    },
-    ArrayIsSorted: (loc_id, source_map, _platformDef, T, T2) => {
-        const cmp = compareFor(T2);
-        return (array, by) => {
-            if (array.length < 2)
-                return true;
-            lockForIteration(array);
-            try {
-                let projectedPrev = call_function(loc_id, source_map, by, array[0]);
-                for (let i = 1; i < array.length; i++) {
-                    const projectedCurr = call_function(loc_id, source_map, by, array[i]);
-                    if (cmp(projectedPrev, projectedCurr) > 0) {
-                        return false;
-                    }
-                    projectedPrev = projectedCurr;
-                }
-            }
-            finally {
-                unlockForIteration(array);
-            }
-            return true;
-        };
-    },
-    ArrayFindSortedFirst: (loc_id, source_map, _platformDef, 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(loc_id, source_map, by, array[mid]);
-                    if (cmp(projectedMid, key) < 0) {
-                        low = mid + 1;
-                    }
-                    else {
-                        high = mid;
-                    }
-                }
-            }
-            finally {
-                unlockForIteration(array);
-            }
-            return BigInt(low);
-        };
-    },
-    ArrayFindSortedLast: (loc_id, source_map, _platformDef, 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(loc_id, source_map, by, array[mid]);
-                    if (cmp(projectedMid, key) <= 0) {
-                        low = mid + 1;
-                    }
-                    else {
-                        high = mid;
-                    }
-                }
-            }
-            finally {
-                unlockForIteration(array);
-            }
-            return BigInt(low);
-        };
-    },
-    ArrayFindSortedRange: (loc_id, source_map, _platformDef, 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(loc_id, source_map, 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(loc_id, source_map, 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(loc_id, source_map, 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: (loc_id, source_map, _platformDef, 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(loc_id, source_map, by, array[i]);
-                    if (cmp(projected, value) === 0) {
-                        return variant("some", BigInt(i));
-                    }
-                }
-                return variant("none", null);
-            }
-            finally {
-                unlockForIteration(array);
-            }
-        };
-    },
-    ArrayConcat: (_loc_id, _source_map, _platformDef, _T) => (a1, a2) => {
-        return [...a1, ...a2];
-    },
-    ArraySlice: (_loc_id, _source_map, _platformDef, _T) => (array, start, end) => {
-        const startNum = Number(start);
-        const endNum = Number(end);
-        return array.slice(startNum, endNum);
-    },
-    ArrayGetKeys: (loc_id, source_map, _platformDef, _T) => (array, keys, onMissing) => {
-        return keys.map(k => {
-            const i = Number(k);
-            if (i < 0 || i >= array.length) {
-                return call_function(loc_id, source_map, onMissing, k);
-            }
-            else {
-                return array[i];
-            }
-        });
-    },
-    ArrayForEach: (loc_id, source_map, _platformDef, _T, _T2) => (array, f) => {
-        lockForIteration(array);
-        try {
-            array.forEach((x, i) => {
-                return call_function(loc_id, source_map, f, x, BigInt(i));
-            });
-            return null;
-        }
-        finally {
-            unlockForIteration(array);
-        }
-    },
-    ArrayCopy: (_loc_id, _source_map, _platformDef, _T) => (array) => {
-        return [...array];
-    },
-    ArrayMap: (loc_id, source_map, _platformDef, _T, _T2) => (array, f) => {
-        lockForIteration(array);
-        try {
-            return array.map((x, i) => {
-                return call_function(loc_id, source_map, f, x, BigInt(i));
-            });
-        }
-        finally {
-            unlockForIteration(array);
-        }
-    },
-    ArrayFilter: (loc_id, source_map, _platformDef, _T, _T2) => (array, f) => {
-        lockForIteration(array);
-        try {
-            return array.filter((x, i) => {
-                return call_function(loc_id, source_map, f, x, BigInt(i));
-            });
-        }
-        finally {
-            unlockForIteration(array);
-        }
-    },
-    ArrayFilterMap: (loc_id, source_map, _platformDef, _T, _T2) => (array, f) => {
-        lockForIteration(array);
-        try {
-            const result = [];
-            for (let i = 0; i < array.length; i++) {
-                const v = call_function(loc_id, source_map, f, array[i], BigInt(i));
-                if (v.type === "some") {
-                    result.push(v.value);
-                }
-            }
-            return result;
-        }
-        finally {
-            unlockForIteration(array);
-        }
-    },
-    ArrayFirstMap: (loc_id, source_map, _platformDef, _T, _T2) => (array, f) => {
-        lockForIteration(array);
-        try {
-            for (let i = 0; i < array.length; i++) {
-                const v = call_function(loc_id, source_map, f, array[i], BigInt(i));
-                if (v.type === "some") {
-                    return v;
-                }
-            }
-            return variant("none", null);
-        }
-        finally {
-            unlockForIteration(array);
-        }
-    },
-    ArrayFold: (loc_id, source_map, _platformDef, _T, _T2) => (array, init, f) => {
-        lockForIteration(array);
-        try {
-            return array.reduce((acc, x, i) => {
-                return call_function(loc_id, source_map, f, acc, x, BigInt(i));
-            }, init);
-        }
-        finally {
-            unlockForIteration(array);
-        }
-    },
-    ArrayScan: (loc_id, source_map, _platformDef, _T, _T2) => (array, init, f) => {
-        lockForIteration(array);
-        try {
-            const result = [];
-            let acc = init;
-            for (let i = 0; i < array.length; i++) {
-                acc = call_function(loc_id, source_map, f, acc, array[i], BigInt(i));
-                result.push(acc);
-            }
-            return result;
-        }
-        finally {
-            unlockForIteration(array);
-        }
-    },
-    ArrayMapReduce: (loc_id, source_map, _platformDef, _T, _T2) => (array, mapFn, reduceFn) => {
-        if (array.length === 0) {
-            throw new EastError("Cannot reduce empty array with no initial value", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        lockForIteration(array);
-        try {
-            let acc = call_function(loc_id, source_map, mapFn, array[0], 0n);
-            for (let i = 1; i < array.length; i++) {
-                const mapped = call_function(loc_id, source_map, mapFn, array[i], BigInt(i));
-                acc = call_function(loc_id, source_map, reduceFn, acc, mapped);
-            }
-            return acc;
-        }
-        finally {
-            unlockForIteration(array);
-        }
-    },
-    ArrayStringJoin: (_loc_id, _source_map, _platformDef) => (x, y) => x.join(y),
-    ArrayToSet: (loc_id, source_map, _platformDef, _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(loc_id, source_map, f, array[i], BigInt(i));
-                    result.add(v);
-                }
-                return result;
-            }
-            finally {
-                unlockForIteration(array);
-            }
-        };
-    },
-    ArrayToDict: (loc_id, source_map, _platformDef, _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(loc_id, source_map, keyFn, v, BigInt(i));
-                    let val = call_function(loc_id, source_map, valueFn, v, BigInt(i));
-                    const existing = result.get(k);
-                    if (existing === undefined) {
-                        result.set(k, val);
-                    }
-                    else {
-                        val = call_function(loc_id, source_map, onConflict, existing, val, k);
-                        result.set(k, val);
-                    }
-                }
-                return result;
-            }
-            finally {
-                unlockForIteration(array);
-            }
-        };
-    },
-    ArrayFlattenToArray: (loc_id, source_map, _platformDef, _T) => (array, fn) => {
-        return array.flatMap(v => {
-            return call_function(loc_id, source_map, fn, v);
-        });
-    },
-    ArrayFlattenToSet: (loc_id, source_map, _platformDef, _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(loc_id, source_map, fn, v);
-                    for (const k of subset) {
-                        result.add(k);
-                    }
-                }
-                return result;
-            }
-            finally {
-                unlockForIteration(array);
-            }
-        };
-    },
-    ArrayFlattenToDict: (loc_id, source_map, _platformDef, _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(loc_id, source_map, 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(loc_id, source_map, onConflict, existing, val, k);
-                            result.set(k, new_val);
-                        }
-                    }
-                }
-                return result;
-            }
-            finally {
-                unlockForIteration(array);
-            }
-        };
-    },
-    ArrayGroupFold: (loc_id, source_map, _platformDef, _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(loc_id, source_map, keyFn, v, BigInt(i));
-                    let existing = result.get(k);
-                    if (existing === undefined) {
-                        existing = call_function(loc_id, source_map, init, k);
-                    }
-                    const new_val = call_function(loc_id, source_map, folder, existing, v, BigInt(i));
-                    result.set(k, new_val);
-                }
-                return result;
-            }
-            finally {
-                unlockForIteration(array);
-            }
-        };
-    },
-    SetGenerate: (loc_id, source_map, _platformDef, 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(loc_id, source_map, keyFn, i);
-                if (result.has(k)) {
-                    call_function(loc_id, source_map, onConflict, k);
-                }
-                else {
-                    result.add(k);
-                }
-            }
-            return result;
-        };
-    },
-    SetSize: (_loc_id, _source_map, _platformDef, _K) => (s) => BigInt(s.size),
-    SetHas: (_loc_id, _source_map, _platformDef, _K) => (s, key) => s.has(key),
-    SetInsert: (loc_id, source_map, _platformDef, K) => {
-        const print = printFor(K);
-        return (s, key) => {
-            if (isFrozenValue(s)) {
-                throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            if ((iterationLocks.get(s) || 0) > 0) {
-                throw new EastError("Cannot modify Set during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            const size_before = s.size;
-            s.add(key);
-            if (s.size === size_before) {
-                throw new EastError(`Set already contains key ${print(key)}`, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            return null;
-        };
-    },
-    SetTryInsert: (loc_id, source_map, _platformDef, _K) => (s, key) => {
-        if (isFrozenValue(s)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(s) || 0) > 0) {
-            throw new EastError("Cannot modify Set during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        const size_before = s.size;
-        s.add(key);
-        return s.size > size_before;
-    },
-    SetDelete: (loc_id, source_map, _platformDef, K) => {
-        const print = printFor(K);
-        return (s, key) => {
-            if (isFrozenValue(s)) {
-                throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            if ((iterationLocks.get(s) || 0) > 0) {
-                throw new EastError("Cannot modify Set during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            if (!s.delete(key)) {
-                throw new EastError(`Set does not contain key ${print(key)}`, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            return null;
-        };
-    },
-    SetTryDelete: (loc_id, source_map, _platformDef, _K) => (s, key) => {
-        if (isFrozenValue(s)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(s) || 0) > 0) {
-            throw new EastError("Cannot modify Set during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        return s.delete(key);
-    },
-    SetClear: (loc_id, source_map, _platformDef, _K) => (s) => {
-        if (isFrozenValue(s)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(s) || 0) > 0) {
-            throw new EastError("Cannot modify Set during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        s.clear();
-        return null;
-    },
-    SetUnionInPlace: (loc_id, source_map, _platformDef, _K) => (s1, s2) => {
-        if (isFrozenValue(s1)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(s1) || 0) > 0) {
-            throw new EastError("Cannot modify Set during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        s2.forEach(v => s1.add(v));
-        return null;
-    },
-    SetUnion: (_loc_id, _source_map, _platformDef, _K) => (s1, s2) => s1.union(s2),
-    SetIntersect: (_loc_id, _source_map, _platformDef, _K) => (s1, s2) => s1.intersection(s2),
-    SetDiff: (_loc_id, _source_map, _platformDef, _K) => (s1, s2) => s1.difference(s2),
-    SetSymDiff: (_loc_id, _source_map, _platformDef, _K) => (s1, s2) => s1.symmetricDifference(s2),
-    SetIsSubset: (_loc_id, _source_map, _platformDef, _K) => (s1, s2) => s1.isSubsetOf(s2),
-    SetIsDisjoint: (_loc_id, _source_map, _platformDef, _K) => (s1, s2) => s1.isDisjointFrom(s2),
-    SetCopy: (loc_id, source_map, _platformDef, K) => {
-        const compare = compareFor(K);
-        return (s) => {
-            return new SortedSet([...s], compare);
-        };
-    },
-    SetForEach: (loc_id, source_map, _platformDef, _K, _T2) => (s, f) => {
-        lockForIteration(s);
-        try {
-            s.forEach(x => {
-                call_function(loc_id, source_map, f, x);
-            });
-            return null;
-        }
-        finally {
-            unlockForIteration(s);
-        }
-    },
-    SetFilter: (loc_id, source_map, _platformDef, K) => {
-        const compare = compareFor(K);
-        return (s, f) => {
-            const result = new SortedSet([], compare);
-            lockForIteration(s);
-            try {
-                s.forEach(x => {
-                    const keep = call_function(loc_id, source_map, f, x);
-                    if (keep) {
-                        result.add(x);
-                    }
-                });
-                return result;
-            }
-            finally {
-                unlockForIteration(s);
-            }
-        };
-    },
-    SetFilterMap: (loc_id, source_map, _platformDef, K, _V2) => {
-        const compare = compareFor(K);
-        return (s, f) => {
-            const result = new SortedMap([], compare);
-            lockForIteration(s);
-            try {
-                s.forEach(k => {
-                    const v2 = call_function(loc_id, source_map, f, k);
-                    if (v2.type === "some") {
-                        result.set(k, v2.value);
-                    }
-                });
-                return result;
-            }
-            finally {
-                unlockForIteration(s);
-            }
-        };
-    },
-    SetFirstMap: (loc_id, source_map, _platformDef, _K, _T2) => (s, f) => {
-        lockForIteration(s);
-        try {
-            for (const k of s) {
-                const v = call_function(loc_id, source_map, f, k);
-                if (v.type === "some") {
-                    return v;
-                }
-            }
-            return variant("none", null);
-        }
-        finally {
-            unlockForIteration(s);
-        }
-    },
-    SetMapReduce: (loc_id, source_map, _platformDef, _K, _T2) => (s, mapFn, reduceFn) => {
-        if (s.size === 0) {
-            throw new EastError("Cannot reduce empty set with no initial value", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        lockForIteration(s);
-        try {
-            const iterator = s[Symbol.iterator]();
-            const first = iterator.next().value;
-            let acc = call_function(loc_id, source_map, mapFn, first);
-            for (const k of iterator) {
-                const mapped = call_function(loc_id, source_map, mapFn, k);
-                acc = call_function(loc_id, source_map, reduceFn, acc, mapped);
-            }
-            return acc;
-        }
-        finally {
-            unlockForIteration(s);
-        }
-    },
-    SetMap: (loc_id, source_map, _platformDef, K, _T2) => {
-        const compare = compareFor(K);
-        return (s, f) => {
-            const result = new SortedMap([], compare);
-            lockForIteration(s);
-            try {
-                s.forEach(x => {
-                    const v = call_function(loc_id, source_map, f, x);
-                    result.set(x, v);
-                });
-                return result;
-            }
-            finally {
-                unlockForIteration(s);
-            }
-        };
-    },
-    SetReduce: (loc_id, source_map, _platformDef, _K, _T2) => (s, f, init) => {
-        let acc = init;
-        lockForIteration(s);
-        try {
-            for (const x of s) {
-                acc = call_function(loc_id, source_map, f, acc, x);
-            }
-            return acc;
-        }
-        finally {
-            unlockForIteration(s);
-        }
-    },
-    SetScan: (loc_id, source_map, _platformDef, _K, _T2) => (s, f, init) => {
-        const result = [];
-        let acc = init;
-        lockForIteration(s);
-        try {
-            for (const x of s) {
-                acc = call_function(loc_id, source_map, f, acc, x);
-                result.push(acc);
-            }
-            return result;
-        }
-        finally {
-            unlockForIteration(s);
-        }
-    },
-    SetToArray: (loc_id, source_map, _platformDef, _K, _T2) => (s, valueFn) => {
-        const ret = [];
-        lockForIteration(s);
-        try {
-            for (const k of s) {
-                const v = call_function(loc_id, source_map, valueFn, k);
-                ret.push(v);
-            }
-            return ret;
-        }
-        finally {
-            unlockForIteration(s);
-        }
-    },
-    SetToSet: (loc_id, source_map, _platformDef, 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(loc_id, source_map, f, x);
-                    result.add(v);
-                }
-                ;
-                return result;
-            }
-            finally {
-                unlockForIteration(s);
-            }
-        };
-    },
-    SetToDict: (loc_id, source_map, _platformDef, 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(loc_id, source_map, keyFn, k);
-                    let v2 = call_function(loc_id, source_map, valueFn, k);
-                    const existing = result.get(k2);
-                    if (existing !== undefined) {
-                        v2 = call_function(loc_id, source_map, onConflict, existing, v2, k2);
-                        result.set(k2, v2);
-                    }
-                    else {
-                        result.set(k2, v2);
-                    }
-                }
-                return result;
-            }
-            finally {
-                unlockForIteration(s);
-            }
-        };
-    },
-    SetFlattenToArray: (loc_id, source_map, _platformDef, _K, _T2) => (s, fn) => {
-        const ret = [];
-        lockForIteration(s);
-        try {
-            for (const k of s) {
-                const subarray = call_function(loc_id, source_map, fn, k);
-                ret.push(...subarray);
-            }
-            return ret;
-        }
-        finally {
-            unlockForIteration(s);
-        }
-    },
-    SetFlattenToSet: (loc_id, source_map, _platformDef, _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(loc_id, source_map, fn, k);
-                    for (const k2 of subset) {
-                        result.add(k2);
-                    }
-                }
-                return result;
-            }
-            finally {
-                unlockForIteration(s);
-            }
-        };
-    },
-    SetFlattenToDict: (loc_id, source_map, _platformDef, _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(loc_id, source_map, 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(loc_id, source_map, onConflict, existing, v2, k2);
-                            result.set(k2, new_v2);
-                        }
-                    }
-                }
-                return result;
-            }
-            finally {
-                unlockForIteration(s);
-            }
-        };
-    },
-    SetGroupFold: (loc_id, source_map, _platformDef, _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(loc_id, source_map, keyFn, k);
-                    let existing = result.get(k2);
-                    if (existing === undefined) {
-                        existing = call_function(loc_id, source_map, init, k2);
-                    }
-                    const new_val = call_function(loc_id, source_map, folder, existing, k);
-                    result.set(k2, new_val);
-                }
-                return result;
-            }
-            finally {
-                unlockForIteration(s);
-            }
-        };
-    },
-    DictGenerate: (loc_id, source_map, _platformDef, 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(loc_id, source_map, keyFn, i);
-                const v = call_function(loc_id, source_map, valueFn, i);
-                const existing = result.get(k);
-                if (existing !== undefined) {
-                    const v2 = call_function(loc_id, source_map, onConflict, existing, v, k);
-                    result.set(k, v2);
-                }
-                else {
-                    result.set(k, v);
-                }
-            }
-            return result;
-        };
-    },
-    DictSize: (_loc_id, _source_map, _platformDef, _K, _V) => (d) => BigInt(d.size),
-    DictHas: (_loc_id, _source_map, _platformDef, _K, _V) => (d, key) => d.has(key),
-    DictGet: (loc_id, source_map, _platformDef, 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: (source_map?.resolve(loc_id) ?? []) });
-            }
-            else {
-                return result;
-            }
-        };
-    },
-    DictGetOrDefault: (loc_id, source_map, _platformDef, _K, _V) => (d, key, onMissingFn) => {
-        const result = d.get(key);
-        if (result === undefined) {
-            return call_function(loc_id, source_map, onMissingFn, key);
-        }
-        else {
-            return result;
-        }
-    },
-    DictTryGet: (_loc_id, _source_map, _platformDef, _K, _V) => (d, key) => {
-        const result = d.get(key);
-        if (result === undefined) {
-            return variant("none", null);
-        }
-        else {
-            return variant("some", result);
-        }
-    },
-    DictInsert: (loc_id, source_map, _platformDef, K, _V) => {
-        const print = printFor(K);
-        return (d, key, value) => {
-            if (isFrozenValue(d)) {
-                throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            if ((iterationLocks.get(d) || 0) > 0) {
-                throw new EastError("Cannot modify Dict during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            const existing = d.get(key);
-            if (existing !== undefined) {
-                throw new EastError(`Dict already contains key ${print(key)}`, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            else {
-                d.set(key, value);
-            }
-            return null;
-        };
-    },
-    DictGetOrInsert: (loc_id, source_map, _platformDef, _K, _V) => (d, key, onMissing) => {
-        if (isFrozenValue(d)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(d) || 0) > 0) {
-            throw new EastError("Cannot modify Dict during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        const existing = d.get(key);
-        if (existing === undefined) {
-            const newValue = call_function(loc_id, source_map, onMissing, key);
-            d.set(key, newValue);
-            return newValue;
-        }
-        else {
-            return existing;
-        }
-    },
-    DictInsertOrUpdate: (loc_id, source_map, _platformDef, _K, _V) => (d, key, value, onConflictFn) => {
-        if (isFrozenValue(d)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(d) || 0) > 0) {
-            throw new EastError("Cannot modify Dict during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        const existing = d.get(key);
-        if (existing !== undefined) {
-            const result = call_function(loc_id, source_map, onConflictFn, existing, value, key);
-            d.set(key, result);
-        }
-        else {
-            d.set(key, value);
-        }
-        return null;
-    },
-    DictUpdate: (loc_id, source_map, _platformDef, K, _V) => {
-        const print = printFor(K);
-        return (d, key, value) => {
-            if (isFrozenValue(d)) {
-                throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            if (d.has(key)) {
-                d.set(key, value);
-                return null;
-            }
-            else {
-                throw new EastError(`Dict does not contain key ${print(key)}`, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-        };
-    },
-    DictSwap: (loc_id, source_map, _platformDef, K, _V) => {
-        const print = printFor(K);
-        return (d, key, value) => {
-            if (isFrozenValue(d)) {
-                throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            let existing = d.get(key);
-            if (existing === undefined) {
-                throw new EastError(`Dict does not contain key ${print(key)}`, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            d.set(key, value);
-            return existing;
-        };
-    },
-    DictMerge: (loc_id, source_map, _platformDef, _K, _V) => (d, key, value, mergeFn, initialFn) => {
-        if (isFrozenValue(d)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(d) || 0) > 0) {
-            throw new EastError("Cannot modify Dict during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        let existing = d.get(key);
-        if (existing === undefined) {
-            existing = call_function(loc_id, source_map, initialFn, key);
-        }
-        const new_value = call_function(loc_id, source_map, mergeFn, existing, value, key);
-        d.set(key, new_value);
-        return null;
-    },
-    DictDelete: (loc_id, source_map, _platformDef, K, _V) => {
-        const print = printFor(K);
-        return (d, key) => {
-            if (isFrozenValue(d)) {
-                throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            if ((iterationLocks.get(d) || 0) > 0) {
-                throw new EastError("Cannot modify Dict during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            const existed = d.delete(key);
-            if (!existed) {
-                throw new EastError(`Dict does not contain key ${print(key)}`, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            return null;
-        };
-    },
-    DictTryDelete: (loc_id, source_map, _platformDef, _K, _V) => (d, key) => {
-        if (isFrozenValue(d)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(d) || 0) > 0) {
-            throw new EastError("Cannot modify Dict during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        return d.delete(key);
-    },
-    DictPop: (loc_id, source_map, _platformDef, K, _V) => {
-        const print = printFor(K);
-        return (d, key) => {
-            if (isFrozenValue(d)) {
-                throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            if ((iterationLocks.get(d) || 0) > 0) {
-                throw new EastError("Cannot modify Dict during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            const existing = d.get(key);
-            if (existing === undefined) {
-                throw new EastError(`Dict does not contain key ${print(key)}`, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            else {
-                d.delete(key);
-                return existing;
-            }
-        };
-    },
-    DictClear: (loc_id, source_map, _platformDef, _K, _V) => (d) => {
-        if (isFrozenValue(d)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(d) || 0) > 0) {
-            throw new EastError("Cannot modify Dict during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        d.clear();
-        return null;
-    },
-    DictUnionInPlace: (loc_id, source_map, _platformDef, _K, _V) => (d1, d2, onConflict) => {
-        if (isFrozenValue(d1)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(d1) || 0) > 0) {
-            throw new EastError("Cannot modify Dict during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        d2.forEach((v2, k) => {
-            const v1 = d1.get(k);
-            if (v1 === undefined) {
-                d1.set(k, v2);
-            }
-            else {
-                const new_value = call_function(loc_id, source_map, onConflict, v1, v2, k);
-                d1.set(k, new_value);
-            }
-        });
-        return null;
-    },
-    DictMergeAll: (loc_id, source_map, _platformDef, _K, _V) => (d1, d2, mergeFn, initialFn) => {
-        if (isFrozenValue(d1)) {
-            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if ((iterationLocks.get(d1) || 0) > 0) {
-            throw new EastError("Cannot modify Dict during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        d2.forEach((v2, k) => {
-            let v1 = d1.get(k);
-            if (v1 === undefined) {
-                v1 = call_function(loc_id, source_map, initialFn, k);
-            }
-            const new_value = call_function(loc_id, source_map, mergeFn, v1, v2, k);
-            d1.set(k, new_value);
-        });
-        return null;
-    },
-    DictKeys: (loc_id, source_map, _platformDef, K, _V) => {
-        const compare = compareFor(K);
-        return (d) => {
-            return new SortedSet([...d.keys()], compare);
-        };
-    },
-    DictGetKeys: (loc_id, source_map, _platformDef, 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(loc_id, source_map, onMissing, k);
-                    result.set(k, new_v);
-                }
-            }
-            return result;
-        };
-    },
-    DictForEach: (loc_id, source_map, _platformDef, _K, _V, _T2) => (d, f) => {
-        lockForIteration(d);
-        try {
-            d.forEach((v, k) => {
-                call_function(loc_id, source_map, f, v, k);
-            });
-            return null;
-        }
-        finally {
-            unlockForIteration(d);
-        }
-    },
-    DictCopy: (loc_id, source_map, _platformDef, K, _V) => {
-        const compare = compareFor(K);
-        return (d) => {
-            return new SortedMap([...d], compare);
-        };
-    },
-    DictMap: (loc_id, source_map, _platformDef, 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(loc_id, source_map, f, v, k);
-                    result.set(k, v2);
-                }
-                return result;
-            }
-            finally {
-                unlockForIteration(d);
-            }
-        };
-    },
-    DictFilter: (loc_id, source_map, _platformDef, 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(loc_id, source_map, f, v, k);
-                    if (keep) {
-                        result.set(k, v);
-                    }
-                }
-                return result;
-            }
-            finally {
-                unlockForIteration(d);
-            }
-        };
-    },
-    DictFilterMap: (loc_id, source_map, _platformDef, 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(loc_id, source_map, f, v, k);
-                    if (v2.type === "some") {
-                        result.set(k, v2.value);
-                    }
-                }
-                return result;
-            }
-            finally {
-                unlockForIteration(d);
-            }
-        };
-    },
-    DictFirstMap: (loc_id, source_map, _platformDef, _K, _V, _T2) => (d, f) => {
-        lockForIteration(d);
-        try {
-            for (const [k, v] of d) {
-                const result = call_function(loc_id, source_map, f, v, k);
-                if (result.type === "some") {
-                    return result;
-                }
-            }
-            return variant("none", null);
-        }
-        finally {
-            unlockForIteration(d);
-        }
-    },
-    DictMapReduce: (loc_id, source_map, _platformDef, _K, _V, _T2) => (d, mapFn, reduceFn) => {
-        if (d.size === 0) {
-            throw new EastError("Cannot reduce empty dictionary with no initial value", { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        lockForIteration(d);
-        try {
-            const iterator = d[Symbol.iterator]();
-            const first = iterator.next().value;
-            let acc = call_function(loc_id, source_map, mapFn, first[1], first[0]);
-            for (const [k, v] of iterator) {
-                const mapped = call_function(loc_id, source_map, mapFn, v, k);
-                acc = call_function(loc_id, source_map, reduceFn, acc, mapped);
-            }
-            return acc;
-        }
-        finally {
-            unlockForIteration(d);
-        }
-    },
-    DictReduce: (loc_id, source_map, _platformDef, _K, _V, _T2) => (d, f, init) => {
-        let acc = init;
-        lockForIteration(d);
-        try {
-            for (const [k, v] of d) {
-                acc = call_function(loc_id, source_map, f, acc, v, k);
-            }
-            return acc;
-        }
-        finally {
-            unlockForIteration(d);
-        }
-    },
-    DictScan: (loc_id, source_map, _platformDef, _K, _V, _T2) => (d, f, init) => {
-        const result = [];
-        let acc = init;
-        lockForIteration(d);
-        try {
-            for (const [k, v] of d) {
-                acc = call_function(loc_id, source_map, f, acc, v, k);
-                result.push(acc);
-            }
-            return result;
-        }
-        finally {
-            unlockForIteration(d);
-        }
-    },
-    DictToArray: (loc_id, source_map, _platformDef, _K, _V, _T2) => (d, valueFn) => {
-        const ret = [];
-        lockForIteration(d);
-        try {
-            for (const [k, v] of d) {
-                const v2 = call_function(loc_id, source_map, valueFn, v, k);
-                ret.push(v2);
-            }
-            return ret;
-        }
-        finally {
-            unlockForIteration(d);
-        }
-    },
-    DictToSet: (loc_id, source_map, _platformDef, _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(loc_id, source_map, fn, v, k);
-                    result.add(k2);
-                }
-                return result;
-            }
-            finally {
-                unlockForIteration(d);
-            }
-        };
-    },
-    DictToDict: (loc_id, source_map, _platformDef, 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(loc_id, source_map, keyFn, v, k);
-                    const v2 = call_function(loc_id, source_map, valueFn, v, k);
-                    const existing = result.get(k2);
-                    if (existing !== undefined) {
-                        const v3 = call_function(loc_id, source_map, onConflict, existing, v2, k2);
-                        result.set(k2, v3);
-                    }
-                    else {
-                        result.set(k2, v2);
-                    }
-                }
-                return result;
-            }
-            finally {
-                unlockForIteration(d);
-            }
-        };
-    },
-    DictFlattenToArray: (loc_id, source_map, _platformDef, _K, _V, _T2) => (d, fn) => {
-        const ret = [];
-        lockForIteration(d);
-        try {
-            for (const [k, v] of d.entries()) {
-                const subarray = call_function(loc_id, source_map, fn, v, k);
-                for (const item of subarray) {
-                    ret.push(item);
-                }
-            }
-            return ret;
-        }
-        finally {
-            unlockForIteration(d);
-        }
-    },
-    DictFlattenToSet: (loc_id, source_map, _platformDef, _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(loc_id, source_map, fn, v, k);
-                    for (const k2 of subset) {
-                        result.add(k2);
-                    }
-                }
-                return result;
-            }
-            finally {
-                unlockForIteration(d);
-            }
-        };
-    },
-    DictFlattenToDict: (loc_id, source_map, _platformDef, _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(loc_id, source_map, 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(loc_id, source_map, onConflict, existing, v2, k2);
-                            result.set(k2, new_v2);
-                        }
-                    }
-                }
-                return result;
-            }
-            finally {
-                unlockForIteration(d);
-            }
-        };
-    },
-    DictGroupFold: (loc_id, source_map, _platformDef, _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(loc_id, source_map, keyFn, v, k);
-                    let existing = result.get(k2);
-                    if (existing === undefined) {
-                        existing = call_function(loc_id, source_map, init, k2);
-                    }
-                    const new_val = call_function(loc_id, source_map, folder, existing, v, k);
-                    result.set(k2, new_val);
-                }
-                return result;
-            }
-            finally {
-                unlockForIteration(d);
-            }
-        };
-    },
-    // Vector builtins
-    VectorLength: (_loc_id, _source_map, _platformDef, _T) => (vec) => BigInt(vec.length),
-    VectorGet: (loc_id, source_map, _platformDef, _T) => (vec, idx) => {
-        const i = Number(idx);
-        if (i < 0 || i >= vec.length) {
-            throw new EastError(`Vector index ${idx} out of bounds (length ${vec.length})`, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        if (vec instanceof Uint8ClampedArray)
-            return vec[i] !== 0;
-        return vec[i];
-    },
-    VectorSet: (loc_id, source_map, _platformDef, _T) => (vec, idx, value) => {
-        const i = Number(idx);
-        if (i < 0 || i >= vec.length) {
-            throw new EastError(`Vector index ${idx} out of bounds (length ${vec.length})`, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        const result = vec.slice();
-        if (result instanceof Uint8ClampedArray) {
-            result[i] = value ? 1 : 0;
-        }
-        else {
-            result[i] = value;
-        }
-        return result;
-    },
-    VectorSlice: (loc_id, source_map, _platformDef, _T) => (vec, start, end) => {
-        const s = Number(start);
-        const e = Number(end);
-        if (s < 0 || e > vec.length || s > e) {
-            throw new EastError(`Vector slice [${start}, ${end}) out of bounds (length ${vec.length})`, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        return vec.slice(s, e);
-    },
-    VectorConcat: (loc_id, source_map, _platformDef, T) => (a, b) => {
-        const result = allocateTypedArray(T, a.length + b.length);
-        result.set(a);
-        result.set(b, a.length);
-        return result;
-    },
-    VectorFromArray: (loc_id, source_map, _platformDef, T) => (arr) => {
-        return createTypedArray(T, arr);
-    },
-    VectorToArray: (_loc_id, _source_map, _platformDef, _T) => (vec) => {
-        if (vec instanceof Uint8ClampedArray) {
-            return Array.from(vec, v => v !== 0);
-        }
-        if (vec instanceof BigInt64Array) {
-            const result = [];
-            for (let i = 0; i < vec.length; i++)
-                result.push(vec[i]);
-            return result;
-        }
-        return Array.from(vec);
-    },
-    VectorToMatrix: (loc_id, source_map, _platformDef, _T) => (vec, rows, cols) => {
-        const r = Number(rows);
-        const c = Number(cols);
-        if (r * c !== vec.length) {
-            throw new EastError(`Cannot reshape vector of length ${vec.length} to matrix ${r}×${c}`, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        return matrix(vec.slice(), r, c);
-    },
-    VectorZeros: (_loc_id, _source_map, _platformDef, T) => (len) => {
-        return allocateTypedArray(T, Number(len));
-    },
-    VectorOnes: (_loc_id, _source_map, _platformDef, T) => (len) => {
-        const arr = allocateTypedArray(T, Number(len));
-        arr.fill((arr instanceof BigInt64Array ? 1n : 1));
-        return arr;
-    },
-    VectorFill: (loc_id, source_map, _platformDef, T) => (len, value) => {
-        const n = Number(len);
-        if (T.type === "Float") {
-            const arr = new Float64Array(n);
-            arr.fill(value);
-            return arr;
-        }
-        else if (T.type === "Integer") {
-            const arr = new BigInt64Array(n);
-            arr.fill(value);
-            return arr;
-        }
-        else {
-            const arr = new Uint8ClampedArray(n);
-            arr.fill(value ? 1 : 0);
-            return arr;
-        }
-    },
-    VectorMap: (loc_id, source_map, _platformDef, _T, U) => (vec, f) => {
-        const len = vec.length;
-        const results = [];
-        for (let i = 0; i < len; i++) {
-            const elem = vec instanceof Uint8ClampedArray ? (vec[i] !== 0) : vec[i];
-            results.push(call_function(loc_id, source_map, f, elem, BigInt(i)));
-        }
-        return createTypedArray(U, results);
-    },
-    VectorFold: (loc_id, source_map, _platformDef, _T, _U) => (vec, init, f) => {
-        let acc = init;
-        for (let i = 0; i < vec.length; i++) {
-            const elem = vec instanceof Uint8ClampedArray ? (vec[i] !== 0) : vec[i];
-            acc = call_function(loc_id, source_map, f, acc, elem, BigInt(i));
-        }
-        return acc;
-    },
-    // Vector elementwise arithmetic + reductions. Reductions fold in index
-    // order, left to right — part of the cross-runtime contract, since a
-    // reassociated float sum gives a different last bit.
-    VectorScale: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("VectorScale", T, loc_id, source_map);
-        return (v, alpha) => {
-            if (elem === "Float") {
-                const result = new Float64Array(v.length);
-                for (let i = 0; i < v.length; i++)
-                    result[i] = v[i] * alpha;
-                return result;
-            }
-            const result = new BigInt64Array(v.length);
-            for (let i = 0; i < v.length; i++)
-                result[i] = wrapI64(v[i] * alpha);
-            return result;
-        };
-    },
-    VectorSum: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("VectorSum", T, loc_id, source_map);
-        return (v) => {
-            if (elem === "Float") {
-                let acc = 0;
-                for (let i = 0; i < v.length; i++)
-                    acc += v[i];
-                return acc;
-            }
-            let acc = 0n;
-            for (let i = 0; i < v.length; i++)
-                acc = wrapI64(acc + v[i]);
-            return acc;
-        };
-    },
-    VectorAddScaled: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("VectorAddScaled", T, loc_id, source_map);
-        return (a, b, alpha) => {
-            requireSameLength(a, b, loc_id, source_map);
-            if (elem === "Float") {
-                const result = new Float64Array(a.length);
-                for (let i = 0; i < a.length; i++)
-                    result[i] = a[i] + alpha * b[i];
-                return result;
-            }
-            const result = new BigInt64Array(a.length);
-            for (let i = 0; i < a.length; i++)
-                result[i] = wrapI64(a[i] + wrapI64(alpha * b[i]));
-            return result;
-        };
-    },
-    VectorMul: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("VectorMul", T, loc_id, source_map);
-        return (a, b) => {
-            requireSameLength(a, b, loc_id, source_map);
-            if (elem === "Float") {
-                const result = new Float64Array(a.length);
-                for (let i = 0; i < a.length; i++)
-                    result[i] = a[i] * b[i];
-                return result;
-            }
-            const result = new BigInt64Array(a.length);
-            for (let i = 0; i < a.length; i++)
-                result[i] = wrapI64(a[i] * b[i]);
-            return result;
-        };
-    },
-    VectorAddScalar: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("VectorAddScalar", T, loc_id, source_map);
-        return (v, c) => {
-            if (elem === "Float") {
-                const result = new Float64Array(v.length);
-                for (let i = 0; i < v.length; i++)
-                    result[i] = v[i] + c;
-                return result;
-            }
-            const result = new BigInt64Array(v.length);
-            for (let i = 0; i < v.length; i++)
-                result[i] = wrapI64(v[i] + c);
-            return result;
-        };
-    },
-    VectorDot: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("VectorDot", T, loc_id, source_map);
-        return (a, b) => {
-            requireSameLength(a, b, loc_id, source_map);
-            if (elem === "Float") {
-                let acc = 0;
-                for (let i = 0; i < a.length; i++)
-                    acc += a[i] * b[i];
-                return acc;
-            }
-            let acc = 0n;
-            for (let i = 0; i < a.length; i++)
-                acc = wrapI64(acc + wrapI64(a[i] * b[i]));
-            return acc;
-        };
-    },
-    VectorMax: (loc_id, source_map, _platformDef, T) => {
-        requireNumericElem("VectorMax", T, loc_id, source_map);
-        const less = lessFor(T);
-        return (v) => {
-            if (v.length === 0) {
-                throw new EastError("Cannot reduce empty Vector", { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            let best = v[0];
-            for (let i = 1; i < v.length; i++) {
-                if (less(best, v[i]))
-                    best = v[i];
-            }
-            return best;
-        };
-    },
-    VectorMin: (loc_id, source_map, _platformDef, T) => {
-        requireNumericElem("VectorMin", T, loc_id, source_map);
-        const less = lessFor(T);
-        return (v) => {
-            if (v.length === 0) {
-                throw new EastError("Cannot reduce empty Vector", { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            let best = v[0];
-            for (let i = 1; i < v.length; i++) {
-                if (less(v[i], best))
-                    best = v[i];
-            }
-            return best;
-        };
-    },
-    VectorArgMax: (loc_id, source_map, _platformDef, T) => {
-        requireNumericElem("VectorArgMax", T, loc_id, source_map);
-        const less = lessFor(T);
-        return (v) => {
-            if (v.length === 0) {
-                throw new EastError("Cannot reduce empty Vector", { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            let bestIdx = 0;
-            for (let i = 1; i < v.length; i++) {
-                if (less(v[bestIdx], v[i]))
-                    bestIdx = i;
-            }
-            return BigInt(bestIdx);
-        };
-    },
-    VectorArgMin: (loc_id, source_map, _platformDef, T) => {
-        requireNumericElem("VectorArgMin", T, loc_id, source_map);
-        const less = lessFor(T);
-        return (v) => {
-            if (v.length === 0) {
-                throw new EastError("Cannot reduce empty Vector", { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            let bestIdx = 0;
-            for (let i = 1; i < v.length; i++) {
-                if (less(v[i], v[bestIdx]))
-                    bestIdx = i;
-            }
-            return BigInt(bestIdx);
-        };
-    },
-    VectorMean: (loc_id, source_map, _platformDef, T) => {
-        requireNumericElem("VectorMean", T, loc_id, source_map);
-        return (v) => {
-            let acc = 0;
-            for (let i = 0; i < v.length; i++)
-                acc += Number(v[i]);
-            return acc / v.length;
-        };
-    },
-    VectorCumSum: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("VectorCumSum", T, loc_id, source_map);
-        return (v) => {
-            if (elem === "Float") {
-                const result = new Float64Array(v.length);
-                let acc = 0;
-                for (let i = 0; i < v.length; i++) {
-                    acc += v[i];
-                    result[i] = acc;
-                }
-                return result;
-            }
-            const result = new BigInt64Array(v.length);
-            let acc = 0n;
-            for (let i = 0; i < v.length; i++) {
-                acc = wrapI64(acc + v[i]);
-                result[i] = acc;
-            }
-            return result;
-        };
-    },
-    VectorAbs: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("VectorAbs", T, loc_id, source_map);
-        return (v) => {
-            if (elem === "Float") {
-                const result = new Float64Array(v.length);
-                for (let i = 0; i < v.length; i++) {
-                    const x = v[i];
-                    result[i] = x < 0 ? -x : x;
-                }
-                return result;
-            }
-            const result = new BigInt64Array(v.length);
-            for (let i = 0; i < v.length; i++) {
-                const x = v[i];
-                result[i] = wrapI64(x < 0n ? -x : x);
-            }
-            return result;
-        };
-    },
-    VectorClamp: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("VectorClamp", T, loc_id, source_map);
-        const less = lessFor(T);
-        return (v, lo, hi) => {
-            const result = elem === "Float" ? new Float64Array(v.length) : new BigInt64Array(v.length);
-            for (let i = 0; i < v.length; i++) {
-                const x = v[i];
-                result[i] = less(x, lo) ? lo : less(hi, x) ? hi : x;
-            }
-            return result;
-        };
-    },
-    // Vector gather/scatter and sorted search
-    VectorGather: (loc_id, source_map, _platformDef, T) => (v, idx) => {
-        const result = allocateTypedArray(T, idx.length);
-        for (let j = 0; j < idx.length; j++) {
-            const i = Number(idx[j]);
-            if (i < 0 || i >= v.length) {
-                throw new EastError(`Vector index ${idx[j]} out of bounds (length ${v.length})`, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            result[j] = v[i];
-        }
-        return result;
-    },
-    VectorScatterAdd: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("VectorScatterAdd", T, loc_id, source_map);
-        return (dst, idx, src) => {
-            requireSameLength(idx, src, loc_id, source_map);
-            const result = dst.slice();
-            for (let j = 0; j < idx.length; j++) {
-                const i = Number(idx[j]);
-                if (i < 0 || i >= dst.length) {
-                    throw new EastError(`Vector index ${idx[j]} out of bounds (length ${dst.length})`, { location: (source_map?.resolve(loc_id) ?? []) });
-                }
-                if (elem === "Float") {
-                    result[i] = (result[i]) + src[j];
-                }
-                else {
-                    result[i] = wrapI64((result[i]) + src[j]);
-                }
-            }
-            return result;
-        };
-    },
-    VectorSearchSorted: (loc_id, source_map, _platformDef, T) => {
-        const less = lessFor(T);
-        const readElem = T.type === "Boolean"
-            ? (v, i) => v[i] !== 0
-            : (v, i) => v[i];
-        return (haystack, needles) => {
-            const result = new BigInt64Array(needles.length);
-            for (let j = 0; j < needles.length; j++) {
-                const needle = readElem(needles, j);
-                let lo = 0;
-                let hi = haystack.length;
-                while (lo < hi) {
-                    const mid = (lo + hi) >>> 1;
-                    if (less(readElem(haystack, mid), needle)) {
-                        lo = mid + 1;
-                    }
-                    else {
-                        hi = mid;
-                    }
-                }
-                result[j] = BigInt(lo);
-            }
-            return result;
-        };
-    },
-    // Vector masks and selection (comparisons use East's total order)
-    VectorEq: (loc_id, source_map, _platformDef, T) => {
-        const equal = equalFor(T);
-        const readElem = T.type === "Boolean"
-            ? (v, i) => v[i] !== 0
-            : (v, i) => v[i];
-        return (a, b) => {
-            requireSameLength(a, b, loc_id, source_map);
-            const result = new Uint8ClampedArray(a.length);
-            for (let i = 0; i < a.length; i++)
-                result[i] = equal(readElem(a, i), readElem(b, i)) ? 1 : 0;
-            return result;
-        };
-    },
-    VectorLt: (loc_id, source_map, _platformDef, T) => {
-        const less = lessFor(T);
-        const readElem = T.type === "Boolean"
-            ? (v, i) => v[i] !== 0
-            : (v, i) => v[i];
-        return (a, b) => {
-            requireSameLength(a, b, loc_id, source_map);
-            const result = new Uint8ClampedArray(a.length);
-            for (let i = 0; i < a.length; i++)
-                result[i] = less(readElem(a, i), readElem(b, i)) ? 1 : 0;
-            return result;
-        };
-    },
-    VectorGt: (loc_id, source_map, _platformDef, T) => {
-        const greater = greaterFor(T);
-        const readElem = T.type === "Boolean"
-            ? (v, i) => v[i] !== 0
-            : (v, i) => v[i];
-        return (a, b) => {
-            requireSameLength(a, b, loc_id, source_map);
-            const result = new Uint8ClampedArray(a.length);
-            for (let i = 0; i < a.length; i++)
-                result[i] = greater(readElem(a, i), readElem(b, i)) ? 1 : 0;
-            return result;
-        };
-    },
-    VectorSelect: (loc_id, source_map, _platformDef, T) => (mask, a, b) => {
-        requireSameLength(mask, a, loc_id, source_map);
-        requireSameLength(a, b, loc_id, source_map);
-        const result = allocateTypedArray(T, mask.length);
-        for (let i = 0; i < mask.length; i++)
-            result[i] = (mask[i] !== 0 ? a[i] : b[i]);
-        return result;
-    },
-    VectorCompress: (loc_id, source_map, _platformDef, T) => (mask, v) => {
-        requireSameLength(mask, v, loc_id, source_map);
-        let count = 0;
-        for (let i = 0; i < mask.length; i++) {
-            if (mask[i] !== 0)
-                count++;
-        }
-        const result = allocateTypedArray(T, count);
-        let j = 0;
-        for (let i = 0; i < mask.length; i++) {
-            if (mask[i] !== 0)
-                result[j++] = v[i];
-        }
-        return result;
-    },
-    VectorCountTrue: (_loc_id, _source_map, _platformDef) => (mask) => {
-        let count = 0n;
-        for (let i = 0; i < mask.length; i++) {
-            if (mask[i] !== 0)
-                count += 1n;
-        }
-        return count;
-    },
-    // Sparse accumulators: parallel (ix, v) with strictly ascending ix.
-    // Entries absent from a side are structurally absent, not explicit zeros:
-    // an A-only entry passes through unscaled, a B-only entry contributes
-    // alpha*vB even when alpha is NaN or infinite.
-    SparseAxpy: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("SparseAxpy", T, loc_id, source_map);
-        return (ixA, vA, ixB, vB, alpha) => {
-            requireSparse(ixA, vA, loc_id, source_map);
-            requireSparse(ixB, vB, loc_id, source_map);
-            let count = 0;
-            let i = 0;
-            let j = 0;
-            while (i < ixA.length && j < ixB.length) {
-                const a = ixA[i];
-                const b = ixB[j];
-                if (a < b)
-                    i++;
-                else if (b < a)
-                    j++;
-                else {
-                    i++;
-                    j++;
-                }
-                count++;
-            }
-            count += (ixA.length - i) + (ixB.length - j);
-            const outIx = new BigInt64Array(count);
-            const outV = elem === "Float" ? new Float64Array(count) : new BigInt64Array(count);
-            i = 0;
-            j = 0;
-            let k = 0;
-            while (i < ixA.length && j < ixB.length) {
-                const a = ixA[i];
-                const b = ixB[j];
-                if (a < b) {
-                    outIx[k] = a;
-                    outV[k] = vA[i];
-                    i++;
-                }
-                else if (b < a) {
-                    outIx[k] = b;
-                    outV[k] = elem === "Float" ? alpha * vB[j] : wrapI64(alpha * vB[j]);
-                    j++;
-                }
-                else {
-                    outIx[k] = a;
-                    outV[k] = elem === "Float"
-                        ? vA[i] + alpha * vB[j]
-                        : wrapI64(vA[i] + wrapI64(alpha * vB[j]));
-                    i++;
-                    j++;
-                }
-                k++;
-            }
-            for (; i < ixA.length; i++, k++) {
-                outIx[k] = ixA[i];
-                outV[k] = vA[i];
-            }
-            for (; j < ixB.length; j++, k++) {
-                outIx[k] = ixB[j];
-                outV[k] = elem === "Float" ? alpha * vB[j] : wrapI64(alpha * vB[j]);
-            }
-            return { ix: outIx, v: outV };
-        };
-    },
-    SparseFromPairs: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("SparseFromPairs", T, loc_id, source_map);
-        return (ix, v) => {
-            if (ix.length !== v.length) {
-                throw new EastError(`Sparse index and value lengths differ (${ix.length} vs ${v.length})`, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            // Stable: order by (index, original position) so equal indices
-            // accumulate in input order and the float result is deterministic.
-            const order = new Array(ix.length);
-            for (let i = 0; i < ix.length; i++)
-                order[i] = i;
-            order.sort((p, q) => {
-                const a = ix[p];
-                const b = ix[q];
-                if (a < b)
-                    return -1;
-                if (a > b)
-                    return 1;
-                return p - q;
-            });
-            let count = 0;
-            for (let i = 0; i < order.length; i++) {
-                if (i === 0 || ix[order[i]] !== ix[order[i - 1]])
-                    count++;
-            }
-            const outIx = new BigInt64Array(count);
-            const outV = elem === "Float" ? new Float64Array(count) : new BigInt64Array(count);
-            let k = -1;
-            for (let i = 0; i < order.length; i++) {
-                const p = order[i];
-                if (i === 0 || ix[p] !== outIx[k]) {
-                    k++;
-                    outIx[k] = ix[p];
-                    outV[k] = v[p];
-                }
-                else {
-                    outV[k] = elem === "Float"
-                        ? (outV[k]) + v[p]
-                        : wrapI64((outV[k]) + v[p]);
-                }
-            }
-            return { ix: outIx, v: outV };
-        };
-    },
-    SparseFilterGt: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("SparseFilterGt", T, loc_id, source_map);
-        const greater = greaterFor(T);
-        return (ix, v, threshold) => {
-            requireSparse(ix, v, loc_id, source_map);
-            let count = 0;
-            for (let i = 0; i < v.length; i++) {
-                if (greater(v[i], threshold))
-                    count++;
-            }
-            const outIx = new BigInt64Array(count);
-            const outV = elem === "Float" ? new Float64Array(count) : new BigInt64Array(count);
-            let k = 0;
-            for (let i = 0; i < v.length; i++) {
-                if (greater(v[i], threshold)) {
-                    outIx[k] = ix[i];
-                    outV[k] = v[i];
-                    k++;
-                }
-            }
-            return { ix: outIx, v: outV };
-        };
-    },
-    // Matrix builtins
-    MatrixRows: (_loc_id, _source_map, _platformDef, _T) => (m) => BigInt(m.rows),
-    MatrixCols: (_loc_id, _source_map, _platformDef, _T) => (m) => BigInt(m.cols),
-    MatrixGet: (loc_id, source_map, _platformDef, _T) => (m, row, col) => {
-        const r = Number(row);
-        const c = Number(col);
-        if (r < 0 || r >= m.rows || c < 0 || c >= m.cols) {
-            throw new EastError(`Matrix index (${row}, ${col}) out of bounds (${m.rows}×${m.cols})`, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        const val = m.data[r * m.cols + c];
-        if (m.data instanceof Uint8ClampedArray)
-            return val !== 0;
-        return val;
-    },
-    MatrixSet: (loc_id, source_map, _platformDef, _T) => (m, row, col, value) => {
-        const r = Number(row);
-        const c = Number(col);
-        if (r < 0 || r >= m.rows || c < 0 || c >= m.cols) {
-            throw new EastError(`Matrix index (${row}, ${col}) out of bounds (${m.rows}×${m.cols})`, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        const data = m.data.slice();
-        if (data instanceof Uint8ClampedArray) {
-            data[r * m.cols + c] = value ? 1 : 0;
-        }
-        else {
-            data[r * m.cols + c] = value;
-        }
-        return matrix(data, m.rows, m.cols);
-    },
-    MatrixGetRow: (loc_id, source_map, _platformDef, _T) => (m, row) => {
-        const r = Number(row);
-        if (r < 0 || r >= m.rows) {
-            throw new EastError(`Matrix row ${row} out of bounds (${m.rows} rows)`, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        const start = r * m.cols;
-        return m.data.slice(start, start + m.cols);
-    },
-    MatrixGetCol: (loc_id, source_map, _platformDef, T) => (m, col) => {
-        const c = Number(col);
-        if (c < 0 || c >= m.cols) {
-            throw new EastError(`Matrix column ${col} out of bounds (${m.cols} cols)`, { location: (source_map?.resolve(loc_id) ?? []) });
-        }
-        const result = allocateTypedArray(T, m.rows);
-        for (let r = 0; r < m.rows; r++)
-            result[r] = m.data[r * m.cols + c];
-        return result;
-    },
-    MatrixToVector: (_loc_id, _source_map, _platformDef, _T) => (m) => {
-        return m.data.slice();
-    },
-    MatrixFromArray: (loc_id, source_map, _platformDef, T) => (arr) => {
-        if (arr.length === 0) {
-            return matrix(createTypedArray(T, []), 0, 0);
-        }
-        const rows = arr.length;
-        const cols = arr[0].length;
-        for (let i = 1; i < rows; i++) {
-            if (arr[i].length !== cols) {
-                throw new EastError(`Jagged array: row 0 has ${cols} columns but row ${i} has ${arr[i].length}`, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-        }
-        const flat = [];
-        for (const row of arr) {
-            flat.push(...row);
-        }
-        return matrix(createTypedArray(T, flat), rows, cols);
-    },
-    MatrixToArray: (_loc_id, _source_map, _platformDef, _T) => (m) => {
-        const result = [];
-        for (let r = 0; r < m.rows; r++) {
-            const row = [];
-            for (let c = 0; c < m.cols; c++) {
-                const val = m.data[r * m.cols + c];
-                row.push(m.data instanceof Uint8ClampedArray ? val !== 0 : val);
-            }
-            result.push(row);
-        }
-        return result;
-    },
-    MatrixTranspose: (loc_id, source_map, _platformDef, T) => (m) => {
-        const result = allocateTypedArray(T, m.rows * m.cols);
-        for (let r = 0; r < m.rows; r++) {
-            for (let c = 0; c < m.cols; c++) {
-                result[c * m.rows + r] = m.data[r * m.cols + c];
-            }
-        }
-        return matrix(result, m.cols, m.rows);
-    },
-    MatrixZeros: (_loc_id, _source_map, _platformDef, T) => (rows, cols) => {
-        return matrix(allocateTypedArray(T, Number(rows) * Number(cols)), Number(rows), Number(cols));
-    },
-    MatrixOnes: (_loc_id, _source_map, _platformDef, T) => (rows, cols) => {
-        const data = allocateTypedArray(T, Number(rows) * Number(cols));
-        data.fill((data instanceof BigInt64Array ? 1n : 1));
-        return matrix(data, Number(rows), Number(cols));
-    },
-    MatrixFill: (loc_id, source_map, _platformDef, T) => (rows, cols, value) => {
-        const r = Number(rows);
-        const c = Number(cols);
-        const n = r * c;
-        if (T.type === "Float") {
-            const data = new Float64Array(n);
-            data.fill(value);
-            return matrix(data, r, c);
-        }
-        else if (T.type === "Integer") {
-            const data = new BigInt64Array(n);
-            data.fill(value);
-            return matrix(data, r, c);
-        }
-        else {
-            const data = new Uint8ClampedArray(n);
-            data.fill(value ? 1 : 0);
-            return matrix(data, r, c);
-        }
-    },
-    MatrixMapElements: (loc_id, source_map, _platformDef, _T, U) => (m, f) => {
-        const results = [];
-        for (let r = 0; r < m.rows; r++) {
-            for (let c = 0; c < m.cols; c++) {
-                const val = m.data[r * m.cols + c];
-                const elem = m.data instanceof Uint8ClampedArray ? val !== 0 : val;
-                results.push(call_function(loc_id, source_map, f, elem, BigInt(r), BigInt(c)));
-            }
-        }
-        return matrix(createTypedArray(U, results), m.rows, m.cols);
-    },
-    MatrixMapRows: (loc_id, source_map, _platformDef, _T, U) => (m, f) => {
-        const resultRows = [];
-        for (let r = 0; r < m.rows; r++) {
-            const start = r * m.cols;
-            const rowVec = m.data.slice(start, start + m.cols);
-            const resultRow = call_function(loc_id, source_map, f, rowVec, BigInt(r));
-            resultRows.push(resultRow);
-        }
-        if (resultRows.length === 0) {
-            return matrix(allocateTypedArray(U, 0), 0, 0);
-        }
-        const newCols = resultRows[0].length;
-        const data = allocateTypedArray(U, m.rows * newCols);
-        for (let r = 0; r < m.rows; r++) {
-            data.set(resultRows[r], r * newCols);
-        }
-        return matrix(data, m.rows, newCols);
-    },
-    MatrixToRows: (_loc_id, _source_map, _platformDef, _T) => (m) => {
-        const rows = [];
-        for (let r = 0; r < m.rows; r++) {
-            rows.push(m.data.slice(r * m.cols, (r + 1) * m.cols));
-        }
-        return rows;
-    },
-    MatrixFromRows: (loc_id, source_map, _platformDef, T) => (arr) => {
-        if (arr.length === 0) {
-            return matrix(allocateTypedArray(T, 0), 0, 0);
-        }
-        const cols = arr[0].length;
-        for (let i = 1; i < arr.length; i++) {
-            if (arr[i].length !== cols) {
-                throw new EastError(`Jagged rows: row 0 has ${cols} columns but row ${i} has ${arr[i].length}`, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-        }
-        const data = allocateTypedArray(T, arr.length * cols);
-        for (let r = 0; r < arr.length; r++)
-            data.set(arr[r], r * cols);
-        return matrix(data, arr.length, cols);
-    },
-    // Matrix elementwise arithmetic + reductions. Sums accumulate in ascending
-    // index order (row-major for whole-matrix walks, ascending row for column
-    // sums, ascending column within each row for row sums and vec-mul) — the
-    // same left-to-right contract as the Vector reductions.
-    MatrixScale: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("MatrixScale", T, loc_id, source_map);
-        return (m, alpha) => {
-            const src = m.data;
-            if (elem === "Float") {
-                const data = new Float64Array(src.length);
-                for (let i = 0; i < src.length; i++)
-                    data[i] = src[i] * alpha;
-                return matrix(data, m.rows, m.cols);
-            }
-            const data = new BigInt64Array(src.length);
-            for (let i = 0; i < src.length; i++)
-                data[i] = wrapI64(src[i] * alpha);
-            return matrix(data, m.rows, m.cols);
-        };
-    },
-    MatrixAddScaled: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("MatrixAddScaled", T, loc_id, source_map);
-        return (a, b, alpha) => {
-            requireSameDims(a, b, loc_id, source_map);
-            const ad = a.data;
-            const bd = b.data;
-            if (elem === "Float") {
-                const data = new Float64Array(ad.length);
-                for (let i = 0; i < ad.length; i++)
-                    data[i] = ad[i] + alpha * bd[i];
-                return matrix(data, a.rows, a.cols);
-            }
-            const data = new BigInt64Array(ad.length);
-            for (let i = 0; i < ad.length; i++)
-                data[i] = wrapI64(ad[i] + wrapI64(alpha * bd[i]));
-            return matrix(data, a.rows, a.cols);
-        };
-    },
-    MatrixMulElementwise: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("MatrixMulElementwise", T, loc_id, source_map);
-        return (a, b) => {
-            requireSameDims(a, b, loc_id, source_map);
-            const ad = a.data;
-            const bd = b.data;
-            if (elem === "Float") {
-                const data = new Float64Array(ad.length);
-                for (let i = 0; i < ad.length; i++)
-                    data[i] = ad[i] * bd[i];
-                return matrix(data, a.rows, a.cols);
-            }
-            const data = new BigInt64Array(ad.length);
-            for (let i = 0; i < ad.length; i++)
-                data[i] = wrapI64(ad[i] * bd[i]);
-            return matrix(data, a.rows, a.cols);
-        };
-    },
-    MatrixRowSums: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("MatrixRowSums", T, loc_id, source_map);
-        return (m) => {
-            const src = m.data;
-            if (elem === "Float") {
-                const result = new Float64Array(m.rows);
-                for (let r = 0; r < m.rows; r++) {
-                    let acc = 0;
-                    for (let c = 0; c < m.cols; c++)
-                        acc += src[r * m.cols + c];
-                    result[r] = acc;
-                }
-                return result;
-            }
-            const result = new BigInt64Array(m.rows);
-            for (let r = 0; r < m.rows; r++) {
-                let acc = 0n;
-                for (let c = 0; c < m.cols; c++)
-                    acc = wrapI64(acc + src[r * m.cols + c]);
-                result[r] = acc;
-            }
-            return result;
-        };
-    },
-    MatrixColSums: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("MatrixColSums", T, loc_id, source_map);
-        return (m) => {
-            const src = m.data;
-            if (elem === "Float") {
-                const result = new Float64Array(m.cols);
-                for (let c = 0; c < m.cols; c++) {
-                    let acc = 0;
-                    for (let r = 0; r < m.rows; r++)
-                        acc += src[r * m.cols + c];
-                    result[c] = acc;
-                }
-                return result;
-            }
-            const result = new BigInt64Array(m.cols);
-            for (let c = 0; c < m.cols; c++) {
-                let acc = 0n;
-                for (let r = 0; r < m.rows; r++)
-                    acc = wrapI64(acc + src[r * m.cols + c]);
-                result[c] = acc;
-            }
-            return result;
-        };
-    },
-    MatrixVecMul: (loc_id, source_map, _platformDef, T) => {
-        const elem = requireNumericElem("MatrixVecMul", T, loc_id, source_map);
-        return (m, v) => {
-            if (v.length !== m.cols) {
-                throw new EastError(`MatrixVecMul dimension mismatch (${m.rows}x${m.cols} vs length ${v.length})`, { location: (source_map?.resolve(loc_id) ?? []) });
-            }
-            const src = m.data;
-            if (elem === "Float") {
-                const result = new Float64Array(m.rows);
-                for (let r = 0; r < m.rows; r++) {
-                    let acc = 0;
-                    for (let c = 0; c < m.cols; c++)
-                        acc += src[r * m.cols + c] * v[c];
-                    result[r] = acc;
-                }
-                return result;
-            }
-            const result = new BigInt64Array(m.rows);
-            for (let r = 0; r < m.rows; r++) {
-                let acc = 0n;
-                for (let c = 0; c < m.cols; c++)
-                    acc = wrapI64(acc + wrapI64(src[r * m.cols + c] * v[c]));
-                result[r] = acc;
-            }
-            return result;
-        };
-    },
-};
-/** @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") {
-        return variant("Function", { inputs: t.value.inputs.map(i => applyTypeParameters(i, params)), output: applyTypeParameters(t.value.output, params) });
-    }
-    else if (t.type === "AsyncFunction") {
-        return variant("AsyncFunction", { inputs: t.value.inputs.map(i => applyTypeParameters(i, params)), output: applyTypeParameters(t.value.output, params) });
-    }
-    else if (t.type === "Vector") {
-        return variant("Vector", applyTypeParameters(t.value, params));
-    }
-    else if (t.type === "Matrix") {
-        return variant("Matrix", applyTypeParameters(t.value, params));
-    }
-    else {
-        throw new Error(`Unhandled type ${t.type}`);
-    }
-}
+/* The TypeScript runtime's compiler, from IR to JavaScript closures. The code
+ * lives in compile/: the pieces compiled code shares, the IR compiler with a
+ * module per node family, and the builtins with a module per domain. This
+ * module names what the package exports from it. */
+export { isTypeValueEqual } from "./type_of_type.js";
+export { printTypeValue, EAST_IR_SYMBOL, EAST_CAPTURES_SYMBOL, EAST_SOURCE_MAP_SYMBOL, requiresBoxing, ReturnException, } from "./compile/runtime.js";
+export { compile_internal } from "./compile/ir.js";
+export { applyTypeParameters } from "./compile/type_parameters.js";
 //# sourceMappingURL=compile.js.map