@elaraai/east 0.0.1-beta.3 → 0.0.1-beta.31

package/dist/src/compile.js

@@ -5,19 +5,47 @@
 import {} from "./builtins.js";
 import { printLocationValue } 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 { EastError } from "./error.js";
+import { EastError, InternalError } from "./error.js";
 import { SortedSet } from "./containers/sortedset.js";
 import { SortedMap } from "./containers/sortedmap.js";
 import { BufferWriter } from "./serialization/binary-utils.js";
-import { decodeBeast2For, decodeBeastFor, encodeBeast2For, encodeBeastFor, fromJSONFor, toJSONFor } from "./serialization/index.js";
+import { decodeBeast2For, decodeBeastFor, encodeBeast2For, encodeBeastFor, fromJSONFor, toJSONFor, decodeCsvFor, encodeCsvFor } 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";
 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");
+/** 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 Track iteration locks to prevent concurrent modification */
 const iterationLocks = new WeakMap();
 /** @internal Lock a collection for iteration (prevents size/keyset modifications) */
@@ -63,7 +91,7 @@ class BreakException {
 *
 * @internal
 */
-export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx = true, compilingNodes = new Set()) {
+export function compile_internal(ir, ctx, platform, asyncPlatformFns, platformDef, fresh_ctx = true, compilingNodes = new Set()) {
     // 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
@@ -73,7 +101,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
         return (_ctx) => v;
     }
     else if (ir.type === "Error") {
-        const message_compiled = compile_internal(ir.value.message, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const message_compiled = compile_internal(ir.value.message, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         const location = ir.value.location;
         if (ir.value.isAsync) {
             return async (ctx) => { throw new EastError(await message_compiled(ctx), { location: location }); };
@@ -83,15 +111,15 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
         }
     }
     else if (ir.type === "TryCatch") {
-        const try_body = compile_internal(ir.value.try_body, Object.create(ctx), platform, asyncPlatformFns, true, compilingNodes);
+        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, true, compilingNodes);
+        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, true, compilingNodes);
+        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) => {
@@ -101,8 +129,8 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                     catch (e) {
                         if (e instanceof EastError) {
                             const new_ctx = Object.create(ctx);
-                            new_ctx[message_name] = e.message;
-                            new_ctx[stack_name] = e.location;
+                            new_ctx[message_name] = variant("value", e.message);
+                            new_ctx[stack_name] = variant("value", e.location);
                             return await catch_body(new_ctx);
                         }
                         else {
@@ -119,8 +147,8 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                     catch (e) {
                         if (e instanceof EastError) {
                             const new_ctx = Object.create(ctx);
-                            new_ctx[message_name] = e.message;
-                            new_ctx[stack_name] = e.location;
+                            new_ctx[message_name] = variant("value", e.message);
+                            new_ctx[stack_name] = variant("value", e.location);
                             return await catch_body(new_ctx);
                         }
                         else {
@@ -142,8 +170,8 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                     catch (e) {
                         if (e instanceof EastError) {
                             const new_ctx = Object.create(ctx);
-                            new_ctx[message_name] = e.message;
-                            new_ctx[stack_name] = e.location;
+                            new_ctx[message_name] = variant("value", e.message);
+                            new_ctx[stack_name] = variant("value", e.location);
                             return catch_body(new_ctx);
                         }
                         else {
@@ -160,8 +188,8 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                     catch (e) {
                         if (e instanceof EastError) {
                             const new_ctx = Object.create(ctx);
-                            new_ctx[message_name] = e.message;
-                            new_ctx[stack_name] = e.location;
+                            new_ctx[message_name] = variant("value", e.message);
+                            new_ctx[stack_name] = variant("value", e.location);
                             return catch_body(new_ctx);
                         }
                         else {
@@ -177,73 +205,58 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     }
     else if (ir.type === "Variable") {
         const name = ir.value.name;
-        if (ir.value.mutable && ir.value.captured) {
-            return (ctx) => ctx[name].x;
-        }
-        else {
-            return (ctx) => ctx[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, false, compilingNodes);
+        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;
-        if (ir.value.variable.value.mutable && ir.value.variable.value.captured) {
-            if (ir.value.isAsync) {
-                return async (ctx) => {
-                    ctx[name] = { x: await compiled_statement(ctx) };
-                    return null;
-                };
-            }
-            else {
-                return (ctx) => {
-                    ctx[name] = { x: compiled_statement(ctx) };
-                    return null;
-                };
-            }
+        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 {
-            if (ir.value.isAsync) {
-                return async (ctx) => {
-                    ctx[name] = await compiled_statement(ctx);
-                    return null;
-                };
-            }
-            else {
-                return (ctx) => {
-                    ctx[name] = compiled_statement(ctx);
-                    return null;
-                };
-            }
+            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, false, compilingNodes);
-        if (ir.value.variable.value.mutable && ir.value.variable.value.captured) {
+        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) => {
-                    const value = await compiled_statement(ctx);
-                    ctx[name].x = value;
+                    getContextValue(ctx, name).value = await compiled_statement(ctx);
                     return null;
                 };
             }
             else {
                 return (ctx) => {
-                    const value = compiled_statement(ctx);
-                    ctx[name].x = value;
+                    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] = value;
+                    ctx[name] = variant("value", value);
                     return null;
                 };
             }
@@ -253,7 +266,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                     // We need to check in which prototype the variable lives
                     while (!Object.hasOwn(ctx, name))
                         ctx = Object.getPrototypeOf(ctx);
-                    ctx[name] = value;
+                    ctx[name] = variant("value", value);
                     return null;
                 };
             }
@@ -262,69 +275,105 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     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, fresh_ctx, compilingNodes);
+        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, fresh_ctx, compilingNodes);
+        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, false, compilingNodes);
+        return compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
     }
     else if (ir.type === "Function") {
-        const ctx2 = {};
+        // Compile-time type context for body compilation
+        const typeCtx = {};
         for (const variable of ir.value.captures) {
-            ctx2[variable.value.name] = variable.value.type;
+            typeCtx[variable.value.name] = variable.value.type;
         }
         for (const parameter of ir.value.parameters) {
-            const parameter_name = parameter.value.name;
-            ctx2[parameter_name] = parameter.value.type;
+            typeCtx[parameter.value.name] = parameter.value.type;
         }
-        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+        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) => {
-            const ctx2 = {};
+            // Runtime context for captured values
+            const captureCtx = {};
             for (const name of capture_names) {
-                ctx2[name] = ctx[name];
+                captureCtx[name] = getContextValue(ctx, name);
             }
-            return (...args) => {
-                const ctx3 = { ...ctx2 };
-                parameter_names.forEach((name, i) => ctx3[name] = args[i]);
-                return compiled_body(ctx3);
+            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
+            });
+            return fn;
         };
     }
     else if (ir.type === "AsyncFunction") {
-        const ctx2 = {};
+        // Compile-time type context for body compilation
+        const typeCtx = {};
         for (const variable of ir.value.captures) {
-            ctx2[variable.value.name] = variable.value.type;
+            typeCtx[variable.value.name] = variable.value.type;
         }
         for (const parameter of ir.value.parameters) {
-            const parameter_name = parameter.value.name;
-            ctx2[parameter_name] = parameter.value.type;
+            typeCtx[parameter.value.name] = parameter.value.type;
         }
-        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+        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) => {
-            const ctx2 = {};
+            // Runtime context for captured values
+            const captureCtx = {};
             for (const name of capture_names) {
-                ctx2[name] = ctx[name];
+                captureCtx[name] = getContextValue(ctx, name);
             }
-            return (...args) => {
-                const ctx3 = { ...ctx2 };
-                parameter_names.forEach((name, i) => ctx3[name] = args[i]);
-                return compiled_body(ctx3); // Promise can pass through in tail position
+            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
+            });
+            return fn;
         };
     }
     else if (ir.type === "Call") {
-        const compiled_f = compile_internal(ir.value.function, ctx, platform, asyncPlatformFns, false, compilingNodes);
-        const compiled_args = ir.value.arguments.map(argument => compile_internal(argument, ctx, platform, asyncPlatformFns, false, compilingNodes));
+        const 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 location = ir.value.location;
         if (ir.value.isAsync) {
             // need to await the arguments
@@ -341,7 +390,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                         return e.value;
                     }
                     else if (e instanceof EastError) {
-                        e.location.push(location); // The fact that we need to push the call location not the definition location means we need to handle this here
+                        e.location.push(...location); // The fact that we need to push the call location not the definition location means we need to handle this here
                         throw (e);
                     }
                     else if (e instanceof ContinueException) {
@@ -366,7 +415,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                         return e.value;
                     }
                     else if (e instanceof EastError) {
-                        e.location.push(location); // The fact that we need to push the call location not the definition location means we need to handle this here
+                        e.location.push(...location); // The fact that we need to push the call location not the definition location means we need to handle this here
                         throw (e);
                     }
                     else if (e instanceof ContinueException) {
@@ -383,8 +432,8 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
         }
     }
     else if (ir.type === "CallAsync") {
-        const compiled_f = compile_internal(ir.value.function, ctx, platform, asyncPlatformFns, false, compilingNodes);
-        const compiled_args = ir.value.arguments.map(argument => compile_internal(argument, ctx, platform, asyncPlatformFns, false, compilingNodes));
+        const 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 location = ir.value.location;
         return async (ctx) => {
             try {
@@ -399,7 +448,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                     return e.value;
                 }
                 else if (e instanceof EastError) {
-                    e.location.push(location); // The fact that we need to push the call location not the definition location means we need to handle this here
+                    e.location.push(...location); // The fact that we need to push the call location not the definition location means we need to handle this here
                     throw (e);
                 }
                 else if (e instanceof ContinueException) {
@@ -422,11 +471,11 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                 asyncPredicate = true;
             }
             ifs.push({
-                predicate: compile_internal(predicate, ctx, platform, asyncPlatformFns, false, compilingNodes),
-                body: compile_internal(body, Object.create(ctx), platform, asyncPlatformFns, true, compilingNodes),
+                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, 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) => {
@@ -461,7 +510,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
         }
     }
     else if (ir.type === "Match") {
-        const compiled_variant = compile_internal(ir.value.variant, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        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) {
@@ -469,14 +518,14 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
             const data_name = variable.value.name;
             data_names[k] = data_name;
             ctx2[data_name] = variable.value.type;
-            compiled_cases[k] = compile_internal(body, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+            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]] = v.value;
+                    ctx2[data_names[v.type]] = variant("value", v.value);
                     return await compiled_cases[v.type](ctx2);
                 };
             }
@@ -484,7 +533,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                 return async (ctx) => {
                     const v = compiled_variant(ctx);
                     const ctx2 = Object.create(ctx);
-                    ctx2[data_names[v.type]] = v.value;
+                    ctx2[data_names[v.type]] = variant("value", v.value);
                     return await compiled_cases[v.type](ctx2);
                 };
             }
