@ball-lang/engine 1.7.9 → 1.7.11

package/dist/compiled_engine.js

@@ -98,12 +98,26 @@ globalThis.BallObject = BallObject;
 // (e.g. 42.0 not 42). Used by the compiled Dart engine's _toDouble.
 class BallDouble {
     value;
-    constructor(v) { this.value = v; }
+    // Collapse nested wrapping down to the innermost raw number instead of
+    // storing a BallDouble that holds another BallDouble. The concrete source of
+    // nested wrapping was string_to_double's engine handler wrapping the result
+    // of the already-wrapping compiled parse path from issue 222; that redundant
+    // wrap was removed at its root in issue 237, so this guard is now purely
+    // defensive (verified: the full TS engine suite stays green without it). It is
+    // kept as a cheap, idempotent belt-and-suspenders against any other caller
+    // that might wrap an already-wrapped value: a doubly-wrapped BallDouble makes
+    // Number/valueOf coercion throw "Cannot convert object to primitive value".
+    // For a plain-number caller the instanceof check is a no-op.
+    constructor(v) { this.value = v instanceof BallDouble ? v.value : v; }
     valueOf() { return this.value; }
     get isNaN() { return Number.isNaN(this.value); }
     get isFinite() { return Number.isFinite(this.value); }
     get isInfinite() { return !Number.isFinite(this.value) && !Number.isNaN(this.value); }
     get isNegative() { return this.value < 0 || (this.value === 0 && 1 / this.value === -Infinity); }
+    // Mirrors the Number.prototype.remainder polyfill below (truncating
+    // remainder, matching JS % and Dart's num.remainder) — BallDouble wraps
+    // a JS number so it never inherits Number.prototype and needs its own.
+    remainder(other) { return this.value % Number(other); }
     toString() {
         const v = this.value;
         if (!isFinite(v))
@@ -252,11 +266,22 @@ function __ball_to_string(v) {
     }
     if (v instanceof Map) {
         const parts = [];
-        for (const [k, val] of v.entries()) {
+        // v.entries() as a method call would hit the Dart-property-style
+        // getter of the same name (installed further down in this file) and
+        // try to invoke its return value -- an array -- as a function.
+        // _nativeMapEntries is the real, un-shadowed method (issue #259).
+        for (const [k, val] of _nativeMapEntries.call(v)) {
             parts.push(__ball_to_string(k) + ': ' + __ball_to_string(val));
         }
         return '{' + parts.join(', ') + '}';
     }
+    if (v instanceof Set) {
+        // A Set is a plain object from typeof's perspective (falls through to
+        // the generic branch below, which reads Object.keys — always [] for a
+        // Set's internal slots), so every Set printed as the empty "{}" no
+        // matter its contents until this dedicated case was added (#219).
+        return '{' + [...v].map(__ball_to_string).join(', ') + '}';
+    }
     if (typeof v === 'object' && !Array.isArray(v)) {
         // StringBuffer-like objects
         if (v['__buffer__'] && Array.isArray(v['__buffer__'])) {
@@ -313,17 +338,30 @@ function __ball_to_int(v) {
     }
     return t;
 }
+// Returns a BallDouble (not a bare number) so a whole-valued result (e.g.
+// double.parse('7.0')) still prints "7.0", not "7" — JS numbers erase the
+// int/double distinction that the wrapper exists to preserve (#67/#222).
 function __ball_parse_double(s) {
     const n = parseFloat(s);
     if (Number.isNaN(n))
         throw new Error('FormatException: ' + s);
-    return n;
+    return new BallDouble(n);
 }
 function __ball_double_to_string(n) {
     if (Number.isInteger(n))
         return n.toFixed(1);
     return n.toString();
 }
+// num.toStringAsFixed(digits). JS Number.prototype.toFixed drops the sign of
+// -0 (returns "0.00" not "-0.00"); Dart's toStringAsFixed keeps it, matching
+// the -0 handling __ball_to_string/BallDouble.toString already do.
+function __ball_to_fixed(v, digits) {
+    const n = Number(v);
+    const s = n.toFixed(digits);
+    if (n === 0 && 1 / n === -Infinity && !s.startsWith('-'))
+        return '-' + s;
+    return s;
+}
 // Polymorphic concat / merge used for std.list_concat. The encoder emits
 // list_concat both for Dart list concat AND for Map.addAll(...) (encoded as
 // m = list_concat(m, other)). Arrays concat positionally; plain objects
@@ -369,11 +407,11 @@ function __ball_push_all(target, items) {
 // demotes back to Number when the result fits in MAX_SAFE_INTEGER.
 const __I64_MAX = 9223372036854775807n;
 const __I64_MIN = -9223372036854775808n;
-const __I64_MOD = 18446744073709551616n;
 function __i64_wrap(v) {
-    v = ((v % __I64_MOD) + __I64_MOD) % __I64_MOD;
-    if (v > __I64_MAX)
-        v = v - __I64_MOD;
+    // Two's-complement wrap to the signed 64-bit range — BigInt.asIntN(64, v)
+    // is the idiomatic builtin for exactly this (equivalent to the old manual
+    // modulo-then-resign, verified against it across boundary/overflow cases).
+    v = BigInt.asIntN(64, v);
     if (v >= -9007199254740991n && v <= 9007199254740991n)
         return Number(v);
     return v;
@@ -381,16 +419,73 @@ function __i64_wrap(v) {
 function __to_bigint(v) {
     if (typeof v === 'bigint')
         return v;
+    // Matches the reference Dart engine's _toInt (engine_std.dart), which
+    // falls through to 0 for anything that isn't an int/BallInt/double/
+    // BallDouble/String/bool -- including null. NaN is deliberately NOT
+    // special-cased here: Dart's double.toInt() throws on NaN (via
+    // _ballDoubleToInt64), and BigInt(NaN) already throws for the same
+    // reason (RangeError: not an integer), so that path already fails loud
+    // consistently with the reference engine without any extra handling.
+    if (v === null || v === undefined)
+        return 0n;
     if (v instanceof BallDouble)
         return BigInt(Math.trunc(v.value));
     return BigInt(v);
 }
-function __ball_bitand(a, b) { return __i64_wrap(__to_bigint(a) & __to_bigint(b)); }
-function __ball_bitor(a, b) { return __i64_wrap(__to_bigint(a) | __to_bigint(b)); }
-function __ball_bitxor(a, b) { return __i64_wrap(__to_bigint(a) ^ __to_bigint(b)); }
-function __ball_bitnot(a) { return __i64_wrap(~__to_bigint(a)); }
+// Fast-path guard: true when v is a plain (non-bigint, non-BallDouble)
+// integer within the signed 32-bit range. AND/OR/XOR/NOT never grow a
+// result past its operands' bit width, so when both operands fit in 32
+// bits, JS's native 32-bit bitwise operators give a result numerically
+// IDENTICAL to the full 64-bit BigInt path (sign-extending a 32-bit value
+// to 64 bits before AND/OR/XOR/NOT never changes the low 32 result bits,
+// and — verified across the full boundary range — never changes whether
+// the high bits are the correct sign-extension of them either). Left/right
+// shift are NOT given this fast path: shifting can grow a result past 32
+// bits even when the input operand fits (e.g. large_int << 40), so their
+// overflow behavior isn't safely 32-bit-local the way AND/OR/XOR/NOT is.
+function __fits32(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v >= -2147483648 && v <= 2147483647;
+}
+function __ball_bitand(a, b) {
+    if (__fits32(a) && __fits32(b))
+        return a & b;
+    return __i64_wrap(__to_bigint(a) & __to_bigint(b));
+}
+function __ball_bitor(a, b) {
+    if (__fits32(a) && __fits32(b))
+        return a | b;
+    return __i64_wrap(__to_bigint(a) | __to_bigint(b));
+}
+function __ball_bitxor(a, b) {
+    if (__fits32(a) && __fits32(b))
+        return a ^ b;
+    return __i64_wrap(__to_bigint(a) ^ __to_bigint(b));
+}
+function __ball_bitnot(a) {
+    if (__fits32(a))
+        return ~a;
+    return __i64_wrap(~__to_bigint(a));
+}
 function __ball_shl(a, b) { return __i64_wrap(__to_bigint(a) << __to_bigint(b)); }
 function __ball_shr(a, b) { return __i64_wrap(__to_bigint(a) >> __to_bigint(b)); }
+// Unsigned/logical shift: reinterpret a as an unsigned 64-bit value (add
+// 2^64 if negative) before shifting, so zeros fill from the left instead of
+// the sign bit — unlike >>> on raw JS numbers, which is only 32-bit.
+function __ball_ushr(a, b) {
+    const unsigned = BigInt.asUintN(64, __to_bigint(a));
+    return __i64_wrap(unsigned >> __to_bigint(b));
+}
+// json_encode (dart:convert's jsonEncode) on a bigint-range int64 must not
+// crash -- JSON.stringify throws "Do not know how to serialize a BigInt"
+// without a toJSON. This is NOT proto3-JSON (which quotes int64 as a
+// string) -- Ball's dart:convert-style jsonEncode matches Dart's own
+// dart:convert (a bare, unquoted JSON number) and the C++ self-host's
+// _ball_json_encode (std::to_string(int64_t), also unquoted). JSON.rawJSON
+// embeds the exact decimal digits as a raw number token, avoiding the
+// precision loss Number(this) would introduce for values past 2^53.
+BigInt.prototype.toJSON = function () {
+    return JSON.rawJSON(this.toString());
+};
 function __ball_negate(a) {
     if (typeof a === 'bigint')
         return __i64_wrap(-a);
@@ -465,14 +560,6 @@ function __dart_mod(a, b) {
 }
 // Active exception for rethrow. Catch bodies shadow with a local.
 let __ball_active_error = undefined;
-// Safe own-property lookup. Returns undefined if key is not an own property.
-// Avoids triggering Object.prototype getters (entries, keys, values) on
-// plain objects that aren't meant to be Dart Maps.
-function __ball_own(obj, key) {
-    if (obj == null || typeof obj !== 'object')
-        return undefined;
-    return Object.prototype.hasOwnProperty.call(obj, key) ? obj[key] : undefined;
-}
 // Dart-style index access. Dart's List '[]' operator throws RangeError on
 // out-of-bounds access, whereas JS array indexing silently returns undefined.
 // To make 'on RangeError' catch clauses behave like Dart we bounds-check list
@@ -731,6 +818,19 @@ function __ball_cascade(target, ops) {
 // ── Dart \u2192 JS method-name polyfills ────────────────────────────────
 //
 // Idempotent: guarded so multiple preamble inclusions don't double-install.
+// Native Map.prototype.entries/keys/values, captured BEFORE the
+// installBallPolyfills IIFE below shadows them with Dart-property-style
+// getters of the same name. Top-level (not IIFE-scoped) so every internal
+// call site that needs the REAL iterator method -- not the property-style
+// getter -- can reach it: the getters themselves (which must call the
+// original to avoid recursing into themselves), __ball_to_string's Map
+// printer, the Map-like constructor copy sites, and the map_keys/values/
+// entries base-function helpers (issue #259 -- calling .entries()/etc.
+// as a METHOD on a real Map after the shadow is installed throws, since
+// the getter's return value -- an array -- isn't itself callable).
+const _nativeMapEntries = Map.prototype.entries;
+const _nativeMapKeys = Map.prototype.keys;
+const _nativeMapValues = Map.prototype.values;
 (function installBallPolyfills() {
     const mp = Map.prototype;
     if (!mp.containsKey)
@@ -745,7 +845,9 @@ function __ball_cascade(target, ops) {
     if (!mp.addAll) {
         mp.addAll = function (other) {
             if (other instanceof Map) {
-                for (const [k, v] of other.entries())
+                // _nativeMapEntries, not other.entries() -- see __ball_to_string's
+                // Map printer above for why (issue #259).
+                for (const [k, v] of _nativeMapEntries.call(other))
                     this.set(k, v);
             }
             else if (other && typeof other === 'object') {
@@ -915,6 +1017,9 @@ function __ball_cascade(target, ops) {
     Object.defineProperty(_ballNp, 'isInfinite', {
         configurable: true, get() { const n = Number(this); return n === Infinity || n === -Infinity; },
     });
+    Object.defineProperty(_ballNp, 'isNegative', {
+        configurable: true, get() { const n = Number(this); return n < 0 || (n === 0 && 1 / n === -Infinity); },
+    });
     if (!_ballNp.abs)
         _ballNp.abs = function () { return Math.abs(Number(this)); };
     if (!_ballNp.ceil)
@@ -934,7 +1039,7 @@ function __ball_cascade(target, ops) {
     if (!_ballNp.compareTo)
         _ballNp.compareTo = function (other) { const a = Number(this), b = Number(other); return a < b ? -1 : a > b ? 1 : 0; };
     if (!_ballNp.toStringAsFixed)
-        _ballNp.toStringAsFixed = function (digits) { return Number(this).toFixed(digits); };
+        _ballNp.toStringAsFixed = function (digits) { return __ball_to_fixed(this, digits); };
     if (!_ballNp.remainder)
         _ballNp.remainder = function (other) { return Number(this) % Number(other); };
     // Object.prototype polyfills — used by the compiled engine when
@@ -975,7 +1080,8 @@ function __ball_cascade(target, ops) {
             value: function (other) {
                 if (this instanceof Map) {
                     if (other instanceof Map) {
-                        for (const [k, v] of other.entries())
+                        // _nativeMapEntries, not other.entries() (issue #259).
+                        for (const [k, v] of _nativeMapEntries.call(other))
                             this.set(k, v);
                     }
                     else if (other && typeof other === 'object') {
@@ -1041,9 +1147,9 @@ function __ball_cascade(target, ops) {
     // JS Map has them as METHODS (need parens). The compiled engine
     // accesses map.entries as a getter. Shadow BOTH Map.prototype AND
     // Object.prototype so Map and plain-object dispatch tables work.
-    const _nativeMapEntries = Map.prototype.entries;
-    const _nativeMapKeys = Map.prototype.keys;
-    const _nativeMapValues = Map.prototype.values;
+    // (_nativeMapEntries/_nativeMapKeys/_nativeMapValues are captured at
+    // top level above, not here, so other call sites outside this IIFE
+    // can reach them too -- issue #259.)
     // Shadow Map.prototype.entries with a getter (Dart uses it as a getter).
     Object.defineProperty(Map.prototype, 'entries', {
         configurable: true, enumerable: false,
@@ -1074,25 +1180,44 @@ function __ball_cascade(target, ops) {
             },
         });
     }
+    // .entries/.keys/.values on a non-Map must FAIL LOUD (throw a catchable
+    // error), not silently return [] — the silent-degradation class of bug
+    // that hid issue #55 (mirrors the fix already applied to the Dart/C++
+    // compilers). .entries used to be the odd one out here, silently
+    // returning [] instead of throwing — same bug family as #218.
+    //
+    // A getter installed on Object.prototype is invoked in "sloppy" (non-strict)
+    // script contexts with this auto-boxed to a Number/String/Boolean WRAPPER
+    // object for a primitive receiver (e.g. (42).keys boxes this to a Number
+    // instance) — typeof this is then 'object', not 'number', so a bare
+    // __ball_is_type(this, 'Map') (which only excludes Array/BallDouble/Set)
+    // would wrongly treat a boxed int/string as Map-like. Exclude the wrapper
+    // types explicitly instead of widening the shared type-check.
+    const __isGenuineMap = (v) => typeof v === 'object' && v !== null && !Array.isArray(v) &&
+        !(v instanceof BallDouble) && !(v instanceof Set) &&
+        !(v instanceof Number) && !(v instanceof String) && !(v instanceof Boolean);
     defDartGetter('entries', function () {
         if (this instanceof Map)
             return [..._nativeMapEntries.call(this)].map(([k, v]) => ({ key: k, value: v }));
-        if (this == null || typeof this !== 'object')
-            return [];
+        if (!__isGenuineMap(this)) {
+            throw new Error('type \'' + __ball_to_string(this) + '\' has no .entries getter (not a Map)');
+        }
         return Object.entries(this).map(([k, v]) => ({ key: k, value: v }));
     });
     defDartGetter('keys', function () {
         if (this instanceof Map)
             return [..._nativeMapKeys.call(this)];
-        if (this == null || typeof this !== 'object')
-            return [];
+        if (!__isGenuineMap(this)) {
+            throw new Error('type \'' + __ball_to_string(this) + '\' has no .keys getter (not a Map)');
+        }
         return Object.keys(this);
     });
     defDartGetter('values', function () {
         if (this instanceof Map)
             return [..._nativeMapValues.call(this)];
-        if (this == null || typeof this !== 'object')
-            return [];
+        if (!__isGenuineMap(this)) {
+            throw new Error('type \'' + __ball_to_string(this) + '\' has no .values getter (not a Map)');
+        }
         return Object.values(this);
     });
     defDartGetter('length', function () {
@@ -1155,6 +1280,67 @@ function __ball_cascade(target, ops) {
         get() { return 'bool'; },
     });
 })();
+// std.map_keys/std.map_values/std.map_entries (the base-function-call form,
+// as opposed to the .keys/.values/.entries DART-GETTER-STYLE property
+// access the defDartGetter block above already guards) must ALSO fail loud
+// on a non-Map receiver instead of silently returning [] — same "genuine
+// Map" check, exposed as top-level helpers so compileStdCall's emitted code
+// can call them (#218).
+function __ball_map_keys(m) {
+    // _nativeMapKeys, not m.keys() -- m.keys() would hit the Dart-property-
+    // style getter shadowing Map.prototype.keys and try to invoke its
+    // return value (an array) as a function (issue #259).
+    if (m instanceof Map)
+        return [..._nativeMapKeys.call(m)];
+    if (typeof m !== 'object' || m === null || Array.isArray(m) ||
+        m instanceof BallDouble || m instanceof Set ||
+        m instanceof Number || m instanceof String || m instanceof Boolean) {
+        throw new Error('type \'' + __ball_to_string(m) + '\' has no .keys getter (not a Map)');
+    }
+    return Object.keys(m);
+}
+function __ball_map_values(m) {
+    // _nativeMapValues, not m.values() (issue #259 -- see __ball_map_keys).
+    if (m instanceof Map)
+        return [..._nativeMapValues.call(m)];
+    if (typeof m !== 'object' || m === null || Array.isArray(m) ||
+        m instanceof BallDouble || m instanceof Set ||
+        m instanceof Number || m instanceof String || m instanceof Boolean) {
+        throw new Error('type \'' + __ball_to_string(m) + '\' has no .values getter (not a Map)');
+    }
+    return Object.values(m);
+}
+function __ball_map_entries(m) {
+    // _nativeMapEntries, not m.entries() (issue #259 -- see __ball_map_keys).
+    if (m instanceof Map)
+        return [..._nativeMapEntries.call(m)].map(([k, v]) => ({ key: k, value: v }));
+    if (typeof m !== 'object' || m === null || Array.isArray(m) ||
+        m instanceof BallDouble || m instanceof Set ||
+        m instanceof Number || m instanceof String || m instanceof Boolean) {
+        throw new Error('type \'' + __ball_to_string(m) + '\' has no .entries getter (not a Map)');
+    }
+    return Object.entries(m).map(([k, v]) => ({ key: k, value: v }));
+}
+// Shared guard for the REMAINING map_* base-function-call cases
+// (map_get/map_set/map_delete/map_merge/map_length/map_is_empty/
+// map_contains_key/map_contains_value/map_foreach) that used to route a
+// bare map[key], Object.keys/values(map), or key in map straight to the
+// receiver with no type check at all -- silently returning undefined,
+// no-opping, or checking array-index membership instead of throwing on a
+// non-Map (issue #55's silent-degradation class, same family as #218's
+// map_keys/map_values/map_entries). Returns the validated Map/plain-object
+// itself (not a boolean) so a call site can keep using it directly, e.g.
+// __ball_require_map(x, 'map_get')[key].
+function __ball_require_map(v, opName) {
+    if (v instanceof Map)
+        return v;
+    if (typeof v !== 'object' || v === null || Array.isArray(v) ||
+        v instanceof BallDouble || v instanceof Set ||
+        v instanceof Number || v instanceof String || v instanceof Boolean) {
+        throw new Error('type \'' + __ball_to_string(v) + '\' is not a Map (' + opName + ')');
+    }
+    return v;
+}
 // ── Protobuf Struct/Value compatibility ─────────────────────────
 //
 // Dart's protobuf runtime wraps google.protobuf.Struct as a class
@@ -1851,7 +2037,7 @@ export class BallEngine {
                 }
                 if (hasMetadata(func)) {
                     let params = this._extractParams(func.metadata);
-                    if (!(params.length === 0)) {
+                    if ((!(params.length === 0) && !(func.name.length === 0))) {
                         this._paramCache[key] = params;
                     }
                     let kindField = __ball_index(func.metadata.fields, 'kind');
@@ -1928,7 +2114,7 @@ export class BallEngine {
     }
     _resolveInstanceMethodDispatch(typeName, methodName) {
         let cacheKey = BallEngine._typeMethodKey(typeName, methodName);
-        if ((cacheKey in this._instanceMethodCache)) {
+        if ((cacheKey in __ball_require_map(this._instanceMethodCache, 'map_contains_key'))) {
             return __ball_index(this._instanceMethodCache, cacheKey);
         }
         let resolved = (this._resolveMethod(typeName, methodName) ?? this._lookupTypeMethodWithInheritance(typeName, methodName));
@@ -2098,7 +2284,7 @@ export class BallEngine {
                 let dotIdx = func.name.indexOf('.');
                 let typeName = (__ball_ge(dotIdx, 0) ? func.name.substring(0, dotIdx) : func.name);
                 let isFactory = (hasMetadata(func) && _metadataBool(__ball_index(func.metadata.fields, 'is_factory')));
-                if (((!isFactory && (__ball_eq(constructorInput, null) || !('self' in constructorInput))) && !__ball_eq(this._findTypeDef(typeName), null))) {
+                if (((!isFactory && (__ball_eq(constructorInput, null) || !('self' in __ball_require_map(constructorInput, 'map_contains_key')))) && !__ball_eq(this._findTypeDef(typeName), null))) {
                     return this._callObjectConstructor(moduleName, func, input);
                 }
             }
@@ -2108,15 +2294,15 @@ export class BallEngine {
             if ((!(func.inputType.length === 0) && !__ball_eq(input, null))) {
                 scope.bind('input', input);
             }
-            let params = (__ball_index(this._paramCache, ((__ball_to_string(moduleName) + '.') + __ball_to_string(func.name))) ?? ((hasMetadata(func) ? this._extractParams(func.metadata) : [])));
+            let params = (!(func.name.length === 0) ? (__ball_index(this._paramCache, ((__ball_to_string(moduleName) + '.') + __ball_to_string(func.name))) ?? ((hasMetadata(func) ? this._extractParams(func.metadata) : []))) : ((hasMetadata(func) ? this._extractParams(func.metadata) : [])));
             let inputMap = this._asMap(input);
             if (!(params.length === 0)) {
-                if ((__ball_eq(params.length, 1) && !(!__ball_eq(inputMap, null) && ('self' in inputMap)))) {
-                    if ((!__ball_eq(inputMap, null) && (__ball_index(params, 0) in inputMap))) {
+                if ((__ball_eq(params.length, 1) && !(!__ball_eq(inputMap, null) && ('self' in __ball_require_map(inputMap, 'map_contains_key'))))) {
+                    if ((!__ball_eq(inputMap, null) && (__ball_index(params, 0) in __ball_require_map(inputMap, 'map_contains_key')))) {
                         scope.bind(__ball_index(params, 0), __ball_index(inputMap, __ball_index(params, 0)));
                     }
                     else {
-                        if (((!__ball_eq(inputMap, null) && ('arg0' in inputMap)) && !(__ball_index(params, 0) in inputMap))) {
+                        if (((!__ball_eq(inputMap, null) && ('arg0' in __ball_require_map(inputMap, 'map_contains_key'))) && !(__ball_index(params, 0) in __ball_require_map(inputMap, 'map_contains_key')))) {
                             scope.bind(__ball_index(params, 0), __ball_index(inputMap, 'arg0'));
                         }
                         else {
@@ -2128,15 +2314,15 @@ export class BallEngine {
                     if (!__ball_eq(inputMap, null)) {
                         for (let i = 0; __ball_lt(i, params.length); (i++)) {
                             let p = __ball_index(params, i);
-                            if ((p in inputMap)) {
+                            if ((p in __ball_require_map(inputMap, 'map_contains_key'))) {
                                 scope.bind(p, __ball_index(inputMap, p));
                             }
                             else {
-                                if ((('arg' + __ball_to_string(i)) in inputMap)) {
+                                if ((('arg' + __ball_to_string(i)) in __ball_require_map(inputMap, 'map_contains_key'))) {
                                     scope.bind(p, __ball_index(inputMap, ('arg' + __ball_to_string(i))));
                                 }
                                 else {
-                                    if ((((__ball_eq(i, 0) && __ball_eq(params.length, 1)) && ('value' in inputMap)) && this._isSetter(func))) {
+                                    if ((((__ball_eq(i, 0) && __ball_eq(params.length, 1)) && ('value' in __ball_require_map(inputMap, 'map_contains_key'))) && this._isSetter(func))) {
                                         scope.bind(p, __ball_index(inputMap, 'value'));
                                     }
                                 }
@@ -2152,7 +2338,7 @@ export class BallEngine {
                     }
                 }
             }
-            if ((!__ball_eq(inputMap, null) && ('self' in inputMap))) {
+            if ((!__ball_eq(inputMap, null) && ('self' in __ball_require_map(inputMap, 'map_contains_key')))) {
                 let self = __ball_index(inputMap, 'self');
                 scope.bind('self', self);
                 let selfMap = this._asMap(self);
@@ -2187,7 +2373,7 @@ export class BallEngine {
             let isAsyncStar = (hasMetadata(func) && _metadataBool(__ball_index(func.metadata.fields, 'is_async_star')));
             let isGenerator = (hasMetadata(func) && _metadataBool(__ball_index(func.metadata.fields, 'is_generator')));
             let isGenFunc = ((isSyncStar || isAsyncStar) || isGenerator);
-            let generator = __no_init__;
+            let generator;
             if (isGenFunc) {
                 generator = _ballNewGenerator();
                 scope.bind('__generator__', generator);
@@ -2196,7 +2382,7 @@ export class BallEngine {
                 this._activeGeneratorScope = scope;
             }
             let isAsync = (hasMetadata(func) && _metadataBool(__ball_index(func.metadata.fields, 'is_async')));
-            let finalResult = __no_init__;
+            let finalResult;
             if ((isAsync && !isGenFunc)) {
                 try {
                     let result = await this._evalExpression(func.body, scope);
@@ -2217,7 +2403,7 @@ export class BallEngine {
             else {
                 let result = await this._evalExpression(func.body, scope);
                 this._currentModule = prevModule;
-                if (((__ball_eq(kind, 'constructor') && !__ball_eq(inputMap, null)) && ('self' in inputMap))) {
+                if (((__ball_eq(kind, 'constructor') && !__ball_eq(inputMap, null)) && ('self' in __ball_require_map(inputMap, 'map_contains_key')))) {
                     let isFactory = (hasMetadata(func) && _metadataBool(__ball_index(func.metadata.fields, 'is_factory')));
                     if (((result instanceof _FlowSignal) && __ball_eq(result.kind, 'return'))) {
                         finalResult = result.value;
@@ -2291,16 +2477,16 @@ export class BallEngine {
         let resolvedParams = {};
         for (let i = 0; __ball_lt(i, params.length); (i++)) {
             let param = __ball_index(params, i);
-            let value = __no_init__;
-            if ((param in inputMap)) {
+            let value;
+            if ((param in __ball_require_map(inputMap, 'map_contains_key'))) {
                 value = __ball_index(inputMap, param);
             }
             else {
-                if ((('arg' + __ball_to_string(i)) in inputMap)) {
+                if ((('arg' + __ball_to_string(i)) in __ball_require_map(inputMap, 'map_contains_key'))) {
                     value = __ball_index(inputMap, ('arg' + __ball_to_string(i)));
                 }
             }
-            if (((__ball_eq(value, null) && __ball_lt(i, paramsMeta.length)) && ('default' in __ball_index(paramsMeta, i)))) {
+            if (((__ball_eq(value, null) && __ball_lt(i, paramsMeta.length)) && ('default' in __ball_require_map(__ball_index(paramsMeta, i), 'map_contains_key')))) {
                 value = __ball_index(__ball_index(paramsMeta, i), 'default');
             }
             resolvedParams[param] = value;
@@ -2316,7 +2502,7 @@ export class BallEngine {
         }
         this._initFieldDefaults(typeName, instanceFields);
         let superclass = this._getMetaString(typeDef, 'superclass');
-        let superObject = __no_init__;
+        let superObject;
         if ((!__ball_eq(superclass, null) && !(superclass.length === 0))) {
             superObject = await this._invokeSuperConstructor(func, superclass, resolvedParams);
             superObject ??= this._buildSuperObject(superclass, instanceFields);
@@ -2332,7 +2518,7 @@ export class BallEngine {
         })();
         let constructed = await this._callFunction(moduleName, func, ctorInput);
         let constructedMap = this._asMap(constructed);
-        if ((!__ball_eq(constructedMap, null) && ('__type__' in constructedMap))) {
+        if ((!__ball_eq(constructedMap, null) && ('__type__' in __ball_require_map(constructedMap, 'map_contains_key')))) {
             return constructed;
         }
         return instance;
@@ -2428,12 +2614,12 @@ export class BallEngine {
             for (let i = 0; __ball_lt(i, params.length); (i++)) {
                 let p = __ball_index(params, i);
                 let isThis = (__ball_lt(i, paramsMeta.length) && __ball_eq(__ball_index(__ball_index(paramsMeta, i), 'is_this'), true));
-                let val = __no_init__;
-                if ((p in inputMap)) {
+                let val;
+                if ((p in __ball_require_map(inputMap, 'map_contains_key'))) {
                     val = __ball_index(inputMap, p);
                 }
                 else {
-                    if ((('arg' + __ball_to_string(i)) in inputMap)) {
+                    if ((('arg' + __ball_to_string(i)) in __ball_require_map(inputMap, 'map_contains_key'))) {
                         val = __ball_index(inputMap, ('arg' + __ball_to_string(i)));
                     }
                     else {
@@ -2471,7 +2657,7 @@ export class BallEngine {
                 if (!__ball_eq(superMap, null)) {
                     instance['__super__'] = superInstance;
                     for (const e of superMap.entries) {
-                        if ((!e.key.startsWith('__') && !(e.key in instance))) {
+                        if ((!e.key.startsWith('__') && !(e.key in __ball_require_map(instance, 'map_contains_key')))) {
                             instance[e.key] = e.value;
                         }
                     }
@@ -2514,7 +2700,7 @@ export class BallEngine {
                         let superInput = {};
                         for (let i = 0; __ball_lt(i, argNames.length); (i++)) {
                             let token = __ball_index(argNames, i);
-                            if ((token in resolvedParams)) {
+                            if ((token in __ball_require_map(resolvedParams, 'map_contains_key'))) {
                                 superInput[('arg' + __ball_to_string(i))] = __ball_index(resolvedParams, token);
                             }
                             else {
@@ -3139,7 +3325,7 @@ export class BallEngine {
             }
             if (hasMetadata(func)) {
                 let params = this._extractParams(func.metadata);
-                if (!(params.length === 0)) {
+                if ((!(params.length === 0) && !(func.name.length === 0))) {
                     this._paramCache[key] = params;
                 }
                 let kindField = __ball_index(func.metadata.fields, 'kind');
@@ -3171,7 +3357,7 @@ export class BallEngine {
     }
     static _extractMetadataTypeArgs(msg) {
         const input = msg;
-        if ((!hasMetadata(msg) || !('type_args' in msg.metadata.fields))) {
+        if ((!hasMetadata(msg) || !('type_args' in __ball_require_map(msg.metadata.fields, 'map_contains_key')))) {
             return null;
         }
         return [...__ball_index(msg.metadata.fields, 'type_args').listValue.values.map(BallEngine._typeRefValueToString)];
@@ -3355,7 +3541,7 @@ export class BallEngine {
             }
         }
         let inputMap = this._asMap(input);
-        if ((!__ball_eq(inputMap, null) && ('self' in inputMap))) {
+        if ((!__ball_eq(inputMap, null) && ('self' in __ball_require_map(inputMap, 'map_contains_key')))) {
             let self = __ball_index(inputMap, 'self');
             let selfMap = this._asMap(self);
             if (!__ball_eq(selfMap, null)) {
@@ -3392,7 +3578,7 @@ export class BallEngine {
                     let methodOwner = selfMap;
                     while (!__ball_eq(methodOwner, null)) {
                         let methods = __ball_index(methodOwner, '__methods__');
-                        if (((typeof methods === 'object' && methods !== null && !Array.isArray(methods) && !(methods instanceof BallDouble) && !(methods instanceof Set)) && (call.function in methods))) {
+                        if (((typeof methods === 'object' && methods !== null && !Array.isArray(methods) && !(methods instanceof BallDouble) && !(methods instanceof Set)) && (call.function in __ball_require_map(methods, 'map_contains_key')))) {
                             let method = __ball_index(methods, call.function);
                             if ((typeof method === 'function')) {
                                 let result = method(input);
@@ -3416,7 +3602,7 @@ export class BallEngine {
             }
         }
         let fallbackMap = this._asMap(input);
-        if ((!__ball_eq(fallbackMap, null) && ('self' in fallbackMap))) {
+        if ((!__ball_eq(fallbackMap, null) && ('self' in __ball_require_map(fallbackMap, 'map_contains_key')))) {
             let selfFallback = __ball_index(fallbackMap, 'self');
             let selfFallbackMap = this._asMap(selfFallback);
             if (!__ball_eq(selfFallbackMap, null)) {
@@ -3693,7 +3879,7 @@ export class BallEngine {
     async _evalReference(ref, scope) {
         let name = ref.name;
         if (__ball_eq(name, 'super')) {
-            let selfRef = __no_init__;
+            let selfRef;
             try {
                 selfRef = scope.lookup('self');
             }
@@ -3736,12 +3922,12 @@ export class BallEngine {
         }
         if (!_builtinTypeNames.includes(name)) {
             let qualifiedName = ((__ball_to_string(this._currentModule) + ':') + __ball_to_string(name));
-            let hasCtor = ((name in this._constructors) || (qualifiedName in this._constructors));
+            let hasCtor = ((name in __ball_require_map(this._constructors, 'map_contains_key')) || (qualifiedName in __ball_require_map(this._constructors, 'map_contains_key')));
             let hasStaticMethods = this._functions.keys.some(((k) => {
                 const input = k;
                 return (k.startsWith((((__ball_to_string(this._currentModule) + '.') + __ball_to_string(qualifiedName)) + '.')) || k.startsWith((((__ball_to_string(this._currentModule) + '.') + __ball_to_string(name)) + '.')));
             }));
-            let typeExists = ((name in this._types) || (qualifiedName in this._types));
+            let typeExists = ((name in __ball_require_map(this._types, 'map_contains_key')) || (qualifiedName in __ball_require_map(this._types, 'map_contains_key')));
             if ((typeExists && (hasCtor || hasStaticMethods))) {
                 return { ['__class_ref__']: name, ['__type__']: '__class__' };
             }
@@ -3751,7 +3937,7 @@ export class BallEngine {
         if ((!__ball_eq(getterFunc, null) && this._isGetter(getterFunc))) {
             return this._callFunction(this._currentModule, getterFunc, null);
         }
-        let selfForGetter = __no_init__;
+        let selfForGetter;
         try {
             selfForGetter = scope.lookup('self');
         }
@@ -3762,7 +3948,7 @@ export class BallEngine {
         if (!__ball_eq(selfForGetter, null)) {
             let selfMap = this._asMap(selfForGetter);
             if (!__ball_eq(selfMap, null)) {
-                if ((name in selfMap)) {
+                if ((name in __ball_require_map(selfMap, 'map_contains_key'))) {
                     let direct = __ball_index(selfMap, name);
                     if (!__ball_eq(direct, null)) {
                         return direct;
@@ -3771,7 +3957,7 @@ export class BallEngine {
                 let superObj = __ball_index(selfMap, '__super__');
                 let superMap = this._asMap(superObj);
                 while (!__ball_eq(superMap, null)) {
-                    if ((name in superMap)) {
+                    if ((name in __ball_require_map(superMap, 'map_contains_key'))) {
                         let inherited = __ball_index(superMap, name);
                         if (!__ball_eq(inherited, null)) {
                             return inherited;
@@ -3896,25 +4082,25 @@ export class BallEngine {
                 });
             }
             let enumVals = (__ball_index(this._enumValues, className) ?? __ball_index(this._enumValues, qualifiedName));
-            if ((!__ball_eq(enumVals, null) && (fieldName in enumVals))) {
+            if ((!__ball_eq(enumVals, null) && (fieldName in __ball_require_map(enumVals, 'map_contains_key')))) {
                 return __ball_index(enumVals, fieldName);
             }
         }
         if (!__ball_eq(objectMap, null)) {
-            if ((fieldName in objectMap)) {
+            if ((fieldName in __ball_require_map(objectMap, 'map_contains_key'))) {
                 return __ball_index(objectMap, fieldName);
             }
             let superObj = __ball_index(objectMap, '__super__');
             let superMap = this._asMap(superObj);
             while (!__ball_eq(superMap, null)) {
-                if ((fieldName in superMap)) {
+                if ((fieldName in __ball_require_map(superMap, 'map_contains_key'))) {
                     return __ball_index(superMap, fieldName);
                 }
                 superObj = __ball_index(superMap, '__super__');
                 superMap = this._asMap(superObj);
             }
             let methods = __ball_index(objectMap, '__methods__');
-            if (((typeof methods === 'object' && methods !== null && !Array.isArray(methods) && !(methods instanceof BallDouble) && !(methods instanceof Set)) && (fieldName in methods))) {
+            if (((typeof methods === 'object' && methods !== null && !Array.isArray(methods) && !(methods instanceof BallDouble) && !(methods instanceof Set)) && (fieldName in __ball_require_map(methods, 'map_contains_key')))) {
                 let method = __ball_index(methods, fieldName);
                 if ((typeof method === 'function')) {
                     return method;
@@ -3924,7 +4110,7 @@ export class BallEngine {
             superMap = this._asMap(superObj);
             while (!__ball_eq(superMap, null)) {
                 let superMethods = __ball_index(superMap, '__methods__');
-                if (((typeof superMethods === 'object' && superMethods !== null && !Array.isArray(superMethods) && !(superMethods instanceof BallDouble) && !(superMethods instanceof Set)) && (fieldName in superMethods))) {
+                if (((typeof superMethods === 'object' && superMethods !== null && !Array.isArray(superMethods) && !(superMethods instanceof BallDouble) && !(superMethods instanceof Set)) && (fieldName in __ball_require_map(superMethods, 'map_contains_key')))) {
                     let method = __ball_index(superMethods, fieldName);
                     if ((typeof method === 'function')) {
                         return method;
@@ -3952,7 +4138,7 @@ export class BallEngine {
                         }))];
                     if ((!(vals.length === 0) && vals.every(((v) => {
                         const input = v;
-                        return (((typeof v === 'object' && v !== null && !Array.isArray(v) && !(v instanceof BallDouble) && !(v instanceof Set)) && ('index' in v)) && ('__type__' in v));
+                        return (((typeof v === 'object' && v !== null && !Array.isArray(v) && !(v instanceof BallDouble) && !(v instanceof Set)) && ('index' in __ball_require_map(v, 'map_contains_key'))) && ('__type__' in __ball_require_map(v, 'map_contains_key')));
                     })))) {
                         vals = [...vals].sort(((a, b) => {
                             return (__ball_index(a, 'index') < __ball_index(b, 'index') ? -1 : __ball_index(a, 'index') > __ball_index(b, 'index') ? 1 : 0);
@@ -4069,7 +4255,7 @@ export class BallEngine {
                         }))];
                     if ((!(vals.length === 0) && vals.every(((v) => {
                         const input = v;
-                        return (((typeof v === 'object' && v !== null && !Array.isArray(v) && !(v instanceof BallDouble) && !(v instanceof Set)) && ('index' in v)) && ('__type__' in v));
+                        return (((typeof v === 'object' && v !== null && !Array.isArray(v) && !(v instanceof BallDouble) && !(v instanceof Set)) && ('index' in __ball_require_map(v, 'map_contains_key'))) && ('__type__' in __ball_require_map(v, 'map_contains_key')));
                     })))) {
                         vals = [...vals].sort(((a, b) => {
                             return (__ball_index(a, 'index') < __ball_index(b, 'index') ? -1 : __ball_index(a, 'index') > __ball_index(b, 'index') ? 1 : 0);
@@ -4251,11 +4437,11 @@ export class BallEngine {
             return;
         }
         let backing = ('_' + __ball_to_string(fieldName));
-        if ((backing in object)) {
+        if ((backing in __ball_require_map(object, 'map_contains_key'))) {
             ballObjectSetField(object, backing, assignedValue);
             return;
         }
-        if (('_celsius' in object)) {
+        if (('_celsius' in __ball_require_map(object, 'map_contains_key'))) {
             ballObjectSetField(object, '_celsius', assignedValue);
         }
     }
@@ -4270,7 +4456,7 @@ export class BallEngine {
             let superObj = __ball_index(selfMap, '__super__');
             let superMap = this._asMap(superObj);
             while (!__ball_eq(superMap, null)) {
-                if ((fieldName in superMap)) {
+                if ((fieldName in __ball_require_map(superMap, 'map_contains_key'))) {
                     ballObjectSetField(superObj, fieldName, val);
                 }
                 superObj = __ball_index(superMap, '__super__');
@@ -4285,7 +4471,7 @@ export class BallEngine {
         let fields = {};
         for (const pair of msg.fields) {
             let val = await this._evalExpression(pair.value, scope);
-            if ((pair.name in fields)) {
+            if ((pair.name in __ball_require_map(fields, 'map_contains_key'))) {
                 let existing = __ball_index(fields, pair.name);
                 if (Array.isArray(existing)) {
                     let merged = ([...existing]);
@@ -4320,7 +4506,7 @@ export class BallEngine {
                 }
                 this._initFieldDefaults(msg.typeName, instanceFields);
                 for (const fieldName of typeDef.fieldNames) {
-                    if (!(fieldName in instanceFields)) {
+                    if (!(fieldName in __ball_require_map(instanceFields, 'map_contains_key'))) {
                         instanceFields[fieldName] = null;
                     }
                 }
@@ -4331,16 +4517,16 @@ export class BallEngine {
                     let paramsMeta = this._extractParamsMeta(ctorEntry.func.metadata);
                     for (let i = 0; __ball_lt(i, params.length); (i++)) {
                         let param = __ball_index(params, i);
-                        let value = __no_init__;
-                        if ((param in fields)) {
+                        let value;
+                        if ((param in __ball_require_map(fields, 'map_contains_key'))) {
                             value = __ball_index(fields, param);
                         }
                         else {
-                            if ((('arg' + __ball_to_string(i)) in fields)) {
+                            if ((('arg' + __ball_to_string(i)) in __ball_require_map(fields, 'map_contains_key'))) {
                                 value = __ball_index(fields, ('arg' + __ball_to_string(i)));
                             }
                         }
-                        if (((__ball_eq(value, null) && __ball_lt(i, paramsMeta.length)) && ('default' in __ball_index(paramsMeta, i)))) {
+                        if (((__ball_eq(value, null) && __ball_lt(i, paramsMeta.length)) && ('default' in __ball_require_map(__ball_index(paramsMeta, i), 'map_contains_key')))) {
                             value = __ball_index(__ball_index(paramsMeta, i), 'default');
                         }
                         resolvedParams[param] = value;
@@ -4359,12 +4545,12 @@ export class BallEngine {
                     this._applyConstructorInitializers(ctorEntry.func, instanceFields, resolvedParams, true);
                 }
                 let superclass = this._getMetaString(typeDef, 'superclass');
-                let superObject = __no_init__;
+                let superObject;
                 if ((!__ball_eq(superclass, null) && !(superclass.length === 0))) {
                     superObject = (__ball_eq(ctorEntry, null) ? null : await this._invokeSuperConstructor(ctorEntry.func, superclass, resolvedParams));
                     superObject ??= this._buildSuperObject(superclass, instanceFields);
                 }
-                if (!('__type_args__' in instanceFields)) {
+                if (!('__type_args__' in __ball_require_map(instanceFields, 'map_contains_key'))) {
                     let metaTypeArgs = BallEngine._extractMetadataTypeArgs(msg);
                     if (!__ball_eq(metaTypeArgs, null)) {
                         instanceFields['__type_args__'] = metaTypeArgs;
@@ -4402,7 +4588,7 @@ export class BallEngine {
                     })();
                     let constructed = await this._callFunction(ctorEntry.module, ctorEntry.func, ctorInput);
                     let constructedMap = this._asMap(constructed);
-                    if ((!__ball_eq(constructedMap, null) && ('__type__' in constructedMap))) {
+                    if ((!__ball_eq(constructedMap, null) && ('__type__' in __ball_require_map(constructedMap, 'map_contains_key')))) {
                         return constructed;
                     }
                     return instance;
@@ -4424,7 +4610,7 @@ export class BallEngine {
                             instanceFields[entry.key] = entry.value;
                         }
                     }
-                    if (!('__type_args__' in instanceFields)) {
+                    if (!('__type_args__' in __ball_require_map(instanceFields, 'map_contains_key'))) {
                         let metaTA = BallEngine._extractMetadataTypeArgs(msg);
                         if (!__ball_eq(metaTA, null)) {
                             instanceFields['__type_args__'] = metaTA;
@@ -4440,13 +4626,13 @@ export class BallEngine {
                     })();
                     let constructed = await this._callFunction(ctorEntry.module, ctorEntry.func, ctorInput);
                     let constructedMap = this._asMap(constructed);
-                    if ((!__ball_eq(constructedMap, null) && ('__type__' in constructedMap))) {
+                    if ((!__ball_eq(constructedMap, null) && ('__type__' in __ball_require_map(constructedMap, 'map_contains_key')))) {
                         return constructed;
                     }
                     return instance;
                 }
                 fields['__type__'] = msg.typeName;
-                if (!('__type_args__' in fields)) {
+                if (!('__type_args__' in __ball_require_map(fields, 'map_contains_key'))) {
                     let metaTA2 = BallEngine._extractMetadataTypeArgs(msg);
                     if (!__ball_eq(metaTA2, null)) {
                         fields['__type_args__'] = metaTA2;
@@ -4518,7 +4704,7 @@ export class BallEngine {
         for (const module of this.program.modules) {
             for (const td of module.typeDefs) {
                 if ((__ball_eq(td.name, typeName) || td.name.endsWith((':' + __ball_to_string(typeName))))) {
-                    let superclass = __no_init__;
+                    let superclass;
                     if (hasMetadata(td)) {
                         let sc = __ball_index(td.metadata.fields, 'superclass');
                         if ((!__ball_eq(sc, null) && hasStringValue(sc))) {
@@ -4567,7 +4753,7 @@ export class BallEngine {
                                     let __naa_10 = __ball_index(fv.structValue.fields, 'name');
                                     return (__ball_eq(__naa_10, null) ? null : __naa_10.stringValue);
                                 })();
-                                if ((__ball_eq(fname, null) || (fname in fields))) {
+                                if ((__ball_eq(fname, null) || (fname in __ball_require_map(fields, 'map_contains_key')))) {
                                     continue;
                                 }
                                 let init = (() => {
@@ -4669,20 +4855,20 @@ export class BallEngine {
         let parentTypeDef = this._findTypeDef(superclass);
         if (!__ball_eq(parentTypeDef, null)) {
             for (const fname of parentTypeDef.fieldNames) {
-                if ((fname in childFields)) {
+                if ((fname in __ball_require_map(childFields, 'map_contains_key'))) {
                     superFields[fname] = __ball_index(childFields, fname);
                 }
             }
             this._initFieldDefaults(superclass, superFields);
             for (const fname of parentTypeDef.fieldNames) {
-                if (!(fname in superFields)) {
+                if (!(fname in __ball_require_map(superFields, 'map_contains_key'))) {
                     superFields[fname] = null;
                 }
             }
             let parentMethods = this._resolveTypeMethods(qualifiedSuperclass);
             let parentMethodsMap = parentMethods.cast();
             let grandparent = parentTypeDef.superclass;
-            let grandparentObject = __no_init__;
+            let grandparentObject;
             if ((!__ball_eq(grandparent, null) && !(grandparent.length === 0))) {
                 grandparentObject = this._buildSuperObject(grandparent, childFields);
             }
@@ -4757,7 +4943,7 @@ export class BallEngine {
     }
     async _evalBlock(block, scope) {
         let blockScope = scope.child();
-        let flowResult = __no_init__;
+        let flowResult;
         for (const stmt of block.statements) {
             let result = await this._evalStatement(stmt, blockScope);
             if ((result instanceof _FlowSignal)) {
@@ -4777,7 +4963,7 @@ export class BallEngine {
             const __sw = whichStmt(stmt);
             if ((__sw === Statement_Stmt.let)) {
                 let letValue = stmt.let.value;
-                let value = __no_init__;
+                let value;
                 if ((__ball_eq(whichExpr(letValue), Expression_Expr.reference) && __ball_eq(letValue.reference.name, '__no_init__'))) {
                     value = null;
                 }
@@ -4831,11 +5017,11 @@ export class BallEngine {
                     for (let i = 0; __ball_lt(i, paramNames.length); (i++)) {
                         let p = __ball_index(paramNames, i);
                         if (!lambdaScope.has(p)) {
-                            if ((p in inputMap)) {
+                            if ((p in __ball_require_map(inputMap, 'map_contains_key'))) {
                                 lambdaScope.bind(p, __ball_index(inputMap, p));
                             }
                             else {
-                                if ((('arg' + __ball_to_string(i)) in inputMap)) {
+                                if ((('arg' + __ball_to_string(i)) in __ball_require_map(inputMap, 'map_contains_key'))) {
                                     lambdaScope.bind(p, __ball_index(inputMap, ('arg' + __ball_to_string(i))));
                                 }
                             }
@@ -4957,7 +5143,7 @@ export class BallEngine {
                     let rawVal = match.group(2).trim();
                     let intParsed = int.tryParse(rawVal);
                     let doubleParsed = (__ball_eq(intParsed, null) ? double.tryParse(rawVal) : null);
-                    let parsed = __no_init__;
+                    let parsed;
                     if (!__ball_eq(intParsed, null)) {
                         parsed = intParsed;
                     }
@@ -4997,7 +5183,7 @@ export class BallEngine {
             let operand = __ball_parse_int(propOpNum.group(4));
             if (scope.has(ref)) {
                 let obj = scope.lookup(ref);
-                let propVal = __no_init__;
+                let propVal;
                 if (((typeof obj === 'string') && __ball_eq(prop, 'length'))) {
                     propVal = obj.value.length;
                 }
@@ -5023,7 +5209,7 @@ export class BallEngine {
                                     }
                                     else {
                                         let map = this._cfAsMap(obj);
-                                        if ((!__ball_eq(map, null) && (prop in map))) {
+                                        if ((!__ball_eq(map, null) && (prop in __ball_require_map(map, 'map_contains_key')))) {
                                             let v = __ball_index(map, prop);
                                             if ((typeof v === 'number' || v instanceof BallDouble)) {
                                                 propVal = v;
@@ -5045,8 +5231,8 @@ export class BallEngine {
             let left = varOpVar.group(1);
             let op = varOpVar.group(2);
             let right = varOpVar.group(3);
-            let leftVal = __no_init__;
-            let rightVal = __no_init__;
+            let leftVal;
+            let rightVal;
             if (scope.has(left)) {
                 let v = scope.lookup(left);
                 if ((typeof v === 'number' || v instanceof BallDouble)) {
@@ -5094,7 +5280,7 @@ export class BallEngine {
                     return obj.length;
                 }
                 let map = this._cfAsMap(obj);
-                if ((!__ball_eq(map, null) && (prop in map))) {
+                if ((!__ball_eq(map, null) && (prop in __ball_require_map(map, 'map_contains_key')))) {
                     return __ball_index(map, prop);
                 }
             }
@@ -5199,7 +5385,7 @@ export class BallEngine {
         if ((!__ball_eq(whichExpr(cases), Expression_Expr.literal) || !__ball_eq(whichValue(cases.literal), Literal_Value.listValue))) {
             return null;
         }
-        let defaultBody = __no_init__;
+        let defaultBody;
         let matched = false;
         for (const caseExpr of cases.literal.listValue.elements) {
             if (!__ball_eq(whichExpr(caseExpr), Expression_Expr.messageCreation)) {
@@ -5259,7 +5445,7 @@ export class BallEngine {
         if ((!__ball_eq(whichExpr(cases), Expression_Expr.literal) || !__ball_eq(whichValue(cases.literal), Literal_Value.listValue))) {
             return null;
         }
-        let defaultBody = __no_init__;
+        let defaultBody;
         for (const caseExpr of cases.literal.listValue.elements) {
             if (!__ball_eq(whichExpr(caseExpr), Expression_Expr.messageCreation)) {
                 continue;
@@ -5375,7 +5561,7 @@ export class BallEngine {
                 }
             }
             let enumVals = __ball_index(this._enumValues, enumType);
-            if ((!__ball_eq(enumVals, null) && (enumValue in enumVals))) {
+            if ((!__ball_eq(enumVals, null) && (enumValue in __ball_require_map(enumVals, 'map_contains_key')))) {
                 let resolved = __ball_index(enumVals, enumValue);
                 let resolvedMap = this._cfAsMap(resolved);
                 if ((!__ball_eq(subjectMap, null) && !__ball_eq(resolvedMap, null))) {
@@ -5384,7 +5570,7 @@ export class BallEngine {
             }
             let qualifiedEnumType = ((__ball_to_string(this._currentModule) + ':') + __ball_to_string(enumType));
             let qualEnumVals = __ball_index(this._enumValues, qualifiedEnumType);
-            if ((!__ball_eq(qualEnumVals, null) && (enumValue in qualEnumVals))) {
+            if ((!__ball_eq(qualEnumVals, null) && (enumValue in __ball_require_map(qualEnumVals, 'map_contains_key')))) {
                 let resolved = __ball_index(qualEnumVals, enumValue);
                 let resolvedMap = this._cfAsMap(resolved);
                 if ((!__ball_eq(subjectMap, null) && !__ball_eq(resolvedMap, null))) {
@@ -5415,7 +5601,7 @@ export class BallEngine {
         let body = __ball_index(fields, 'body');
         let catches = __ball_index(fields, 'catches');
         let finallyBlock = __ball_index(fields, 'finally');
-        let result = __no_init__;
+        let result;
         try {
             result = (!__ball_eq(body, null) ? await this._evalExpression(body, scope) : null);
         }
@@ -5435,7 +5621,7 @@ export class BallEngine {
                     }
                     let catchType = this._stringFieldVal(cf, 'type');
                     if ((!__ball_eq(catchType, null) && !(catchType.length === 0))) {
-                        let matches = __no_init__;
+                        let matches;
                         if ((e instanceof BallException)) {
                             let eType = e['typeName'];
                             let eColonIdx = eType.indexOf(':');
@@ -5652,7 +5838,7 @@ export class BallEngine {
                     this._cfWritebackIndexed(indexTarget, list, scope);
                 }
                 if (((!__ball_eq(op, null) && !(op.length === 0)) && !__ball_eq(op, '='))) {
-                    let computed = __no_init__;
+                    let computed;
                     let didSet = false;
                     if ((false /* BallList is List in TS */ && (typeof idx === 'number' && Number.isInteger(idx)))) {
                         computed = this._applyCompoundOp(op, __ball_index(list.items, idx), val);
@@ -5881,7 +6067,7 @@ export class BallEngine {
         }))) : ((op === '>>=') ? (this._intOp(current, val, ((a, b) => {
             return __ball_shr(a, b);
         }))) : ((op === '>>>=') ? (this._intOp(current, val, ((a, b) => {
-            return (a >>> b);
+            return __ball_ushr(a, b);
         }))) : ((op === '??=') ? ((current ?? val)) : val)))))))))))));
     }
     _numOp(a, b, op) {
@@ -6153,7 +6339,7 @@ export class BallEngine {
         if (__ball_eq(body, null)) {
             return null;
         }
-        let result = __no_init__;
+        let result;
         let repeat = true;
         while (repeat) {
             repeat = false;
@@ -6241,7 +6427,7 @@ export class BallEngine {
         let args = (inputMap ?? {});
         let arg0 = (__ball_index(args, 'arg0') ?? __ball_index(args, 'value'));
         let wasBallList = false /* BallList is List in TS */;
-        let unwrappedSelf = __no_init__;
+        let unwrappedSelf;
         if (false /* BallList is List in TS */) {
             unwrappedSelf = self.items;
         }
@@ -6500,7 +6686,7 @@ export class BallEngine {
                 else if ((__sw === 'reduce')) {
                     if ((typeof arg0 === 'function')) {
                         let seeded = false;
-                        let acc = __no_init__;
+                        let acc;
                         for (const item of self) {
                             if (!seeded) {
                                 acc = item;
@@ -6556,13 +6742,13 @@ export class BallEngine {
                     let seen = {};
                     let result = [];
                     for (const item of self) {
-                        if (!(item in seen)) {
+                        if (!(item in __ball_require_map(seen, 'map_contains_key'))) {
                             seen[item] = item;
                             result = (result.push(item), result);
                         }
                     }
                     for (const item of other) {
-                        if (!(item in seen)) {
+                        if (!(item in __ball_require_map(seen, 'map_contains_key'))) {
                             seen[item] = item;
                             result = (result.push(item), result);
                         }
@@ -6638,15 +6824,15 @@ export class BallEngine {
             do {
                 const __sw = method;
                 if ((__sw === 'union')) {
-                    let otherU = ((arg0 instanceof Set) ? arg0 : ((Array.isArray(arg0) ? arg0.toSet() : new Set(['Object?']))));
+                    let otherU = ((arg0 instanceof Set) ? arg0 : ((Array.isArray(arg0) ? arg0.toSet() : new Set())));
                     return self.union(otherU);
                 }
                 else if ((__sw === 'intersection')) {
-                    let otherI = ((arg0 instanceof Set) ? arg0 : ((Array.isArray(arg0) ? arg0.toSet() : new Set(['Object?']))));
+                    let otherI = ((arg0 instanceof Set) ? arg0 : ((Array.isArray(arg0) ? arg0.toSet() : new Set())));
                     return self.intersection(otherI);
                 }
                 else if ((__sw === 'difference')) {
-                    let otherD = ((arg0 instanceof Set) ? arg0 : ((Array.isArray(arg0) ? arg0.toSet() : new Set(['Object?']))));
+                    let otherD = ((arg0 instanceof Set) ? arg0 : ((Array.isArray(arg0) ? arg0.toSet() : new Set())));
                     return self.difference(otherD);
                 }
                 else if ((__sw === 'add')) {
@@ -6708,7 +6894,7 @@ export class BallEngine {
                 }
                 else if ((__sw === 'where') || (__sw === 'filter')) {
                     if ((typeof arg0 === 'function')) {
-                        let result = new Set(['Object?']);
+                        let result = new Set();
                         for (const item of self) {
                             let r = arg0(item);
                             if ((r != null)) {
@@ -6796,7 +6982,7 @@ export class BallEngine {
                     return await this._ballToStringAsync(self);
                 }
                 else if ((__sw === 'toStringAsFixed')) {
-                    return (+(self)).toFixed(this._toInt(arg0));
+                    return __ball_to_fixed(self, this._toInt(arg0));
                 }
                 else if ((__sw === 'abs')) {
                     return __ball_math_abs(self);
@@ -6825,7 +7011,7 @@ export class BallEngine {
             } while (false);
         }
         let selfMap = this._cfAsMap(self);
-        if ((!__ball_eq(selfMap, null) && ('__type__' in selfMap))) {
+        if ((!__ball_eq(selfMap, null) && ('__type__' in __ball_require_map(selfMap, 'map_contains_key')))) {
             let typeName = __ball_index(selfMap, '__type__');
             if ((!__ball_eq(typeName, null) && (typeName.endsWith(':StringBuffer') || __ball_eq(typeName, 'StringBuffer')))) {
                 do {
@@ -6925,8 +7111,8 @@ export class BallEngine {
         if (__ball_eq(m, null)) {
             return null;
         }
-        let left = __no_init__;
-        let right = __no_init__;
+        let left;
+        let right;
         if (__ball_eq(function_, 'index')) {
             left = __ball_index(m, 'target');
             right = __ball_index(m, 'index');
@@ -6936,7 +7122,7 @@ export class BallEngine {
             right = __ball_index(m, 'right');
         }
         let leftMap = this._stdAsMap(left);
-        if ((__ball_eq(leftMap, null) || !('__type__' in leftMap))) {
+        if ((__ball_eq(leftMap, null) || !('__type__' in __ball_require_map(leftMap, 'map_contains_key')))) {
             return null;
         }
         let typeName = __ball_index(leftMap, '__type__');
@@ -7001,7 +7187,7 @@ export class BallEngine {
         } while (false);
     }
     async _callBaseFunction(module, function_, input) {
-        if ((function_ in _stdFunctionToOperator)) {
+        if ((function_ in __ball_require_map(_stdFunctionToOperator, 'map_contains_key'))) {
             let override = await this._tryOperatorOverride(function_, input);
             if (!__ball_eq(override, null)) {
                 return this._consumeGeneratorFlow(override);
@@ -7133,7 +7319,7 @@ export class BallEngine {
             }), ['unsigned_right_shift']: ((i) => {
                 const input = i;
                 return this._stdBinaryInt(i, ((a, b) => {
-                    return (a >>> b);
+                    return __ball_ushr(a, b);
                 }));
             }), ['pre_increment']: ((i) => {
                 const input = i;
@@ -7175,7 +7361,7 @@ export class BallEngine {
                 const input = i;
                 return this._stdConvert(i, ((v) => {
                     const input = v;
-                    return new BallDouble(__ball_parse_double(v));
+                    return __ball_parse_double(v);
                 }));
             }), ['to_double']: ((i) => {
                 const input = i;
@@ -7206,7 +7392,7 @@ export class BallEngine {
                 let v = (__ball_index(m, 'value') ?? __ball_index(m, 'left'));
                 let digits = (__ball_index(m, 'digits') ?? __ball_index(m, 'fractionDigits'));
                 let n = this._toNum(v);
-                let s = (+(n)).toFixed(this._toInt(digits));
+                let s = __ball_to_fixed(n, this._toInt(digits));
                 if (((__ball_eq(n, 0) && __ball_lt(new BallDouble(Number(new BallDouble(1)) / Number(n)), 0)) && !s.startsWith('-'))) {
                     return ('-' + __ball_to_string(s));
                 }
@@ -7404,7 +7590,7 @@ export class BallEngine {
                 let list = this._stdAsList(__ball_index(m, 'list'));
                 let cb = ((__ball_index(m, 'callback') ?? __ball_index(m, 'function')) ?? __ball_index(m, 'value'));
                 let seeded = false;
-                let acc = __no_init__;
+                let acc;
                 for (const e of list) {
                     if (!seeded) {
                         acc = e;
@@ -7544,19 +7730,19 @@ export class BallEngine {
                 const input = i;
                 let m = this._stdAsMap(i);
                 let list = this._stdAsList(__ball_index(m, 'list'));
-                let s = __no_init__;
-                let e = __no_init__;
-                if (('start' in m)) {
+                let s;
+                let e;
+                if (('start' in __ball_require_map(m, 'map_contains_key'))) {
                     s = this._toInt(__ball_index(m, 'start'));
                     e = (!__ball_eq(__ball_index(m, 'end'), null) ? this._toInt(__ball_index(m, 'end')) : null);
                 }
                 else {
-                    if ((('arg0' in m) && ('arg1' in m))) {
+                    if ((('arg0' in __ball_require_map(m, 'map_contains_key')) && ('arg1' in __ball_require_map(m, 'map_contains_key')))) {
                         s = this._toInt(__ball_index(m, 'arg0'));
                         e = this._toInt(__ball_index(m, 'arg1'));
                     }
                     else {
-                        if (('value' in m)) {
+                        if (('value' in __ball_require_map(m, 'map_contains_key'))) {
                             let v = __ball_index(m, 'value');
                             if ((Array.isArray(v) && __ball_ge(v.length, 2))) {
                                 s = this._toInt(__ball_index(v, 0));
@@ -7764,13 +7950,13 @@ export class BallEngine {
                 let m = this._stdAsMap(i);
                 let raw = __ball_index(m, 'map');
                 let map = (false /* BallMap is Map in TS */ ? raw.entries : (((typeof raw === 'object' && raw !== null && !Array.isArray(raw) && !(raw instanceof BallDouble) && !(raw instanceof Set)) ? raw : {})));
-                return Object.values(map).includes(__ball_index(m, 'value'));
+                return Object.values(__ball_require_map(map, 'map_contains_value')).includes(__ball_index(m, 'value'));
             }), ['map_put_if_absent']: ((i) => {
                 const input = i;
                 let m = this._stdAsMap(i);
                 let map = (this._stdAsMap(__ball_index(m, 'map')) ?? __ball_index(m, 'map'));
                 let key = __ball_index(m, 'key');
-                if (!(key in map)) {
+                if (!(key in __ball_require_map(map, 'map_contains_key'))) {
                     this._trackMemoryAllocation(_ballMapEntryBytes);
                     let val = __ball_index(m, 'value');
                     map[key] = ((typeof val === 'function') ? val() : val);
@@ -7976,7 +8162,7 @@ export class BallEngine {
                 let valMap = this._stdAsMap(val);
                 if (!__ball_eq(valMap, null)) {
                     typeName = ((__ball_index(valMap, '__type__') ?? __ball_index(valMap, '__type')) ?? 'Exception');
-                    if ((!('message' in valMap) && ('arg0' in valMap))) {
+                    if ((!('message' in __ball_require_map(valMap, 'map_contains_key')) && ('arg0' in __ball_require_map(valMap, 'map_contains_key')))) {
                         valMap['message'] = __ball_index(valMap, 'arg0');
                     }
                 }
@@ -8575,7 +8761,7 @@ export class BallEngine {
     }
     async _stdPrint(input) {
         let m = this._stdAsMap(input);
-        if ((!__ball_eq(m, null) && ((('message' in m) || ('arg0' in m)) || ('value' in m)))) {
+        if ((!__ball_eq(m, null) && ((('message' in __ball_require_map(m, 'map_contains_key')) || ('arg0' in __ball_require_map(m, 'map_contains_key'))) || ('value' in __ball_require_map(m, 'map_contains_key'))))) {
             let message = ((__ball_index(m, 'message') ?? __ball_index(m, 'arg0')) ?? __ball_index(m, 'value'));
             this.stdout(await this._ballToStringAsync(message));
             return null;
@@ -8667,7 +8853,7 @@ export class BallEngine {
                     }
                     return (typeName.includes(':') ? typeName.substring(__ball_add(typeName.lastIndexOf(':'), 1)) : typeName);
                 }
-                if (('__tostring_guard__' in map)) {
+                if (('__tostring_guard__' in __ball_require_map(map, 'map_contains_key'))) {
                     let shortType = (typeName.includes(':') ? typeName.substring(__ball_add(typeName.lastIndexOf(':'), 1)) : typeName);
                     return (__ball_to_string(shortType) + '{...}');
                 }
@@ -8805,7 +8991,7 @@ export class BallEngine {
             __cascade_self__.remove('__type__');
             return __cascade_self__;
         })();
-        let result = __no_init__;
+        let result;
         if (__ball_eq(args.length, 1)) {
             result = Function.apply(callee, [args.values.first]);
         }
@@ -9092,7 +9278,7 @@ export class BallEngine {
         if (__ball_eq(cases, null)) {
             return null;
         }
-        let defaultBody = __no_init__;
+        let defaultBody;
         for (const c of cases) {
             let cMap = this._stdAsMap(c);
             if (__ball_eq(cMap, null)) {
@@ -9278,7 +9464,7 @@ export class BallEngine {
                         return false;
                     }
                     let key = __ball_index(entryMap, 'key');
-                    if (!(key in rawMap)) {
+                    if (!(key in __ball_require_map(rawMap, 'map_contains_key'))) {
                         return false;
                     }
                     if (!this._matchPattern(__ball_index(rawMap, key), __ball_index(entryMap, 'value'), bindings)) {
@@ -9318,7 +9504,7 @@ export class BallEngine {
                     return false;
                 }
                 for (const entry of recFields.entries) {
-                    if (!(entry.key in recMap)) {
+                    if (!(entry.key in __ball_require_map(recMap, 'map_contains_key'))) {
                         return false;
                     }
                     let fieldVal = __ball_index(recMap, entry.key);
@@ -9478,7 +9664,7 @@ export class BallEngine {
         let map = this._stdAsMap(v);
         if (!__ball_eq(map, null)) {
             let typeName = __ball_index(map, '__type__');
-            if ((!__ball_eq(typeName, null) && (typeName in this._enumValues))) {
+            if ((!__ball_eq(typeName, null) && (typeName in __ball_require_map(this._enumValues, 'map_contains_key')))) {
                 let shortType = (typeName.includes(':') ? typeName.substring(__ball_add(typeName.lastIndexOf(':'), 1)) : typeName);
                 let valName = __ball_index(map, 'name');
                 if (!__ball_eq(valName, null)) {
@@ -9897,9 +10083,9 @@ export class BallEngine {
             throw new BallRuntimeError('Expected message');
         }
         let rawValue = __ball_index(m, 'value');
-        let value = __no_init__;
-        let min = __no_init__;
-        let max = __no_init__;
+        let value;
+        let min;
+        let max;
         if ((__ball_is_type(rawValue, "Map<String, Object?>") || false /* BallMap is Map in TS */)) {
             value = this._toNum(__ball_index(m, 'min'));
             min = this._toNum(__ball_index(m, 'max'));
@@ -10072,7 +10258,7 @@ export class _Scope {
     }
     lookup(name) {
         const input = name;
-        if ((name in this._bindings)) {
+        if ((name in __ball_require_map(this._bindings, 'map_contains_key'))) {
             return __ball_index(this._bindings, name);
         }
         if (!__ball_eq(this._parent, null)) {
@@ -10085,13 +10271,13 @@ export class _Scope {
     }
     has(name) {
         const input = name;
-        if ((name in this._bindings)) {
+        if ((name in __ball_require_map(this._bindings, 'map_contains_key'))) {
             return true;
         }
         return ((__ball_eq(this._parent, null) ? null : this._parent.has(name)) ?? false);
     }
     set(name, value) {
-        if ((name in this._bindings)) {
+        if ((name in __ball_require_map(this._bindings, 'map_contains_key'))) {
             this._bindings[name] = value;
             return;
         }
@@ -10190,7 +10376,7 @@ export class StdModuleHandler extends BallModuleHandler {
             if (this._tombstones.includes(entry.key)) {
                 continue;
             }
-            if ((entry.key in this._composedDispatch)) {
+            if ((entry.key in __ball_require_map(this._composedDispatch, 'map_contains_key'))) {
                 continue;
             }
             if ((!__ball_eq(allowlist, null) && !allowlist.includes(entry.key))) {
@@ -10293,7 +10479,7 @@ function _ballToDouble(value) {
 }
 function _ballValueIsSet(v) {
     const input = v;
-    return ((typeof v === 'object' && v !== null && !Array.isArray(v) && !(v instanceof BallDouble) && !(v instanceof Set)) && (_kBallSetTag in v));
+    return ((typeof v === 'object' && v !== null && !Array.isArray(v) && !(v instanceof BallDouble) && !(v instanceof Set)) && (_kBallSetTag in __ball_require_map(v, 'map_contains_key')));
 }
 function _ballIsInt(v) {
     const input = v;
@@ -10357,7 +10543,7 @@ function _ballMapValuesDyn(map) {
 function _ballMapContainsKeyDyn(map, key) {
     let handle = _ballMapHandleEntries(map);
     if ((typeof handle === 'object' && handle !== null && !Array.isArray(handle) && !(handle instanceof BallDouble) && !(handle instanceof Set))) {
-        return (key in handle);
+        return (key in __ball_require_map(handle, 'map_contains_key'));
     }
     return false;
 }
@@ -10373,12 +10559,12 @@ function ballObjectSetField(target, fieldName, val) {
         return;
     }
     if (false /* BallMap is Map in TS */) {
-        if (('__type__' in target.entries)) {
+        if (('__type__' in __ball_require_map(target.entries, 'map_contains_key'))) {
             target[fieldName] = val;
         }
         return;
     }
-    if ((__ball_is_type(target, "Map<String, Object?>") && ('__type__' in target))) {
+    if ((__ball_is_type(target, "Map<String, Object?>") && ('__type__' in __ball_require_map(target, 'map_contains_key')))) {
         target[fieldName] = val;
     }
 }
@@ -10471,7 +10657,7 @@ function _unwrapBallFuture(value) {
     const input = value;
     if (_isBallFuture(value)) {
         let map = value;
-        if (('error' in map)) {
+        if (('error' in __ball_require_map(map, 'map_contains_key'))) {
             let error = __ball_index(map, 'error');
             if ((error instanceof BallException)) {
                 throw error;