@@ -493,15 +542,15 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
             return (ctx) => {
                 const v = compiled_variant(ctx);
                 const ctx2 = Object.create(ctx);
-                ctx2[data_names[v.type]] = v.value;
+                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, false, compilingNodes);
+        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, true, compilingNodes);
+        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) => {
@@ -550,13 +599,13 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     }
     else if (ir.type === "ForArray") {
         const value_type = expandTypeValue(ir.value.array.value.type).value;
-        const compiled_array = compile_internal(ir.value.array, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const 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, true, compilingNodes);
+        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) => {
@@ -565,8 +614,8 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                 try {
                     for (const [key, value] of array.entries()) {
                         const ctx2 = Object.create(ctx);
-                        ctx2[key_name] = BigInt(key);
-                        ctx2[value_name] = value;
+                        ctx2[key_name] = variant("value", BigInt(key));
+                        ctx2[value_name] = variant("value", value);
                         try {
                             await compiled_body(ctx2);
                         }
@@ -596,8 +645,8 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                 try {
                     for (const [key, value] of array.entries()) {
                         const ctx2 = Object.create(ctx);
-                        ctx2[key_name] = BigInt(key);
-                        ctx2[value_name] = value;
+                        ctx2[key_name] = variant("value", BigInt(key));
+                        ctx2[value_name] = variant("value", value);
                         try {
                             compiled_body(ctx2);
                         }
@@ -623,11 +672,11 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     }
     else if (ir.type === "ForSet") {
         const key_type = expandTypeValue(ir.value.set.value.type).value;
-        const compiled_set = compile_internal(ir.value.set, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const 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, true, compilingNodes);
+        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) => {
@@ -636,7 +685,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                 try {
                     for (const key of set) {
                         const ctx2 = Object.create(ctx);
-                        ctx2[key_name] = key;
+                        ctx2[key_name] = variant("value", key);
                         try {
                             await compiled_body(ctx2);
                         }
@@ -666,7 +715,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                 try {
                     for (const key of set) {
                         const ctx2 = Object.create(ctx);
-                        ctx2[key_name] = key;
+                        ctx2[key_name] = variant("value", key);
                         try {
                             compiled_body(ctx2);
                         }
@@ -693,13 +742,13 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     else if (ir.type === "ForDict") {
         const key_type = expandTypeValue(ir.value.dict.value.type).value.key;
         const value_type = expandTypeValue(ir.value.dict.value.type).value.value;
-        const compiled_dict = compile_internal(ir.value.dict, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const 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, true, compilingNodes);
+        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) => {
@@ -708,8 +757,8 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                 try {
                     for (const [key, value] of dict) {
                         const ctx2 = Object.create(ctx);
-                        ctx2[key_name] = key;
-                        ctx2[value_name] = value;
+                        ctx2[key_name] = variant("value", key);
+                        ctx2[value_name] = variant("value", value);
                         try {
                             await compiled_body(ctx2);
                         }
@@ -739,8 +788,8 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                 try {
                     for (const [key, value] of dict) {
                         const ctx2 = Object.create(ctx);
-                        ctx2[key_name] = key;
-                        ctx2[value_name] = value;
+                        ctx2[key_name] = variant("value", key);
+                        ctx2[value_name] = variant("value", value);
                         try {
                             compiled_body(ctx2);
                         }
@@ -770,7 +819,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
         if (fresh_ctx) {
             const compiled_statements = [];
             for (const statement of ir.value.statements) {
-                const compiled_statement = compile_internal(statement, ctx, platform, asyncPlatformFns, true, compilingNodes);
+                const compiled_statement = compile_internal(statement, ctx, platform, asyncPlatformFns, platformDef, true, compilingNodes);
                 compiled_statements.push(compiled_statement);
             }
             if (ir.value.isAsync) {
@@ -796,7 +845,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
             const ctx2 = Object.create(ctx);
             const compiled_statements = [];
             for (const statement of ir.value.statements) {
-                const compiled_statement = compile_internal(statement, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+                const compiled_statement = compile_internal(statement, ctx2, platform, asyncPlatformFns, platformDef, true, compilingNodes);
                 compiled_statements.push(compiled_statement);
             }
             if (ir.value.isAsync) {
@@ -822,7 +871,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
         }
     }
     else if (ir.type === "GetField") {
-        const struct = compile_internal(ir.value.struct, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        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];
@@ -833,7 +882,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     }
     else if (ir.type === "Struct") {
         const fields = ir.value.fields.map(f => {
-            return compile_internal(f.value, ctx, platform, asyncPlatformFns, false, compilingNodes);
+            return compile_internal(f.value, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         });
         const keys = ir.value.fields.map(f => f.name);
         if (ir.value.isAsync) {
@@ -851,7 +900,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     }
     else if (ir.type === "Variant") {
         const k = ir.value.case;
-        const v = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        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));
         }
@@ -860,7 +909,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
         }
     }
     else if (ir.type === "NewRef") {
-        const value = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const value = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         if (ir.value.isAsync) {
             return async (ctx) => ref(await value(ctx));
         }
@@ -870,7 +919,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     }
     else if (ir.type === "NewArray") {
         const values = ir.value.values.map(a => {
-            return compile_internal(a, ctx, platform, asyncPlatformFns, false, compilingNodes);
+            return compile_internal(a, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         });
         if (ir.value.isAsync) {
             return async (ctx) => {
@@ -887,7 +936,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     }
     else if (ir.type === "NewSet") {
         const values = ir.value.values.map(a => {
-            return compile_internal(a, ctx, platform, asyncPlatformFns, false, compilingNodes);
+            return compile_internal(a, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         });
         const keyComparer = compareFor(ir.value.type.value);
         if (ir.value.isAsync) {
@@ -905,7 +954,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     }
     else if (ir.type === "NewDict") {
         const values = ir.value.values.map(({ key, value }) => {
-            return [compile_internal(key, ctx, platform, asyncPlatformFns, false, compilingNodes), compile_internal(value, ctx, platform, asyncPlatformFns, false, compilingNodes)];
+            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) {
@@ -922,7 +971,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
         }
     }
     else if (ir.type === "Return") {
-        const compiled_value = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        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));
@@ -952,7 +1001,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
             if (a.value.isAsync) {
                 argsAsync = true;
             }
-            return compile_internal(a, ctx, platform, asyncPlatformFns, false, compilingNodes);
+            return compile_internal(a, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         });
         // Special optimization for regex builtins with literal pattern/flags
         if ((ir.value.builtin === "RegexContains" || ir.value.builtin === "RegexIndexOf" || ir.value.builtin === "RegexReplace") &&
@@ -1127,7 +1176,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                 }
             }
         }
-        const evaluator = builtin_evaluators[ir.value.builtin](ir.value.location, ...ir.value.type_parameters);
+        const evaluator = builtin_evaluators[ir.value.builtin](ir.value.location, platformDef, ...ir.value.type_parameters);
         if (argsAsync) {
             return async (ctx) => {
                 const args_resolved = [];
@@ -1147,11 +1196,41 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
             if (a.value.isAsync) {
                 argsAsync = true;
             }
-            return compile_internal(a, ctx, platform, asyncPlatformFns, false, compilingNodes);
+            return compile_internal(a, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         });
-        const evaluator = platform[ir.value.name];
-        if (evaluator === undefined) {
-            throw new Error(`Evaluator for platform function ${JSON.stringify(ir.value.name)} not found at ${printLocationValue(ir.value.location)}`);
+        // 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;
+                const location = ir.value.location;
+                evaluator = () => {
+                    throw new EastError(`Platform function '${name}' is not available`, { location });
+                };
+            }
+            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;
+                const location = ir.value.location;
+                evaluator = () => {
+                    throw new EastError(`Platform function '${name}' is not available`, { location });
+                };
+            }
+            else {
+                evaluator = platformEvaluator;
+            }
         }
         if (argsAsync) {
             return async (ctx) => {
@@ -1180,7 +1259,7 @@ function call_function(location, compiled_f, ...args) {
             return e.value;
         }
         else if (e instanceof EastError) {
-            e.location.push(location); // The fact that we need to push the call location not the definition location means we need to handle this here
+            e.location.push(...location); // The fact that we need to push the call location not the definition location means we need to handle this here
             throw (e);
         }
         else if (e instanceof ContinueException) {
@@ -1196,13 +1275,43 @@ function call_function(location, compiled_f, ...args) {
 }
 /** @internal */
 const builtin_evaluators = {
-    Is: (_location, T) => isFor(T),
-    Equal: (_location, T) => equalFor(T),
-    NotEqual: (_location, T) => notEqualFor(T),
-    Less: (_location, T) => lessFor(T),
-    LessEqual: (_location, T) => lessEqualFor(T),
-    Greater: (_location, T) => greaterFor(T),
-    GreaterEqual: (_location, T) => greaterEqualFor(T),
+    Is: (_location, _platformDef, T) => isFor(T),
+    Equal: (_location, _platformDef, T) => equalFor(T),
+    NotEqual: (_location, _platformDef, T) => notEqualFor(T),
+    Less: (_location, _platformDef, T) => lessFor(T),
+    LessEqual: (_location, _platformDef, T) => lessEqualFor(T),
+    Greater: (_location, _platformDef, T) => greaterFor(T),
+    GreaterEqual: (_location, _platformDef, T) => greaterEqualFor(T),
+    Diff: (_location, _platformDef, T) => diffFor(T),
+    ApplyPatch: (location, _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 });
+                }
+                throw e;
+            }
+        };
+    },
+    ComposePatch: (location, _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 });
+                }
+                throw e;
+            }
+        };
+    },
+    InvertPatch: (_location, _platformDef, T) => invertFor(T),
     BooleanNot: (_location) => (x) => !x,
     BooleanOr: (_location) => (x, y) => x || y,
     BooleanAnd: (_location) => (x, y) => x && y,
@@ -1257,10 +1366,10 @@ const builtin_evaluators = {
     FloatSin: (_location) => (value) => Math.sin(value),
     FloatCos: (_location) => (value) => Math.cos(value),
     FloatTan: (_location) => (value) => Math.tan(value),
-    Print: (_location, T) => {
+    Print: (_location, _platformDef, T) => {
         return printFor(T);
     },
-    Parse: (location, T) => {
+    Parse: (location, _platformDef, T) => {
         const p = parseFor(T);
         return (x) => {
             const result = p(x);
@@ -1460,7 +1569,7 @@ const builtin_evaluators = {
             return buffer.toUint8Array();
         };
     },
-    StringParseJSON: (location, type) => {
+    StringParseJSON: (location, _platformDef, type) => {
         const fromJSON = fromJSONFor(type);
         return (x) => {
             let parsed;
@@ -1478,7 +1587,7 @@ const builtin_evaluators = {
             }
         };
     },
-    StringPrintJSON: (_location, type) => {
+    StringPrintJSON: (_location, _platformDef, type) => {
         const toJSON = toJSONFor(type);
         return (x) => JSON.stringify(toJSON(x));
     },
@@ -1555,13 +1664,13 @@ const builtin_evaluators = {
             }
         };
     },
-    BlobEncodeBeast: (_location, type) => {
+    BlobEncodeBeast: (_location, _platformDef, type) => {
         const encodeBeast = encodeBeastFor(type);
         return (value) => {
             return encodeBeast(value);
         };
     },
-    BlobDecodeBeast: (location, type) => {
+    BlobDecodeBeast: (location, _platformDef, type) => {
         const decodeBeast = decodeBeastFor(type);
         return (data) => {
             try {
@@ -1572,14 +1681,14 @@ const builtin_evaluators = {
             }
         };
     },
-    BlobEncodeBeast2: (_location, type) => {
+    BlobEncodeBeast2: (_location, _platformDef, type) => {
         const encodeBeast2 = encodeBeast2For(type);
         return (value) => {
             return encodeBeast2(value);
         };
     },
-    BlobDecodeBeast2: (location, type) => {
-        const decodeBeast2 = decodeBeast2For(type);
+    BlobDecodeBeast2: (location, platformDef, type) => {
+        const decodeBeast2 = decodeBeast2For(type, { platform: platformDef });
         return (data) => {
             try {
                 return decodeBeast2(data);
@@ -1589,17 +1698,39 @@ const builtin_evaluators = {
             }
         };
     },
-    RefGet: (_location, _T) => (ref) => {
+    BlobDecodeCsv: (location, _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 });
+            }
+        };
+    },
+    ArrayEncodeCsv: (location, _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 });
+            }
+        };
+    },
+    RefGet: (_location, _platformDef, _T) => (ref) => {
         return ref.value;
     },
-    RefUpdate: (location, _T) => (ref, value) => {
+    RefUpdate: (location, _platformDef, _T) => (ref, value) => {
         if (Object.isFrozen(ref)) {
             throw new EastError("Cannot modify frozen Ref", { location });
         }
         ref.value = value;
         return null;
     },
-    RefMerge: (location, _T) => (ref, value, merger) => {
+    RefMerge: (location, _platformDef, _T) => (ref, value, merger) => {
         if (Object.isFrozen(ref)) {
             throw new EastError("Cannot modify frozen Ref", { location });
         }
@@ -1607,7 +1738,7 @@ const builtin_evaluators = {
         ref.value = new_value;
         return null;
     },
-    ArrayGenerate: (location, _T) => (size, f) => {
+    ArrayGenerate: (location, _platformDef, _T) => (size, f) => {
         const result = [];
         for (let i = 0n; i < size; i += 1n) {
             const v = call_function(location, f, i);
@@ -1648,12 +1779,12 @@ const builtin_evaluators = {
         }
         return result;
     },
-    ArraySize: (_location, _T) => (array) => BigInt(array.length),
-    ArrayHas: (_location, _T) => (array, key) => {
+    ArraySize: (_location, _platformDef, _T) => (array) => BigInt(array.length),
+    ArrayHas: (_location, _platformDef, _T) => (array, key) => {
         const i = Number(key);
         return i >= 0 && i < array.length;
     },
-    ArrayGet: (location, _T) => (array, key) => {
+    ArrayGet: (location, _platformDef, _T) => (array, key) => {
         const i = Number(key);
         if (i < 0 || i >= array.length) {
             throw new EastError(`Array index ${key} out of bounds`, { location });
@@ -1662,7 +1793,7 @@ const builtin_evaluators = {
             return array[i];
         }
     },
-    ArrayGetOrDefault: (location, _T) => (array, key, defaultFn) => {
+    ArrayGetOrDefault: (location, _platformDef, _T) => (array, key, defaultFn) => {
         const i = Number(key);
         if (i < 0 || i >= array.length) {
             return call_function(location, defaultFn, key);
@@ -1671,7 +1802,7 @@ const builtin_evaluators = {
             return array[i];
         }
     },
-    ArrayTryGet: (_location, _T) => (array, key) => {
+    ArrayTryGet: (_location, _platformDef, _T) => (array, key) => {
         const i = Number(key);
         if (i < 0 || i >= array.length) {
             return variant("none", null);
@@ -1680,7 +1811,7 @@ const builtin_evaluators = {
             return variant("some", array[i]);
         }
     },
-    ArrayUpdate: (location, _T) => (array, key, value) => {
+    ArrayUpdate: (location, _platformDef, _T) => (array, key, value) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1693,7 +1824,7 @@ const builtin_evaluators = {
             return null;
         }
     },
-    ArrayMerge: (location, _T) => (array, key, value, merger) => {
+    ArrayMerge: (location, _platformDef, _T) => (array, key, value, merger) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1707,7 +1838,7 @@ const builtin_evaluators = {
             return null;
         }
     },
-    ArrayPushLast: (location, _T) => (array, value) => {
+    ArrayPushLast: (location, _platformDef, _T) => (array, value) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1717,7 +1848,7 @@ const builtin_evaluators = {
         array.push(value);
         return null;
     },
-    ArrayPopLast: (location, _T) => (array) => {
+    ArrayPopLast: (location, _platformDef, _T) => (array) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1731,7 +1862,7 @@ const builtin_evaluators = {
             return array.pop();
         }
     },
-    ArrayPushFirst: (location, _T) => (array, value) => {
+    ArrayPushFirst: (location, _platformDef, _T) => (array, value) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1741,7 +1872,7 @@ const builtin_evaluators = {
         array.unshift(value);
         return null;
     },
-    ArrayPopFirst: (location, _T) => (array) => {
+    ArrayPopFirst: (location, _platformDef, _T) => (array) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1755,7 +1886,7 @@ const builtin_evaluators = {
             return array.shift();
         }
     },
-    ArrayAppend: (location, _T) => (array, other) => {
+    ArrayAppend: (location, _platformDef, _T) => (array, other) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1765,7 +1896,7 @@ const builtin_evaluators = {
         array.push(...other);
         return null;
     },
-    ArrayPrepend: (location, _T) => (array, other) => {
+    ArrayPrepend: (location, _platformDef, _T) => (array, other) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1775,7 +1906,7 @@ const builtin_evaluators = {
         array.unshift(...other);
         return null;
     },
-    ArrayMergeAll: (location, _T, _T2) => (array, other, merger) => {
+    ArrayMergeAll: (location, _platformDef, _T, _T2) => (array, other, merger) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1799,7 +1930,7 @@ const builtin_evaluators = {
         }
         return null;
     },
-    ArrayClear: (location, _T) => (array) => {
+    ArrayClear: (location, _platformDef, _T) => (array) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1809,7 +1940,7 @@ const builtin_evaluators = {
         array.length = 0;
         return null;
     },
-    ArraySortInPlace: (location, T, T2) => (array, by) => {
+    ArraySortInPlace: (location, _platformDef, T, T2) => (array, by) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1830,7 +1961,7 @@ const builtin_evaluators = {
         }
         return null;
     },
-    ArrayReverseInPlace: (location, _T) => (array) => {
+    ArrayReverseInPlace: (location, _platformDef, _T) => (array) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1840,7 +1971,7 @@ const builtin_evaluators = {
         array.reverse();
         return null;
     },
-    ArraySort: (location, T, T2) => (array, by) => {
+    ArraySort: (location, _platformDef, T, T2) => (array, by) => {
         const cmp = compareFor(T2);
         const newArray = [...array];
         newArray.sort((a, b) => {
@@ -1850,12 +1981,12 @@ const builtin_evaluators = {
         });
         return newArray;
     },
-    ArrayReverse: (_location, _T) => (array) => {
+    ArrayReverse: (_location, _platformDef, _T) => (array) => {
         const newArray = [...array];
         newArray.reverse();
         return newArray;
     },
-    ArrayIsSorted: (location, T, T2) => {
+    ArrayIsSorted: (location, _platformDef, T, T2) => {
         const cmp = compareFor(T2);
         return (array, by) => {
             if (array.length < 2)
@@ -1877,7 +2008,7 @@ const builtin_evaluators = {
             return true;
         };
     },
-    ArrayFindSortedFirst: (location, T, T2) => {
+    ArrayFindSortedFirst: (location, _platformDef, T, T2) => {
         const cmp = compareFor(T2);
         return (array, key, by) => {
             let low = 0;
@@ -1901,7 +2032,7 @@ const builtin_evaluators = {
             return BigInt(low);
         };
     },
-    ArrayFindSortedLast: (location, T, T2) => {
+    ArrayFindSortedLast: (location, _platformDef, T, T2) => {
         const cmp = compareFor(T2);
         return (array, key, by) => {
             let low = 0;
@@ -1925,7 +2056,7 @@ const builtin_evaluators = {
             return BigInt(low);
         };
     },
-    ArrayFindSortedRange: (location, T, T2) => {
+    ArrayFindSortedRange: (location, _platformDef, T, T2) => {
         const cmp = compareFor(T2);
         return (array, key, by) => {
             let lo = -1;
@@ -1983,7 +2114,7 @@ const builtin_evaluators = {
             return { start: BigInt(lo + 1), end: BigInt(lo + 1) };
         };
     },
-    ArrayFindFirst: (location, T, T2) => {
+    ArrayFindFirst: (location, _platformDef, T, T2) => {
         const cmp = compareFor(T2);
         return (array, value, by) => {
             lockForIteration(array);
@@ -2001,15 +2132,15 @@ const builtin_evaluators = {
             }
         };
     },
-    ArrayConcat: (_location, _T) => (a1, a2) => {
+    ArrayConcat: (_location, _platformDef, _T) => (a1, a2) => {
         return [...a1, ...a2];
     },
-    ArraySlice: (_location, _T) => (array, start, end) => {
+    ArraySlice: (_location, _platformDef, _T) => (array, start, end) => {
         const startNum = Number(start);
         const endNum = Number(end);
         return array.slice(startNum, endNum);
     },
-    ArrayGetKeys: (location, _T) => (array, keys, onMissing) => {
+    ArrayGetKeys: (location, _platformDef, _T) => (array, keys, onMissing) => {
         return keys.map(k => {
             const i = Number(k);
             if (i < 0 || i >= array.length) {
@@ -2020,7 +2151,7 @@ const builtin_evaluators = {
             }
         });
     },
-    ArrayForEach: (location, _T, _T2) => (array, f) => {
+    ArrayForEach: (location, _platformDef, _T, _T2) => (array, f) => {
         lockForIteration(array);
         try {
             array.forEach((x, i) => {
@@ -2032,10 +2163,10 @@ const builtin_evaluators = {
             unlockForIteration(array);
         }
     },
-    ArrayCopy: (_location, _T) => (array) => {
+    ArrayCopy: (_location, _platformDef, _T) => (array) => {
         return [...array];
     },
-    ArrayMap: (location, _T, _T2) => (array, f) => {
+    ArrayMap: (location, _platformDef, _T, _T2) => (array, f) => {
         lockForIteration(array);
         try {
             return array.map((x, i) => {
@@ -2046,7 +2177,7 @@ const builtin_evaluators = {
             unlockForIteration(array);
         }
     },
-    ArrayFilter: (location, _T, _T2) => (array, f) => {
+    ArrayFilter: (location, _platformDef, _T, _T2) => (array, f) => {
         lockForIteration(array);
         try {
             return array.filter((x, i) => {
@@ -2057,7 +2188,7 @@ const builtin_evaluators = {
             unlockForIteration(array);
         }
     },
-    ArrayFilterMap: (location, _T, _T2) => (array, f) => {
+    ArrayFilterMap: (location, _platformDef, _T, _T2) => (array, f) => {
         lockForIteration(array);
         try {
             const result = [];
@@ -2073,7 +2204,7 @@ const builtin_evaluators = {
             unlockForIteration(array);
         }
     },
-    ArrayFirstMap: (location, _T, _T2) => (array, f) => {
+    ArrayFirstMap: (location, _platformDef, _T, _T2) => (array, f) => {
         lockForIteration(array);
         try {
             for (let i = 0; i < array.length; i++) {
@@ -2088,7 +2219,7 @@ const builtin_evaluators = {
             unlockForIteration(array);
         }
     },
-    ArrayFold: (location, _T, _T2) => (array, init, f) => {
+    ArrayFold: (location, _platformDef, _T, _T2) => (array, init, f) => {
         lockForIteration(array);
         try {
             return array.reduce((acc, x, i) => {
@@ -2099,7 +2230,7 @@ const builtin_evaluators = {
             unlockForIteration(array);
         }
     },
-    ArrayMapReduce: (location, _T, _T2) => (array, mapFn, reduceFn) => {
+    ArrayMapReduce: (location, _platformDef, _T, _T2) => (array, mapFn, reduceFn) => {
         if (array.length === 0) {
             throw new EastError("Cannot reduce empty array with no initial value", { location });
         }
@@ -2116,8 +2247,8 @@ const builtin_evaluators = {
             unlockForIteration(array);
         }
     },
-    ArrayStringJoin: (_location) => (x, y) => x.join(y),
-    ArrayToSet: (location, _T, T2) => {
+    ArrayStringJoin: (_location, _platformDef) => (x, y) => x.join(y),
+    ArrayToSet: (location, _platformDef, _T, T2) => {
         const compare = compareFor(T2);
         return (array, f) => {
             lockForIteration(array);
@@ -2134,7 +2265,7 @@ const builtin_evaluators = {
             }
         };
     },
-    ArrayToDict: (location, _T, K2, _T2) => {
+    ArrayToDict: (location, _platformDef, _T, K2, _T2) => {
         const compare = compareFor(K2);
         return (array, keyFn, valueFn, onConflict) => {
             const result = new SortedMap([], compare);
@@ -2160,12 +2291,12 @@ const builtin_evaluators = {
             }
         };
     },
-    ArrayFlattenToArray: (location, _T) => (array, fn) => {
+    ArrayFlattenToArray: (location, _platformDef, _T) => (array, fn) => {
         return array.flatMap(v => {
             return call_function(location, fn, v);
         });
     },
-    ArrayFlattenToSet: (location, _T, K2) => {
+    ArrayFlattenToSet: (location, _platformDef, _T, K2) => {
         const compare = compareFor(K2);
         return (array, fn) => {
             const result = new SortedSet([], compare);
@@ -2184,7 +2315,7 @@ const builtin_evaluators = {
             }
         };
     },
-    ArrayFlattenToDict: (location, _T, K2, _T2) => {
+    ArrayFlattenToDict: (location, _platformDef, _T, K2, _T2) => {
         const compare = compareFor(K2);
         return (array, fn, onConflict) => {
             const result = new SortedMap([], compare);
@@ -2210,7 +2341,7 @@ const builtin_evaluators = {
             }
         };
     },
-    ArrayGroupFold: (location, _T, K2, _V2) => {
+    ArrayGroupFold: (location, _platformDef, _T, K2, _V2) => {
         const compare = compareFor(K2);
         return (array, keyFn, init, folder) => {
             const result = new SortedMap([], compare);
@@ -2233,7 +2364,7 @@ const builtin_evaluators = {
             }
         };
     },
-    SetGenerate: (location, K) => {
+    SetGenerate: (location, _platformDef, K) => {
         const keyComparer = compareFor(K);
         return (size, keyFn, onConflict) => {
             const result = new SortedSet([], keyComparer);
@@ -2249,9 +2380,9 @@ const builtin_evaluators = {
             return result;
         };
     },
-    SetSize: (_location, _K) => (s) => BigInt(s.size),
-    SetHas: (_location, _K) => (s, key) => s.has(key),
-    SetInsert: (location, K) => {
+    SetSize: (_location, _platformDef, _K) => (s) => BigInt(s.size),
+    SetHas: (_location, _platformDef, _K) => (s, key) => s.has(key),
+    SetInsert: (location, _platformDef, K) => {
         const print = printFor(K);
         return (s, key) => {
             if (Object.isFrozen(s)) {
@@ -2268,7 +2399,7 @@ const builtin_evaluators = {
             return null;
         };
     },
-    SetTryInsert: (location, _K) => (s, key) => {
+    SetTryInsert: (location, _platformDef, _K) => (s, key) => {
         if (Object.isFrozen(s)) {
             throw new EastError("Cannot modify frozen Set", { location });
         }
@@ -2279,7 +2410,7 @@ const builtin_evaluators = {
         s.add(key);
         return s.size > size_before;
     },
-    SetDelete: (location, K) => {
+    SetDelete: (location, _platformDef, K) => {
         const print = printFor(K);
         return (s, key) => {
             if (Object.isFrozen(s)) {
@@ -2294,7 +2425,7 @@ const builtin_evaluators = {
             return null;
         };
     },
-    SetTryDelete: (location, _K) => (s, key) => {
+    SetTryDelete: (location, _platformDef, _K) => (s, key) => {
         if (Object.isFrozen(s)) {
             throw new EastError("Cannot modify frozen Set", { location });
         }
@@ -2303,7 +2434,7 @@ const builtin_evaluators = {
         }
         return s.delete(key);
     },
-    SetClear: (location, _K) => (s) => {
+    SetClear: (location, _platformDef, _K) => (s) => {
         if (Object.isFrozen(s)) {
             throw new EastError("Cannot modify frozen Set", { location });
         }
@@ -2313,7 +2444,7 @@ const builtin_evaluators = {
         s.clear();
         return null;
     },
-    SetUnionInPlace: (location, _K) => (s1, s2) => {
+    SetUnionInPlace: (location, _platformDef, _K) => (s1, s2) => {
         if (Object.isFrozen(s1)) {
             throw new EastError("Cannot modify frozen Set", { location });
         }
@@ -2323,19 +2454,19 @@ const builtin_evaluators = {
         s2.forEach(v => s1.add(v));
         return null;
     },
-    SetUnion: (_location, _K) => (s1, s2) => s1.union(s2),
-    SetIntersect: (_location, _K) => (s1, s2) => s1.intersection(s2),
-    SetDiff: (_location, _K) => (s1, s2) => s1.difference(s2),
-    SetSymDiff: (_location, _K) => (s1, s2) => s1.symmetricDifference(s2),
-    SetIsSubset: (_location, _K) => (s1, s2) => s1.isSubsetOf(s2),
-    SetIsDisjoint: (_location, _K) => (s1, s2) => s1.isDisjointFrom(s2),
-    SetCopy: (_location, K) => {
+    SetUnion: (_location, _platformDef, _K) => (s1, s2) => s1.union(s2),
+    SetIntersect: (_location, _platformDef, _K) => (s1, s2) => s1.intersection(s2),
+    SetDiff: (_location, _platformDef, _K) => (s1, s2) => s1.difference(s2),
+    SetSymDiff: (_location, _platformDef, _K) => (s1, s2) => s1.symmetricDifference(s2),
+    SetIsSubset: (_location, _platformDef, _K) => (s1, s2) => s1.isSubsetOf(s2),
+    SetIsDisjoint: (_location, _platformDef, _K) => (s1, s2) => s1.isDisjointFrom(s2),
+    SetCopy: (_location, _platformDef, K) => {
         const compare = compareFor(K);
         return (s) => {
             return new SortedSet([...s], compare);
         };
     },
-    SetForEach: (location, _K, _T2) => (s, f) => {
+    SetForEach: (location, _platformDef, _K, _T2) => (s, f) => {
         lockForIteration(s);
         try {
             s.forEach(x => {
@@ -2347,7 +2478,7 @@ const builtin_evaluators = {
             unlockForIteration(s);
         }
     },
-    SetFilter: (location, K) => {
+    SetFilter: (location, _platformDef, K) => {
         const compare = compareFor(K);
         return (s, f) => {
             const result = new SortedSet([], compare);
@@ -2366,7 +2497,7 @@ const builtin_evaluators = {
             }
         };
     },
-    SetFilterMap: (location, K, _V2) => {
+    SetFilterMap: (location, _platformDef, K, _V2) => {
         const compare = compareFor(K);
         return (s, f) => {
             const result = new SortedMap([], compare);
@@ -2385,7 +2516,7 @@ const builtin_evaluators = {
             }
         };
     },
-    SetFirstMap: (location, _K, _T2) => (s, f) => {
+    SetFirstMap: (location, _platformDef, _K, _T2) => (s, f) => {
         lockForIteration(s);
         try {
             for (const k of s) {
@@ -2400,7 +2531,7 @@ const builtin_evaluators = {
             unlockForIteration(s);
         }
     },
-    SetMapReduce: (location, _K, _T2) => (s, mapFn, reduceFn) => {
+    SetMapReduce: (location, _platformDef, _K, _T2) => (s, mapFn, reduceFn) => {
         if (s.size === 0) {
             throw new EastError("Cannot reduce empty set with no initial value", { location });
         }
@@ -2419,7 +2550,7 @@ const builtin_evaluators = {
             unlockForIteration(s);
         }
     },
-    SetMap: (location, K, _T2) => {
+    SetMap: (location, _platformDef, K, _T2) => {
         const compare = compareFor(K);
         return (s, f) => {
             const result = new SortedMap([], compare);
@@ -2436,7 +2567,7 @@ const builtin_evaluators = {
             }
         };
     },
-    SetReduce: (location, _K, _T2) => (s, f, init) => {
+    SetReduce: (location, _platformDef, _K, _T2) => (s, f, init) => {
         let acc = init;
         lockForIteration(s);
         try {
@@ -2449,7 +2580,7 @@ const builtin_evaluators = {
             unlockForIteration(s);
         }
     },
-    SetToArray: (location, _K, _T2) => (s, valueFn) => {
+    SetToArray: (location, _platformDef, _K, _T2) => (s, valueFn) => {
         const ret = [];
         lockForIteration(s);
         try {
@@ -2463,7 +2594,7 @@ const builtin_evaluators = {
             unlockForIteration(s);
         }
     },
-    SetToSet: (location, K, K2) => {
+    SetToSet: (location, _platformDef, K, K2) => {
         const compare = compareFor(K2);
         return (s, f) => {
             const result = new SortedSet([], compare);
@@ -2481,7 +2612,7 @@ const builtin_evaluators = {
             }
         };
     },
-    SetToDict: (location, K, K2, _V2) => {
+    SetToDict: (location, _platformDef, K, K2, _V2) => {
         const compare = compareFor(K2);
         return (s, keyFn, valueFn, onConflict) => {
             const result = new SortedMap([], compare);
@@ -2506,7 +2637,7 @@ const builtin_evaluators = {
             }
         };
     },
-    SetFlattenToArray: (location, _K, _T2) => (s, fn) => {
+    SetFlattenToArray: (location, _platformDef, _K, _T2) => (s, fn) => {
         const ret = [];
         lockForIteration(s);
         try {
@@ -2520,7 +2651,7 @@ const builtin_evaluators = {
             unlockForIteration(s);
         }
     },
-    SetFlattenToSet: (location, _K, K2) => {
+    SetFlattenToSet: (location, _platformDef, _K, K2) => {
         const compare = compareFor(K2);
         return (s, fn) => {
             const result = new SortedSet([], compare);
@@ -2539,7 +2670,7 @@ const builtin_evaluators = {
             }
         };
     },
-    SetFlattenToDict: (location, _K, K2, _V2) => {
+    SetFlattenToDict: (location, _platformDef, _K, K2, _V2) => {
         const compare = compareFor(K2);
         return (s, fn, onConflict) => {
             const result = new SortedMap([], compare);
@@ -2565,7 +2696,7 @@ const builtin_evaluators = {
             }
         };
     },
-    SetGroupFold: (location, _K, K2, _T2) => {
+    SetGroupFold: (location, _platformDef, _K, K2, _T2) => {
         const compare = compareFor(K2);
         return (s, keyFn, init, folder) => {
             const result = new SortedMap([], compare);
@@ -2587,7 +2718,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictGenerate: (location, K, _V) => {
+    DictGenerate: (location, _platformDef, K, _V) => {
         const keyComparer = compareFor(K);
         return (size, keyFn, valueFn, onConflict) => {
             const result = new SortedMap([], keyComparer);
@@ -2606,9 +2737,9 @@ const builtin_evaluators = {
             return result;
         };
     },
-    DictSize: (_location, _K, _V) => (d) => BigInt(d.size),
-    DictHas: (_location, _K, _V) => (d, key) => d.has(key),
-    DictGet: (location, K, _V) => {
+    DictSize: (_location, _platformDef, _K, _V) => (d) => BigInt(d.size),
+    DictHas: (_location, _platformDef, _K, _V) => (d, key) => d.has(key),
+    DictGet: (location, _platformDef, K, _V) => {
         const print = printFor(K);
         return (d, key) => {
             const result = d.get(key);
@@ -2620,7 +2751,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictGetOrDefault: (location, _K, _V) => (d, key, onMissingFn) => {
+    DictGetOrDefault: (location, _platformDef, _K, _V) => (d, key, onMissingFn) => {
         const result = d.get(key);
         if (result === undefined) {
             return call_function(location, onMissingFn, key);
@@ -2629,7 +2760,7 @@ const builtin_evaluators = {
             return result;
         }
     },
-    DictTryGet: (_location, _K, _V) => (d, key) => {
+    DictTryGet: (_location, _platformDef, _K, _V) => (d, key) => {
         const result = d.get(key);
         if (result === undefined) {
             return variant("none", null);
@@ -2638,7 +2769,7 @@ const builtin_evaluators = {
             return variant("some", result);
         }
     },
-    DictInsert: (location, K, _V) => {
+    DictInsert: (location, _platformDef, K, _V) => {
         const print = printFor(K);
         return (d, key, value) => {
             if (Object.isFrozen(d)) {
@@ -2657,7 +2788,7 @@ const builtin_evaluators = {
             return null;
         };
     },
-    DictGetOrInsert: (location, _K, _V) => (d, key, onMissing) => {
+    DictGetOrInsert: (location, _platformDef, _K, _V) => (d, key, onMissing) => {
         if (Object.isFrozen(d)) {
             throw new EastError("Cannot modify frozen Dict", { location });
         }
@@ -2674,7 +2805,7 @@ const builtin_evaluators = {
             return existing;
         }
     },
-    DictInsertOrUpdate: (location, _K, _V) => (d, key, value, onConflictFn) => {
+    DictInsertOrUpdate: (location, _platformDef, _K, _V) => (d, key, value, onConflictFn) => {
         if (Object.isFrozen(d)) {
             throw new EastError("Cannot modify frozen Dict", { location });
         }
@@ -2691,7 +2822,7 @@ const builtin_evaluators = {
         }
         return null;
     },
-    DictUpdate: (location, K, _V) => {
+    DictUpdate: (location, _platformDef, K, _V) => {
         const print = printFor(K);
         return (d, key, value) => {
             if (Object.isFrozen(d)) {
@@ -2706,7 +2837,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictSwap: (location, K, _V) => {
+    DictSwap: (location, _platformDef, K, _V) => {
         const print = printFor(K);
         return (d, key, value) => {
             if (Object.isFrozen(d)) {
@@ -2720,7 +2851,7 @@ const builtin_evaluators = {
             return existing;
         };
     },
-    DictMerge: (location, _K, _V) => (d, key, value, mergeFn, initialFn) => {
+    DictMerge: (location, _platformDef, _K, _V) => (d, key, value, mergeFn, initialFn) => {
         if (Object.isFrozen(d)) {
             throw new EastError("Cannot modify frozen Dict", { location });
         }
@@ -2735,7 +2866,7 @@ const builtin_evaluators = {
         d.set(key, new_value);
         return null;
     },
-    DictDelete: (location, K, _V) => {
+    DictDelete: (location, _platformDef, K, _V) => {
         const print = printFor(K);
         return (d, key) => {
             if (Object.isFrozen(d)) {
@@ -2751,7 +2882,7 @@ const builtin_evaluators = {
             return null;
         };
     },
-    DictTryDelete: (location, _K, _V) => (d, key) => {
+    DictTryDelete: (location, _platformDef, _K, _V) => (d, key) => {
         if (Object.isFrozen(d)) {
             throw new EastError("Cannot modify frozen Dict", { location });
         }
@@ -2760,7 +2891,7 @@ const builtin_evaluators = {
         }
         return d.delete(key);
     },
-    DictPop: (location, K, _V) => {
+    DictPop: (location, _platformDef, K, _V) => {
         const print = printFor(K);
         return (d, key) => {
             if (Object.isFrozen(d)) {
@@ -2779,7 +2910,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictClear: (location, _K, _V) => (d) => {
+    DictClear: (location, _platformDef, _K, _V) => (d) => {
         if (Object.isFrozen(d)) {
             throw new EastError("Cannot modify frozen Dict", { location });
         }
@@ -2789,7 +2920,7 @@ const builtin_evaluators = {
         d.clear();
         return null;
     },
-    DictUnionInPlace: (location, _K, _V) => (d1, d2, onConflict) => {
+    DictUnionInPlace: (location, _platformDef, _K, _V) => (d1, d2, onConflict) => {
         if (Object.isFrozen(d1)) {
             throw new EastError("Cannot modify frozen Dict", { location });
         }
@@ -2808,7 +2939,7 @@ const builtin_evaluators = {
         });
         return null;
     },
-    DictMergeAll: (location, _K, _V) => (d1, d2, mergeFn, initialFn) => {
+    DictMergeAll: (location, _platformDef, _K, _V) => (d1, d2, mergeFn, initialFn) => {
         if (Object.isFrozen(d1)) {
             throw new EastError("Cannot modify frozen Dict", { location });
         }
@@ -2825,13 +2956,13 @@ const builtin_evaluators = {
         });
         return null;
     },
-    DictKeys: (_location, K, _V) => {
+    DictKeys: (_location, _platformDef, K, _V) => {
         const compare = compareFor(K);
         return (d) => {
             return new SortedSet([...d.keys()], compare);
         };
     },
-    DictGetKeys: (location, K, _V) => {
+    DictGetKeys: (location, _platformDef, K, _V) => {
         const compare = compareFor(K);
         return (d, keys, onMissing) => {
             const result = new SortedMap([], compare);
@@ -2848,7 +2979,7 @@ const builtin_evaluators = {
             return result;
         };
     },
-    DictForEach: (location, _K, _V, _T2) => (d, f) => {
+    DictForEach: (location, _platformDef, _K, _V, _T2) => (d, f) => {
         lockForIteration(d);
         try {
             d.forEach((v, k) => {
@@ -2860,13 +2991,13 @@ const builtin_evaluators = {
             unlockForIteration(d);
         }
     },
-    DictCopy: (_location, K, _V) => {
+    DictCopy: (_location, _platformDef, K, _V) => {
         const compare = compareFor(K);
         return (d) => {
             return new SortedMap([...d], compare);
         };
     },
-    DictMap: (location, K, _V, _V2) => {
+    DictMap: (location, _platformDef, K, _V, _V2) => {
         const compare = compareFor(K);
         return (d, f) => {
             const result = new SortedMap([], compare);
@@ -2883,7 +3014,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictFilter: (location, K, _V) => {
+    DictFilter: (location, _platformDef, K, _V) => {
         const compare = compareFor(K);
         return (d, f) => {
             const result = new SortedMap([], compare);
@@ -2902,7 +3033,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictFilterMap: (location, K, _V, _V2) => {
+    DictFilterMap: (location, _platformDef, K, _V, _V2) => {
         const compare = compareFor(K);
         return (d, f) => {
             const result = new SortedMap([], compare);
@@ -2921,7 +3052,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictFirstMap: (location, _K, _V, _T2) => (d, f) => {
+    DictFirstMap: (location, _platformDef, _K, _V, _T2) => (d, f) => {
         lockForIteration(d);
         try {
             for (const [k, v] of d) {
@@ -2936,7 +3067,7 @@ const builtin_evaluators = {
             unlockForIteration(d);
         }
     },
-    DictMapReduce: (location, _K, _V, _T2) => (d, mapFn, reduceFn) => {
+    DictMapReduce: (location, _platformDef, _K, _V, _T2) => (d, mapFn, reduceFn) => {
         if (d.size === 0) {
             throw new EastError("Cannot reduce empty dictionary with no initial value", { location });
         }
@@ -2955,7 +3086,7 @@ const builtin_evaluators = {
             unlockForIteration(d);
         }
     },
-    DictReduce: (location, _K, _V, _T2) => (d, f, init) => {
+    DictReduce: (location, _platformDef, _K, _V, _T2) => (d, f, init) => {
         let acc = init;
         lockForIteration(d);
         try {
@@ -2968,7 +3099,7 @@ const builtin_evaluators = {
             unlockForIteration(d);
         }
     },
-    DictToArray: (location, _K, _V, _T2) => (d, valueFn) => {
+    DictToArray: (location, _platformDef, _K, _V, _T2) => (d, valueFn) => {
         const ret = [];
         lockForIteration(d);
         try {
@@ -2982,7 +3113,7 @@ const builtin_evaluators = {
             unlockForIteration(d);
         }
     },
-    DictToSet: (location, _K, _V, K2) => {
+    DictToSet: (location, _platformDef, _K, _V, K2) => {
         const compare = compareFor(K2);
         return (d, fn) => {
             const result = new SortedSet([], compare);
@@ -2999,7 +3130,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictToDict: (location, K, _V, K2, _V2) => {
+    DictToDict: (location, _platformDef, K, _V, K2, _V2) => {
         const compare = compareFor(K2);
         return (d, keyFn, valueFn, onConflict) => {
             const result = new SortedMap([], compare);
@@ -3024,7 +3155,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictFlattenToArray: (location, _K, _V, _T2) => (d, fn) => {
+    DictFlattenToArray: (location, _platformDef, _K, _V, _T2) => (d, fn) => {
         const ret = [];
         lockForIteration(d);
         try {
@@ -3040,7 +3171,7 @@ const builtin_evaluators = {
             unlockForIteration(d);
         }
     },
-    DictFlattenToSet: (location, _K, _V, K2) => {
+    DictFlattenToSet: (location, _platformDef, _K, _V, K2) => {
         const compare = compareFor(K2);
         return (d, fn) => {
             const result = new SortedSet([], compare);
@@ -3059,7 +3190,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictFlattenToDict: (location, _K, _V, K2, _V2) => {
+    DictFlattenToDict: (location, _platformDef, _K, _V, K2, _V2) => {
         const compare = compareFor(K2);
         return (d, fn, onConflict) => {
             const result = new SortedMap([], compare);
@@ -3085,7 +3216,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictGroupFold: (location, _K, _V, K2, _T2) => {
+    DictGroupFold: (location, _platformDef, _K, _V, K2, _T2) => {
         const compare = compareFor(K2);
         return (d, keyFn, init, folder) => {
             const result = new SortedMap([], compare);