@ball-lang/cli 1.23.0 → 1.25.0

package/dist/compiled_cli.js

@@ -0,0 +1,1938 @@
+// @ts-nocheck — auto-generated
+// ── Ball runtime preamble (generated by @ball-lang/compiler) ────────
+// Base class for all Ball runtime values.
+export class BallValue {
+}
+// A cast pattern (value as T) ASSERTS the runtime type — it throws on a type
+// mismatch (Dart semantics), it does NOT refute / fall through. Conjoined into a
+// switch-case condition by the compiler; returns true when the type check passed,
+// else throws a catchable error. (conformance 302_cast_patterns)
+export function ball_cast_assert(ok, t) {
+    if (!ok)
+        throw new Error('TypeError: type cast failed: not a ' + t);
+    return true;
+}
+// ── Ball container runtime types ────────────────────────────────────
+//
+// The self-hosted engine IR models class instances as 'BallObject extends
+// BallMap'. The compiler treats maps/lists transparently (a Ball map is a
+// plain JS object, a Ball list a plain JS array) and _asMap() returns an
+// instance verbatim, reading its data through bracket access (obj of f)
+// and the Object.prototype .entries / .keys / .length getters. To stay
+// compatible we make BallObject a plain-object-like instance: the field data
+// lives as OWN ENUMERABLE properties (so bracket access and .entries see it),
+// while the class bookkeeping (typeName/fields/methods/superObject) is stored
+// non-enumerably so it never leaks into .entries / .keys / .length.
+//
+// BallMap / BallList exist only so 'extends BallMap' resolves and any stray
+// new BallMap(...) / new BallList(...) behaves like the transparent value.
+export class BallMap extends BallValue {
+    constructor(entries) {
+        super();
+        if (entries && typeof entries === 'object') {
+            if (entries instanceof Map) {
+                for (const [k, v] of entries)
+                    this[k] = v;
+            }
+            else {
+                for (const k of Object.keys(entries))
+                    this[k] = entries[k];
+            }
+        }
+    }
+}
+export class BallList extends Array {
+    constructor(items) {
+        super();
+        if (Array.isArray(items))
+            for (const it of items)
+                this.push(it);
+    }
+}
+export class BallObject extends BallMap {
+    constructor(arg0, superObject, fields, methods) {
+        super();
+        // Accept either the named-args object the encoder emits
+        // (new BallObject({typeName, superObject, fields, methods})) or the
+        // positional form, so the class works regardless of how it is invoked.
+        let typeName = arg0;
+        if (arg0 && typeof arg0 === 'object' && !Array.isArray(arg0) &&
+            ('typeName' in arg0 || 'fields' in arg0 || 'methods' in arg0 ||
+                'superObject' in arg0)) {
+            typeName = arg0.typeName;
+            superObject = arg0.superObject;
+            fields = arg0.fields;
+            methods = arg0.methods;
+        }
+        const fieldMap = (fields && typeof fields === 'object') ? fields : {};
+        const methodMap = (methods && typeof methods === 'object') ? methods : {};
+        // Field data → own enumerable properties (visible to bracket access and
+        // the Object.prototype map getters).
+        for (const k of Object.keys(fieldMap))
+            this[k] = fieldMap[k];
+        // Class bookkeeping → own props the engine reads/writes by bracket name.
+        this['__type__'] = typeName ?? '';
+        this['__super__'] = superObject ?? null;
+        this['__fields__'] = fieldMap;
+        this['__methods__'] = methodMap;
+        // Mirror the Dart class fields too, but non-enumerably so they never show
+        // up as Ball fields in .entries / .keys / .length.
+        for (const [name, value] of [
+            ['typeName', typeName ?? ''], ['superObject', superObject ?? null],
+            ['fields', fieldMap], ['methods', methodMap],
+        ]) {
+            Object.defineProperty(this, name, {
+                value, writable: true, configurable: true, enumerable: false,
+            });
+        }
+    }
+    setField(name, value) {
+        this.fields[name] = value;
+        this[name] = value;
+    }
+}
+globalThis.BallMap = BallMap;
+globalThis.BallList = BallList;
+globalThis.BallObject = BallObject;
+// BallDouble wrapper — tracks that a number should print as a double
+// (e.g. 42.0 not 42). Used by the compiled Dart engine's _toDouble.
+export class BallDouble {
+    value;
+    // 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))
+            return v.toString();
+        if (v === 0 && 1 / v === -Infinity)
+            return '-0.0';
+        if (Number.isInteger(v))
+            return v.toFixed(1);
+        return v.toString();
+    }
+    // Arithmetic: unwrap for operations
+    [Symbol.toPrimitive](hint) {
+        if (hint === 'string')
+            return this.toString();
+        return this.value;
+    }
+}
+globalThis.BallDouble = BallDouble;
+// Arithmetic helpers that propagate BallDouble through operations.
+// If either operand is BallDouble, the result is BallDouble (preserving .0).
+//
+// Operator-overload dispatch checks for __op_X__ methods (TRAILING double
+// underscore) — this MUST match the Dart encoder's canonical operator naming
+// (_canonicalOperatorName in dart/encoder/lib/encoder.dart), which always
+// emits a trailing __. A single-underscore lookup (__op_mul) never matches,
+// so overloaded operators silently fall through to raw JS arithmetic (#205).
+export function __ball_mul(a, b) {
+    if (a != null && typeof a === 'object' && typeof a.__op_mul__ === 'function')
+        return a.__op_mul__(b);
+    if (typeof a === 'bigint' || typeof b === 'bigint')
+        return __i64_wrap(__to_bigint(a) * __to_bigint(b));
+    const av = a instanceof BallDouble ? a.value : a;
+    const bv = b instanceof BallDouble ? b.value : b;
+    const r = av * bv;
+    return (a instanceof BallDouble || b instanceof BallDouble) ? new BallDouble(r) : r;
+}
+export function __ball_add(a, b) {
+    if (a != null && typeof a === 'object' && typeof a.__op_add__ === 'function')
+        return a.__op_add__(b);
+    if (typeof a === 'bigint' || typeof b === 'bigint')
+        return __i64_wrap(__to_bigint(a) + __to_bigint(b));
+    const av = a instanceof BallDouble ? a.value : a;
+    const bv = b instanceof BallDouble ? b.value : b;
+    const r = av + bv;
+    return (a instanceof BallDouble || b instanceof BallDouble) ? new BallDouble(r) : r;
+}
+export function __ball_sub(a, b) {
+    if (a != null && typeof a === 'object' && typeof a.__op_sub__ === 'function')
+        return a.__op_sub__(b);
+    if (typeof a === 'bigint' || typeof b === 'bigint')
+        return __i64_wrap(__to_bigint(a) - __to_bigint(b));
+    const av = a instanceof BallDouble ? a.value : a;
+    const bv = b instanceof BallDouble ? b.value : b;
+    const r = av - bv;
+    return (a instanceof BallDouble || b instanceof BallDouble) ? new BallDouble(r) : r;
+}
+// Dart equality: NaN != NaN, BallDouble value comparison, null == undefined.
+export function __ball_eq(a, b) {
+    if (a != null && typeof a === 'object' && typeof a.__op_eq__ === 'function')
+        return a.__op_eq__(b);
+    if (typeof a === 'bigint' || typeof b === 'bigint') {
+        if (typeof a === 'bigint' && typeof b === 'bigint')
+            return a === b;
+        if (typeof a === 'bigint' && typeof b === 'number')
+            return a === BigInt(b);
+        if (typeof a === 'number' && typeof b === 'bigint')
+            return BigInt(a) === b;
+        return false;
+    }
+    if (a instanceof BallDouble || b instanceof BallDouble) {
+        const av = a instanceof BallDouble ? a.value : a;
+        const bv = b instanceof BallDouble ? b.value : b;
+        if (Number.isNaN(av) || Number.isNaN(bv))
+            return false;
+        return av === bv;
+    }
+    if (a == null && b == null)
+        return true;
+    if (a == null || b == null)
+        return a == b;
+    return a === b;
+}
+// Relational operator-overload dispatch (less-than/greater-than/etc.),
+// matching the __op_add__-style convention above. Unlike arithmetic,
+// relational comparisons had NO overload attempt at all before #205 — every
+// overloaded Vec2 < x etc. compiled straight to raw JS comparison.
+export function __ball_lt(a, b) {
+    if (a != null && typeof a === 'object' && typeof a.__op_lt__ === 'function')
+        return a.__op_lt__(b);
+    if (typeof a === 'bigint' || typeof b === 'bigint')
+        return __to_bigint(a) < __to_bigint(b);
+    const av = a instanceof BallDouble ? a.value : a;
+    const bv = b instanceof BallDouble ? b.value : b;
+    return av < bv;
+}
+export function __ball_gt(a, b) {
+    if (a != null && typeof a === 'object' && typeof a.__op_gt__ === 'function')
+        return a.__op_gt__(b);
+    if (typeof a === 'bigint' || typeof b === 'bigint')
+        return __to_bigint(a) > __to_bigint(b);
+    const av = a instanceof BallDouble ? a.value : a;
+    const bv = b instanceof BallDouble ? b.value : b;
+    return av > bv;
+}
+export function __ball_le(a, b) {
+    if (a != null && typeof a === 'object' && typeof a.__op_le__ === 'function')
+        return a.__op_le__(b);
+    if (typeof a === 'bigint' || typeof b === 'bigint')
+        return __to_bigint(a) <= __to_bigint(b);
+    const av = a instanceof BallDouble ? a.value : a;
+    const bv = b instanceof BallDouble ? b.value : b;
+    return av <= bv;
+}
+export function __ball_ge(a, b) {
+    if (a != null && typeof a === 'object' && typeof a.__op_ge__ === 'function')
+        return a.__op_ge__(b);
+    if (typeof a === 'bigint' || typeof b === 'bigint')
+        return __to_bigint(a) >= __to_bigint(b);
+    const av = a instanceof BallDouble ? a.value : a;
+    const bv = b instanceof BallDouble ? b.value : b;
+    return av >= bv;
+}
+export function __ball_to_string(v) {
+    if (v === null || v === undefined)
+        return 'null';
+    if (typeof v === 'bigint')
+        return v.toString();
+    if (typeof v === 'boolean')
+        return v ? 'true' : 'false';
+    if (v instanceof BallDouble)
+        return v.toString();
+    if (typeof v === 'number') {
+        if (!isFinite(v) || Number.isNaN(v))
+            return v.toString();
+        if (v === 0 && 1 / v === -Infinity)
+            return '-0.0';
+        if (Number.isInteger(v))
+            return v.toString();
+        const s = v.toString();
+        return s.includes('.') || s.includes('e') ? s : s + '.0';
+    }
+    if (typeof v === 'string')
+        return v;
+    if (Array.isArray(v)) {
+        return '[' + v.map(__ball_to_string).join(', ') + ']';
+    }
+    if (v instanceof Map) {
+        const parts = [];
+        // 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__'])) {
+            return v['__buffer__'].join('');
+        }
+        // Check for custom toString method on the instance (not Object.prototype).
+        if (v.toString !== Object.prototype.toString && typeof v.toString === 'function') {
+            return v.toString();
+        }
+        // Dart Map-like object: format as {key: value, ...}
+        const keys = Object.keys(v).filter((k) => !k.startsWith('__'));
+        if (keys.length > 0) {
+            return '{' + keys.map((k) => __ball_to_string(k) + ': ' + __ball_to_string(v[k])).join(', ') + '}';
+        }
+        return '{}';
+    }
+    return String(v);
+}
+export function __ball_parse_int(s) {
+    const trimmed = s.trim();
+    if (!/^-?\d+$/.test(trimmed)) {
+        throw new Error('FormatException: ' + s);
+    }
+    return parseInt(trimmed, 10);
+}
+// Dart-style int conversion that preserves int64 precision. JS numbers lose
+// precision above 2^53, so integer literals encoded as decimal strings (the
+// JSON proto3 representation of int64) would round. When the string magnitude
+// exceeds Number.MAX_SAFE_INTEGER we return a BigInt to keep the exact value;
+// otherwise we keep a plain number so the common arithmetic path is unchanged.
+export function __ball_to_int(v) {
+    if (typeof v === 'bigint')
+        return v;
+    if (typeof v === 'string') {
+        if (/^-?\d+$/.test(v)) {
+            const b = BigInt(v);
+            if (b > 9007199254740991n || b < -9007199254740991n)
+                return b;
+            return Number(b);
+        }
+        return Math.trunc(Number(v)) || 0;
+    }
+    const n = (v instanceof BallDouble) ? v.value : v;
+    const t = Math.trunc(n) || 0;
+    if (t >= 9223372036854775808)
+        return __I64_MAX;
+    if (t <= -9223372036854775808)
+        return __I64_MIN;
+    if (t > 9007199254740991 || t < -9007199254740991) {
+        try {
+            return __i64_wrap(BigInt(Math.round(t)));
+        }
+        catch { }
+    }
+    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).
+export function __ball_parse_double(s) {
+    const n = parseFloat(s);
+    if (Number.isNaN(n))
+        throw new Error('FormatException: ' + s);
+    return new BallDouble(n);
+}
+export 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.
+export 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
+// (Ball maps) merge by key with the right side winning (so child class
+// methods override parent methods).
+export function __ball_concat(a, b) {
+    const aIsArr = Array.isArray(a);
+    const bIsArr = Array.isArray(b);
+    if (aIsArr || bIsArr) {
+        const al = aIsArr ? a : (a == null ? [] : [a]);
+        const bl = bIsArr ? b : (b == null ? [] : [b]);
+        return [...al, ...bl];
+    }
+    if ((a && typeof a === 'object') || (b && typeof b === 'object')) {
+        return Object.assign({}, a ?? {}, b ?? {});
+    }
+    return [a, b];
+}
+// In-place collection append: mutates target by appending all elements.
+// For arrays: pushes elements (Dart List.addAll semantics).
+// For objects: merges keys (Dart Map.addAll semantics).
+// Preserves reference identity so callers sharing the same collection see changes.
+export function __ball_push_all(target, items) {
+    if (Array.isArray(target)) {
+        if (Array.isArray(items)) {
+            for (let i = 0; i < items.length; i++)
+                target.push(items[i]);
+        }
+        else if (items != null) {
+            target.push(items);
+        }
+    }
+    else if (target && typeof target === 'object') {
+        if (items && typeof items === 'object' && !Array.isArray(items)) {
+            for (const k of Object.keys(items))
+                target[k] = items[k];
+        }
+    }
+}
+// ── BigInt / signed-64-bit integer support ──────────────────────
+// Dart int is signed 64-bit; JS Number loses precision above 2^53.
+// Arithmetic on BigInt values wraps to the signed 64-bit range and
+// demotes back to Number when the result fits in MAX_SAFE_INTEGER.
+export const __I64_MAX = 9223372036854775807n;
+export const __I64_MIN = -9223372036854775808n;
+export function __i64_wrap(v) {
+    // 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;
+}
+export 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);
+}
+// 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.
+export function __fits32(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v >= -2147483648 && v <= 2147483647;
+}
+export function __ball_bitand(a, b) {
+    if (__fits32(a) && __fits32(b))
+        return a & b;
+    return __i64_wrap(__to_bigint(a) & __to_bigint(b));
+}
+export function __ball_bitor(a, b) {
+    if (__fits32(a) && __fits32(b))
+        return a | b;
+    return __i64_wrap(__to_bigint(a) | __to_bigint(b));
+}
+export function __ball_bitxor(a, b) {
+    if (__fits32(a) && __fits32(b))
+        return a ^ b;
+    return __i64_wrap(__to_bigint(a) ^ __to_bigint(b));
+}
+export function __ball_bitnot(a) {
+    if (__fits32(a))
+        return ~a;
+    return __i64_wrap(~__to_bigint(a));
+}
+export function __ball_shl(a, b) { return __i64_wrap(__to_bigint(a) << __to_bigint(b)); }
+export 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.
+export 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());
+};
+export function __ball_negate(a) {
+    if (typeof a === 'bigint')
+        return __i64_wrap(-a);
+    if (a instanceof BallDouble)
+        return new BallDouble(-a.value);
+    return -a;
+}
+export function __ball_divide(a, b) {
+    if (typeof a === 'bigint' || typeof b === 'bigint') {
+        const ba = __to_bigint(a), bb = __to_bigint(b);
+        const r = ba / bb;
+        return __i64_wrap(r);
+    }
+    return Math.trunc(a / b);
+}
+export function __ball_math_abs(a) {
+    if (typeof a === 'bigint') {
+        const neg = -a;
+        return __i64_wrap(neg < 0n ? a : neg);
+    }
+    return Math.abs(a);
+}
+// Greatest common divisor (Dart's int.gcd). Preserves BigInt (i64) inputs so
+// integer identities round-trip; falls back to Number arithmetic otherwise.
+export function __ball_math_gcd(a, b) {
+    if (typeof a === 'bigint' || typeof b === 'bigint') {
+        let x = __to_bigint(a);
+        x = x < 0n ? -x : x;
+        let y = __to_bigint(b);
+        y = y < 0n ? -y : y;
+        while (y) {
+            const t = y;
+            y = x % y;
+            x = t;
+        }
+        return __i64_wrap(x);
+    }
+    let x = Math.abs(Number(a)), y = Math.abs(Number(b));
+    while (y) {
+        const t = y;
+        y = x % y;
+        x = t;
+    }
+    return x;
+}
+// Least common multiple, derived from gcd. lcm(0, n) == lcm(n, 0) == 0.
+export function __ball_math_lcm(a, b) {
+    if (typeof a === 'bigint' || typeof b === 'bigint') {
+        const x = __to_bigint(a), y = __to_bigint(b);
+        if (x === 0n || y === 0n)
+            return __i64_wrap(0n);
+        const g = __to_bigint(__ball_math_gcd(x, y));
+        const r = (x / g) * y;
+        return __i64_wrap(r < 0n ? -r : r);
+    }
+    const x = Number(a), y = Number(b);
+    if (x === 0 || y === 0)
+        return 0;
+    const g = Number(__ball_math_gcd(x, y));
+    return Math.abs((x / g) * y);
+}
+// Dart-style Euclidean modulo: result is always non-negative.
+// JS % is remainder (can be negative), Dart % is Euclidean modulo.
+export function __dart_mod(a, b) {
+    if (typeof a === 'bigint' || typeof b === 'bigint') {
+        const ba = __to_bigint(a), bb = __to_bigint(b);
+        const r = ba % bb;
+        return __i64_wrap(r < 0n ? r + (bb < 0n ? -bb : bb) : r);
+    }
+    const r = a % b;
+    return r < 0 ? r + (b < 0 ? -b : b) : r;
+}
+// Active exception for rethrow. Catch bodies shadow with a local.
+export let __ball_active_error = 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
+// (array) access here and throw a RangeError-shaped exception. Maps, strings
+// and objects keep their JS semantics (no throw) — Dart Map '[]' returns null
+// for absent keys, and String '[]' is handled by callers.
+export function __ball_index(target, idx) {
+    if (Array.isArray(target) && typeof idx === 'number' && Number.isInteger(idx)) {
+        if (idx < 0 || idx >= target.length) {
+            throw {
+                __type__: 'RangeError',
+                message: 'RangeError (index): Invalid value: ' +
+                    (target.length === 0
+                        ? 'Valid value range is empty: ' + idx
+                        : 'Not in inclusive range 0..' + (target.length - 1) + ': ' + idx),
+                index: idx,
+            };
+        }
+        return target[idx];
+    }
+    return target[idx];
+}
+// Dart type shims — provide static methods for Dart built-in types
+// that don't exist in JS (int, double, num, bool).
+export const int = {
+    parse: (s) => { const n = parseInt(String(s), 10); if (isNaN(n))
+        throw new Error('FormatException: ' + s); return n; },
+    tryParse: (s) => { const n = parseInt(String(s), 10); return isNaN(n) ? null : n; },
+};
+export const double = {
+    parse: (s) => { const n = parseFloat(String(s)); if (isNaN(n))
+        throw new Error('FormatException: ' + s); return n; },
+    tryParse: (s) => { const n = parseFloat(String(s)); return isNaN(n) ? null : n; },
+    infinity: Infinity,
+    nan: NaN,
+    negativeInfinity: -Infinity,
+};
+export const num = {
+    parse: (s) => { const n = Number(s); if (isNaN(n))
+        throw new Error('FormatException: ' + s); return n; },
+    tryParse: (s) => { const n = Number(s); return isNaN(n) ? null : n; },
+};
+export const bool = {
+    parse: (s) => { if (s === 'true')
+        return true; if (s === 'false')
+        return false; throw new Error('FormatException: ' + s); },
+    tryParse: (s) => { if (s === 'true')
+        return true; if (s === 'false')
+        return false; return null; },
+};
+// Sentinel for "not yet initialized" — used by the Dart engine for
+// late-initialized variables and block-scoped flow tracking.
+export const __no_init__ = Symbol('__no_init__');
+// Null-aware spread source normalizer (the ...? operator). Returns an
+// iterable for the spread loop, mapping null / undefined / the __no_init__
+// sentinel (an uninitialized nullable, e.g. List<int>? n;) to an empty list
+// — matching Dart's ...?n which contributes nothing when the operand is null.
+export function __ball_spread_iter(v) {
+    if (v == null || v === __no_init__)
+        return [];
+    return v;
+}
+// Dart type constructor shims — List, Map, etc.
+export const List = {
+    filled: (count, value) => Array(count).fill(value),
+    generate: (count, generator) => {
+        const r = [];
+        for (let i = 0; i < count; i++)
+            r.push(generator(i));
+        return r;
+    },
+    from: (iter) => Array.isArray(iter) ? [...iter] : [...iter],
+    of: (iter) => Array.isArray(iter) ? [...iter] : [...iter],
+    unmodifiable: (iter) => Object.freeze(Array.isArray(iter) ? [...iter] : [...iter]),
+    empty: (opts) => [],
+    castFrom: (source) => Array.isArray(source) ? [...source] : [],
+};
+// Set.unmodifiable
+export const _nativeSet = Set;
+Set.unmodifiable = (iter) => {
+    const s = new _nativeSet(iter);
+    return Object.freeze(s);
+};
+Set.from = (iter) => new _nativeSet(iter);
+Set.of = (iter) => new _nativeSet(iter);
+// Ball encoder sometimes uses set_create for lists, then list_push on them.
+// Bridge the gap with push/indexOf/length on Set.
+if (!Set.prototype.push)
+    Set.prototype.push = function (v) { this.add(v); return this.size; };
+Object.defineProperty(Set.prototype, 'length', { configurable: true, get() { return this.size; } });
+Object.defineProperty(Set.prototype, 'isEmpty', { configurable: true, get() { return this.size === 0; } });
+Object.defineProperty(Set.prototype, 'isNotEmpty', { configurable: true, get() { return this.size !== 0; } });
+// Patch: scope _bindings must use null-prototype objects to avoid
+// Object.prototype getters (entries, keys, values, length) polluting
+// the "in" operator used by scope.lookup/has/set.
+export const _origScopeInit = { patched: false };
+export function _patchScopeBindings(scope) {
+    if (!scope || _origScopeInit.patched)
+        return;
+    const ScopeClass = scope.constructor;
+    if (!ScopeClass)
+        return;
+    const origCtor = ScopeClass;
+    const origBind = ScopeClass.prototype.bind;
+    // Override bind to lazily convert _bindings to null-proto object
+    ScopeClass.prototype.bind = function (name, value) {
+        if (Object.getPrototypeOf(this._bindings) !== null) {
+            const entries = Object.entries(this._bindings);
+            this._bindings = Object.create(null);
+            for (const [k, v] of entries)
+                this._bindings[k] = v;
+        }
+        return (this._bindings[name] = value);
+    };
+    // Also patch child() to create null-proto bindings
+    const origChild = ScopeClass.prototype.child;
+    if (origChild) {
+        ScopeClass.prototype.child = function () {
+            const c = origChild.call(this);
+            if (Object.getPrototypeOf(c._bindings) !== null) {
+                c._bindings = Object.create(null);
+            }
+            return c;
+        };
+    }
+    _origScopeInit.patched = true;
+}
+// Proto has* functions as global helpers (encoder routes method calls through ball_proto)
+// Generic has* helper — returns true if obj[field] is present and non-null
+export function _has(obj, field) { return obj?.[field] !== undefined && obj?.[field] !== null; }
+export function hasMetadata(obj) { return _has(obj, 'metadata'); }
+export function hasBody(obj) { return _has(obj, 'body'); }
+export function hasInput(obj) { return _has(obj, 'input'); }
+export function hasDescriptor(obj) { return _has(obj, 'descriptor'); }
+// ModuleImport.source oneof (issue #364 — cli_core.dart's _importSource
+// reads these via hasHttp()/hasFile()/hasGit()/hasRegistry()/hasInline()
+// instead of whichSource(), since the self-hosted engine represents proto
+// oneof-case enums as maps and can't self-host a whichSource() ==
+// ModuleImport_Source.x comparison — see cli_core.dart's _importSource doc).
+export function hasHttp(obj) { return _has(obj, 'http'); }
+export function hasFile(obj) { return _has(obj, 'file'); }
+export function hasGit(obj) { return _has(obj, 'git'); }
+export function hasRegistry(obj) { return _has(obj, 'registry'); }
+export function hasInline(obj) { return _has(obj, 'inline'); }
+export function hasStringValue(obj) { return _has(obj, 'stringValue'); }
+export function hasBoolValue(obj) { return _has(obj, 'boolValue'); }
+export function hasNumberValue(obj) { return _has(obj, 'numberValue'); }
+export function hasResult(obj) { return _has(obj, 'result'); }
+export function hasCall(obj) { return _has(obj, 'call'); }
+export function hasListValue(obj) { return _has(obj, 'listValue'); }
+export function hasNullValue(obj) { return _has(obj, 'nullValue'); }
+export function hasStructValue(obj) { return _has(obj, 'structValue'); }
+export function hasMatch(obj) { return _has(obj, 'match'); }
+export function hasXxx(obj) { return false; }
+export function whichXxx(obj) { return 'notSet'; }
+// whichExpr/whichValue/whichStmt/whichKind sit on the hottest path of the
+// compiled engine (whichExpr alone runs up to 8x per _evalExpression). The
+// previous 'typeof obj.whichXxx === "function"' probe always walked the
+// prototype chain to the Object.prototype shim installed by installProtoShims
+// (true for EVERY plain object) and then *invoked* it — a prototype walk + a
+// megamorphic keyed-load loop per call, even though the compiled engine's AST
+// nodes never carry an own whichXxx. We gate the method probe behind an
+// own-property check (so plain nodes skip the prototype walk entirely and use
+// the inline discriminator) while still honoring hand-rolled wrapper objects —
+// notably the metadata wrapValue Value wrappers, whose own getters
+// (.stringValue etc.) are always-defined, so their own whichXxx() must win
+// over the inline field probes. Hence the own-method check stays FIRST.
+export function whichExpr(obj) {
+    if (!obj)
+        return 'notSet';
+    if (Object.prototype.hasOwnProperty.call(obj, 'whichExpr') && typeof obj.whichExpr === 'function')
+        return obj.whichExpr();
+    if (obj.call)
+        return 'call';
+    if (obj.literal)
+        return 'literal';
+    if (obj.reference)
+        return 'reference';
+    if (obj.fieldAccess)
+        return 'fieldAccess';
+    if (obj.messageCreation)
+        return 'messageCreation';
+    if (obj.block)
+        return 'block';
+    if (obj.lambda)
+        return 'lambda';
+    return 'notSet';
+}
+export function whichValue(obj) {
+    if (!obj)
+        return 'notSet';
+    if (Object.prototype.hasOwnProperty.call(obj, 'whichValue') && typeof obj.whichValue === 'function')
+        return obj.whichValue();
+    if (obj.intValue !== undefined)
+        return 'intValue';
+    if (obj.doubleValue !== undefined)
+        return 'doubleValue';
+    if (obj.stringValue !== undefined)
+        return 'stringValue';
+    if (obj.boolValue !== undefined)
+        return 'boolValue';
+    if (obj.listValue)
+        return 'listValue';
+    if (obj.bytesValue !== undefined)
+        return 'bytesValue';
+    return 'notSet';
+}
+export function whichStmt(obj) {
+    if (!obj)
+        return 'notSet';
+    if (Object.prototype.hasOwnProperty.call(obj, 'whichStmt') && typeof obj.whichStmt === 'function')
+        return obj.whichStmt();
+    if (obj.let)
+        return 'let';
+    if (obj.expression)
+        return 'expression';
+    return 'notSet';
+}
+export function whichKind(obj) {
+    if (!obj)
+        return 'notSet';
+    if (Object.prototype.hasOwnProperty.call(obj, 'whichKind') && typeof obj.whichKind === 'function')
+        return obj.whichKind();
+    if (obj.nullValue !== undefined)
+        return 'nullValue';
+    if (obj.numberValue !== undefined)
+        return 'numberValue';
+    if (obj.stringValue !== undefined)
+        return 'stringValue';
+    if (obj.boolValue !== undefined)
+        return 'boolValue';
+    if (obj.structValue)
+        return 'structValue';
+    if (obj.listValue)
+        return 'listValue';
+    return 'notSet';
+}
+export function whichSource(obj) {
+    if (!obj)
+        return 'notSet';
+    if (obj.path)
+        return 'path';
+    if (obj.url)
+        return 'url';
+    if (obj.inline)
+        return 'inline';
+    return 'notSet';
+}
+// Identical function (Dart identical())
+export function identical(a, b) { return a === b; }
+// Function.apply shim (Dart Function.apply)
+Function.apply = function (fn, positionalArgs, namedArgs) {
+    if (typeof fn !== 'function')
+        return undefined;
+    const args = positionalArgs == null ? [] : (Array.isArray(positionalArgs) ? positionalArgs : [positionalArgs]);
+    return fn(...args);
+};
+// Dart cascade helper — evaluates target, applies ops, returns target.
+export function __ball_cascade(target, ops) {
+    for (const op of ops) {
+        if (typeof op === 'function')
+            op(target);
+    }
+    return target;
+}
+// ── 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).
+export const _nativeMapEntries = Map.prototype.entries;
+export const _nativeMapKeys = Map.prototype.keys;
+export const _nativeMapValues = Map.prototype.values;
+(function installBallPolyfills() {
+    const mp = Map.prototype;
+    if (!mp.containsKey)
+        mp.containsKey = function (k) { return this.has(k); };
+    if (!mp.putIfAbsent) {
+        mp.putIfAbsent = function (k, supplier) {
+            if (!this.has(k))
+                this.set(k, supplier());
+            return this.get(k);
+        };
+    }
+    if (!mp.addAll) {
+        mp.addAll = function (other) {
+            if (other instanceof Map) {
+                // _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') {
+                for (const k of Object.keys(other))
+                    this.set(k, other[k]);
+            }
+        };
+    }
+    Object.defineProperty(mp, 'isEmpty', {
+        configurable: true, get() { return this.size === 0; },
+    });
+    Object.defineProperty(mp, 'isNotEmpty', {
+        configurable: true, get() { return this.size !== 0; },
+    });
+    const ap = Array.prototype;
+    if (!ap.add)
+        ap.add = function (v) { this.push(v); };
+    if (!ap.addAll)
+        ap.addAll = function (iter) {
+            for (const v of iter)
+                this.push(v);
+        };
+    if (!ap.removeLast)
+        ap.removeLast = function () { return this.pop(); };
+    if (!ap.removeAt)
+        ap.removeAt = function (i) { return this.splice(i, 1)[0]; };
+    if (!ap.insert)
+        ap.insert = function (i, v) { this.splice(i, 0, v); };
+    if (!ap.setAll)
+        ap.setAll = function (idx, values) { for (let i = 0; i < values.length; i++)
+            this[idx + i] = values[i]; };
+    if (!ap.where)
+        ap.where = Array.prototype.filter;
+    if (!ap.toList)
+        ap.toList = function () { return this.slice(); };
+    if (!ap.toSet)
+        ap.toSet = function () { return new Set(this); };
+    if (!ap.contains)
+        ap.contains = function (v) { return this.indexOf(v) >= 0; };
+    if (!ap.sublist)
+        ap.sublist = function (start, end) { return this.slice(start, end); };
+    if (!ap.asMap)
+        ap.asMap = function () {
+            const m = {};
+            for (let i = 0; i < this.length; i++)
+                m[i] = this[i];
+            return m;
+        };
+    if (!ap.expand)
+        ap.expand = function (fn) { return this.flatMap(fn); };
+    if (!ap.take)
+        ap.take = function (n) { return this.slice(0, n); };
+    if (!ap.skip)
+        ap.skip = function (n) { return this.slice(n); };
+    if (!ap.any)
+        ap.any = function (fn) { return this.some(fn); };
+    if (!ap.fold)
+        ap.fold = function (init, fn) { return this.reduce(fn, init); };
+    if (!ap.followedBy)
+        ap.followedBy = function (other) { return [...this, ...other]; };
+    if (!ap.getRange)
+        ap.getRange = function (start, end) { return this.slice(start, end); };
+    if (!ap.fillRange)
+        ap.fillRange = function (start, end, fill) {
+            for (let i = start; i < end; i++)
+                this[i] = fill;
+        };
+    if (!ap.setRange)
+        ap.setRange = function (start, end, iterable, skipCount) {
+            const src = Array.isArray(iterable) ? iterable : [...iterable];
+            const skip = skipCount ?? 0;
+            for (let i = start; i < end; i++)
+                this[i] = src[i - start + skip];
+        };
+    // Dart Set polyfills — Set.contains → Set.has, etc.
+    const setp = Set.prototype;
+    if (!setp.contains)
+        setp.contains = function (v) { return this.has(v); };
+    if (!setp.includes)
+        setp.includes = function (v) { return this.has(v); };
+    if (!setp.toList)
+        setp.toList = function () { return [...this]; };
+    if (!setp.add) { /* Set already has .add */ }
+    if (!setp.remove)
+        setp.remove = function (v) { return this.delete(v); };
+    Object.defineProperty(ap, 'isEmpty', {
+        configurable: true, get() { return this.length === 0; },
+    });
+    Object.defineProperty(ap, 'isNotEmpty', {
+        configurable: true, get() { return this.length !== 0; },
+    });
+    Object.defineProperty(ap, 'first', {
+        configurable: true, get() { return this[0]; },
+    });
+    Object.defineProperty(ap, 'last', {
+        configurable: true, get() { return this[this.length - 1]; },
+    });
+    const sp = String.prototype;
+    Object.defineProperty(sp, 'isEmpty', {
+        configurable: true, get() { return this.length === 0; },
+    });
+    Object.defineProperty(sp, 'isNotEmpty', {
+        configurable: true, get() { return this.length !== 0; },
+    });
+    // Note: undefined/null safety for .isEmpty/.isNotEmpty is handled in the
+    // generated code via optional-chaining (?.isEmpty) patterns and protoWrap;
+    // properties cannot be installed on undefined/null directly.
+    // Dart String methods not on JS String.
+    if (!sp.contains)
+        sp.contains = function (s) { return this.includes(s); };
+    if (!sp.replaceFirst)
+        sp.replaceFirst = function (from, to) {
+            return this.replace(from instanceof RegExp ? from : String(from), to);
+        };
+    if (!sp.codeUnitAt)
+        sp.codeUnitAt = function (i) { return this.charCodeAt(i); };
+    if (!sp.compareTo)
+        sp.compareTo = function (other) {
+            return this < other ? -1 : this > other ? 1 : 0;
+        };
+    if (!sp.allMatches)
+        sp.allMatches = function (pattern, start) {
+            const s = typeof start === 'number' ? this.substring(start) : this;
+            if (typeof pattern === 'string') {
+                return Array.from(s.matchAll(new RegExp(pattern, 'g')));
+            }
+            const flags = pattern.flags.includes('g') ? pattern.flags : pattern.flags + 'g';
+            return Array.from(s.matchAll(new RegExp(pattern.source, flags)));
+        };
+    // Dart RegExp polyfills.
+    const rp = RegExp.prototype;
+    if (!rp.firstMatch)
+        rp.firstMatch = function (s) {
+            const m = this.exec(s);
+            if (m)
+                m.group = (i) => m[i];
+            return m;
+        };
+    if (!rp.allMatches)
+        rp.allMatches = function (s) {
+            const flags = this.flags.includes('g') ? this.flags : this.flags + 'g';
+            return [...s.matchAll(new RegExp(this.source, flags))];
+        };
+    if (!rp.hasMatch)
+        rp.hasMatch = function (s) { return this.test(s); };
+    // Dart Number polyfills — Dart num/int methods not on JS Number.prototype.
+    const _ballNp = Number.prototype;
+    if (!_ballNp.gcd)
+        _ballNp.gcd = function (other) {
+            let a = Math.abs(this), b = Math.abs(Number(other));
+            while (b) {
+                const t = b;
+                b = a % b;
+                a = t;
+            }
+            return a;
+        };
+    Object.defineProperty(_ballNp, 'sign', {
+        configurable: true, get() { const n = Number(this); return n > 0 ? 1 : n < 0 ? -1 : 0; },
+    });
+    Object.defineProperty(_ballNp, 'isNaN', {
+        configurable: true, get() { return Number.isNaN(Number(this)); },
+    });
+    Object.defineProperty(_ballNp, 'isFinite', {
+        configurable: true, get() { return Number.isFinite(Number(this)); },
+    });
+    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)
+        _ballNp.ceil = function () { return Math.ceil(Number(this)); };
+    if (!_ballNp.floor)
+        _ballNp.floor = function () { return Math.floor(Number(this)); };
+    if (!_ballNp.round)
+        _ballNp.round = function () { return Math.round(Number(this)); };
+    if (!_ballNp.truncate)
+        _ballNp.truncate = function () { return Math.trunc(Number(this)); };
+    if (!_ballNp.toInt)
+        _ballNp.toInt = function () { return Math.trunc(Number(this)); };
+    if (!_ballNp.toDouble)
+        _ballNp.toDouble = function () { return Number(this); };
+    if (!_ballNp.clamp)
+        _ballNp.clamp = function (lo, hi) { const n = Number(this); return n < lo ? lo : n > hi ? hi : n; };
+    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 __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
+    // checking Ball program inputs (plain objects, not Maps).
+    const op2 = Object.prototype;
+    if (!op2.containsKey) {
+        Object.defineProperty(op2, 'containsKey', {
+            configurable: true, writable: true, enumerable: false,
+            value: function (k) {
+                if (this instanceof Map)
+                    return this.has(k);
+                if (this == null || typeof this !== 'object')
+                    return false;
+                return Object.prototype.hasOwnProperty.call(this, k);
+            },
+        });
+    }
+    // putIfAbsent — Dart Map.putIfAbsent. Works on plain objects too.
+    if (!op2.putIfAbsent) {
+        Object.defineProperty(op2, 'putIfAbsent', {
+            configurable: true, writable: true, enumerable: false,
+            value: function (k, supplier) {
+                if (this instanceof Map) {
+                    if (!this.has(k))
+                        this.set(k, supplier());
+                    return this.get(k);
+                }
+                if (!(k in this))
+                    this[k] = supplier();
+                return this[k];
+            },
+        });
+    }
+    // addAll — Dart Map.addAll. Works on plain objects too.
+    if (!op2.addAll) {
+        Object.defineProperty(op2, 'addAll', {
+            configurable: true, writable: true, enumerable: false,
+            value: function (other) {
+                if (this instanceof Map) {
+                    if (other instanceof Map) {
+                        // _nativeMapEntries, not other.entries() (issue #259).
+                        for (const [k, v] of _nativeMapEntries.call(other))
+                            this.set(k, v);
+                    }
+                    else if (other && typeof other === 'object') {
+                        for (const k of Object.keys(other))
+                            this.set(k, other[k]);
+                    }
+                }
+                else {
+                    if (other instanceof Map) {
+                        for (const [k, v] of other)
+                            this[k] = v;
+                    }
+                    else if (other && typeof other === 'object') {
+                        Object.assign(this, other);
+                    }
+                }
+            },
+        });
+    }
+    // forEach — Dart Map.forEach. Works on plain objects.
+    // Don't overwrite native Map.prototype.forEach.
+    Object.defineProperty(op2, 'forEach', {
+        configurable: true, writable: true, enumerable: false,
+        value: function (fn) {
+            if (this instanceof Map) {
+                return Map.prototype.forEach.call(this, fn);
+            }
+            if (Array.isArray(this)) {
+                return Array.prototype.forEach.call(this, fn);
+            }
+            // Plain object: Dart Map.forEach(void f(K key, V value))
+            if (typeof fn === 'function') {
+                for (const k of Object.keys(this))
+                    fn(k, this[k]);
+            }
+        },
+    });
+    // remove — Dart Map.remove.
+    if (!op2.remove) {
+        Object.defineProperty(op2, 'remove', {
+            configurable: true, writable: true, enumerable: false,
+            value: function (k) {
+                if (this instanceof Map) {
+                    const v = this.get(k);
+                    this.delete(k);
+                    return v;
+                }
+                const v = this[k];
+                delete this[k];
+                return v;
+            },
+        });
+    }
+    // cast — Dart Map.cast<K2,V2>() / List.cast<E2>(). The cast is a static
+    // re-typing only; at runtime it returns the same collection unchanged.
+    if (!op2.cast) {
+        Object.defineProperty(op2, 'cast', {
+            configurable: true, writable: true, enumerable: false,
+            value: function () { return this; },
+        });
+    }
+    // Dart Map has .entries / .keys / .values as GETTERS (no parens).
+    // 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.
+    // (_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,
+        get() {
+            return [..._nativeMapEntries.call(this)].map(([k, v]) => ({ key: k, value: v }));
+        },
+    });
+    Object.defineProperty(Map.prototype, 'keys', {
+        configurable: true, enumerable: false,
+        get() { return [..._nativeMapKeys.call(this)]; },
+    });
+    Object.defineProperty(Map.prototype, 'values', {
+        configurable: true, enumerable: false,
+        get() { return [..._nativeMapValues.call(this)]; },
+    });
+    // For plain objects — same getters on Object.prototype.
+    // Helper: define a getter on Object.prototype that also allows
+    // own-property assignment (setter stores as a data property on the
+    // instance, shadowing the prototype getter for future accesses).
+    function defDartGetter(name, getter) {
+        Object.defineProperty(op2, name, {
+            configurable: true, enumerable: false,
+            get: getter,
+            set(v) {
+                Object.defineProperty(this, name, {
+                    value: v, writable: true, configurable: true, enumerable: true,
+                });
+            },
+        });
+    }
+    // .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 (!__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 (!__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 (!__isGenuineMap(this)) {
+            throw new Error('type \'' + __ball_to_string(this) + '\' has no .values getter (not a Map)');
+        }
+        return Object.values(this);
+    });
+    defDartGetter('length', function () {
+        if (this instanceof Map)
+            return this.size;
+        if (this instanceof Set)
+            return this.size;
+        if (typeof this === 'string' || Array.isArray(this))
+            return this.length;
+        if (this == null || typeof this !== 'object')
+            return 0;
+        return Object.keys(this).filter((k) => !k.startsWith('__')).length;
+    });
+    // runtimeType — Dart's Object.runtimeType. Returns the Dart-style
+    // type name for any JS value. Used by the compiled engine for type
+    // checking and error messages.
+    Object.defineProperty(op2, 'runtimeType', {
+        configurable: true, enumerable: false,
+        get() {
+            if (this === null || this === undefined)
+                return 'Null';
+            if (this instanceof BallDouble)
+                return 'double';
+            if (typeof this === 'number' || this instanceof Number)
+                return Number.isInteger(+this) ? 'int' : 'double';
+            if (typeof this === 'string' || this instanceof String)
+                return 'String';
+            if (typeof this === 'boolean' || this instanceof Boolean)
+                return 'bool';
+            if (typeof this === 'function')
+                return 'Function';
+            if (Array.isArray(this))
+                return 'List';
+            if (this instanceof Set)
+                return 'Set';
+            if (this instanceof Map)
+                return 'Map';
+            if (this instanceof RegExp)
+                return 'RegExp';
+            const t = this['__type__'];
+            if (typeof t === 'string' && t.length > 0) {
+                const ci = t.indexOf(':');
+                return ci >= 0 ? t.substring(ci + 1) : t;
+            }
+            return 'Map';
+        },
+    });
+    // Also add to Number.prototype, String.prototype, Boolean.prototype
+    // (they don't inherit from Object.prototype getters reliably for primitives).
+    Object.defineProperty(Number.prototype, 'runtimeType', {
+        configurable: true, enumerable: false,
+        get() { return Number.isInteger(+this) ? 'int' : 'double'; },
+    });
+    Object.defineProperty(String.prototype, 'runtimeType', {
+        configurable: true, enumerable: false,
+        get() { return 'String'; },
+    });
+    Object.defineProperty(Boolean.prototype, 'runtimeType', {
+        configurable: true, enumerable: false,
+        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).
+export 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);
+}
+export 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);
+}
+export 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].
+export 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
+// with .fields (Map<String, Value>) and Value as .whichKind() +
+// .stringValue / .boolValue / .numberValue / .listValue / .structValue.
+// In proto3 JSON, these serialize as plain objects and values.
+//
+// This shim makes plain JSON objects behave like Struct/Value so the
+// compiled engine.dart can call .fields['key'].whichKind() etc.
+//
+// Strategy: Object.prototype gets a .fields getter that returns a
+// Proxy wrapping the object as a Map-like. Accessing [key] on the
+// proxy returns a Value-like wrapper with .whichKind() / typed
+// accessors (.stringValue, .boolValue, .numberValue, .listValue,
+// .structValue).
+export const structpb_Value_Kind = {
+    nullValue: 'nullValue',
+    numberValue: 'numberValue',
+    stringValue: 'stringValue',
+    boolValue: 'boolValue',
+    structValue: 'structValue',
+    listValue: 'listValue',
+};
+export class __BallValueWrapper {
+    _raw;
+    constructor(raw) { this._raw = raw; }
+    whichKind() {
+        const v = this._raw;
+        if (v === null || v === undefined)
+            return 'nullValue';
+        if (typeof v === 'string')
+            return 'stringValue';
+        if (typeof v === 'boolean')
+            return 'boolValue';
+        if (typeof v === 'number')
+            return 'numberValue';
+        if (Array.isArray(v))
+            return 'listValue';
+        if (typeof v === 'object')
+            return 'structValue';
+        return 'nullValue';
+    }
+    get stringValue() { return typeof this._raw === 'string' ? this._raw : String(this._raw ?? ''); }
+    get boolValue() { return !!this._raw; }
+    get numberValue() { return Number(this._raw); }
+    get nullValue() { return null; }
+    get listValue() {
+        const arr = Array.isArray(this._raw) ? this._raw : [];
+        return { values: arr.map((v) => new __BallValueWrapper(v)) };
+    }
+    get structValue() {
+        const obj = (typeof this._raw === 'object' && this._raw !== null) ? this._raw : {};
+        const fields = {};
+        for (const [k, v] of Object.entries(obj))
+            fields[k] = new __BallValueWrapper(v);
+        return { fields };
+    }
+    // Also proxy hasXxx for sub-values.
+    hasNullValue() { return this._raw == null; }
+    hasStringValue() { return typeof this._raw === 'string'; }
+    hasBoolValue() { return typeof this._raw === 'boolean'; }
+    hasNumberValue() { return typeof this._raw === 'number'; }
+    hasListValue() { return Array.isArray(this._raw); }
+    hasStructValue() { return typeof this._raw === 'object' && this._raw !== null && !Array.isArray(this._raw); }
+    // Pass-through for when the wrapper is used in expressions.
+    toString() { return String(this._raw); }
+    valueOf() { return this._raw; }
+}
+// Struct.fields shimming is done via a metadata-specific wrapper.
+// We do NOT add .fields to Object.prototype because it conflicts
+// with data properties named "fields" on MessageCreation / TypeDef.
+// Instead, the compiled engine accesses metadata.fields['key'] —
+// in proto3 JSON, metadata IS the fields directly, so we add a
+// .fields getter only when the object is a metadata Struct (i.e.,
+// it has string/bool/number/array/object values and no proto-shape
+// keys like "call"/"literal"/"block").
+//
+// The protoWrap normalizer in the test harness is responsible for
+// converting metadata objects to have the right shape.
+// ── Protobuf compatibility shims ────────────────────────────────
+//
+// The Dart encoder produces code that uses Dart's protobuf runtime
+// API (.whichExpr(), Expression_Expr.call, .hasInput(), .toInt(), etc.)
+// on what are really plain JSON objects at runtime. These shims make
+// the proto-style method calls work on plain objects so the compiled
+// engine.dart can execute on Node.
+// Oneof discriminator enums — string-valued constants that match the
+// field names the Dart protobuf codegen uses.
+export const Expression_Expr = {
+    call: 'call', literal: 'literal', reference: 'reference',
+    fieldAccess: 'fieldAccess', messageCreation: 'messageCreation',
+    block: 'block', lambda: 'lambda', notSet: 'notSet',
+};
+export const Literal_Value = {
+    intValue: 'intValue', doubleValue: 'doubleValue',
+    stringValue: 'stringValue', boolValue: 'boolValue',
+    listValue: 'listValue', bytesValue: 'bytesValue', notSet: 'notSet',
+};
+export const Statement_Stmt = {
+    let: 'let', expression: 'expression', notSet: 'notSet',
+};
+export const ModuleImport_Source = {
+    http: 'http', file: 'file', inline: 'inline',
+    git: 'git', registry: 'registry', notSet: 'notSet',
+};
+// Object.prototype shims for .whichXxx() / .hasXxx() / .toInt() —
+// these match the Dart protobuf generated API. Each is configurable
+// and non-enumerable so it doesn't pollute for-in loops.
+(function installProtoShims() {
+    const op = Object.prototype;
+    function defMethod(name, fn) {
+        if (op[name])
+            return;
+        Object.defineProperty(op, name, {
+            configurable: true, writable: true, enumerable: false, value: fn,
+        });
+    }
+    // whichExpr / whichValue / whichStmt / whichSource — return which
+    // oneof field is set on this object.
+    defMethod('whichExpr', function () {
+        for (const k of ['call', 'literal', 'reference', 'fieldAccess', 'messageCreation', 'block', 'lambda']) {
+            if (this[k] !== undefined && this[k] !== null)
+                return k;
+        }
+        return 'notSet';
+    });
+    defMethod('whichValue', function () {
+        for (const k of ['intValue', 'doubleValue', 'stringValue', 'boolValue', 'listValue', 'bytesValue']) {
+            if (this[k] !== undefined && this[k] !== null)
+                return k;
+        }
+        return 'notSet';
+    });
+    defMethod('whichStmt', function () {
+        if (this['let'] !== undefined && this['let'] !== null)
+            return 'let';
+        if (this['expression'] !== undefined && this['expression'] !== null)
+            return 'expression';
+        return 'notSet';
+    });
+    defMethod('whichSource', function () {
+        for (const k of ['http', 'file', 'inline', 'git', 'registry']) {
+            if (this[k] !== undefined && this[k] !== null)
+                return k;
+        }
+        return 'notSet';
+    });
+    // Presence checks — .hasXxx() returns true if the field is set.
+    for (const field of [
+        'input', 'body', 'result', 'metadata', 'value', 'name', 'module',
+        'left', 'right', 'condition', 'then', 'else', 'finally',
+        'subject', 'cases', 'catches', 'init', 'update', 'iterable',
+        'target', 'index', 'field', 'object', 'key', 'message',
+        'stringValue', 'boolValue', 'intValue', 'doubleValue', 'listValue',
+        'call', 'literal', 'reference', 'fieldAccess', 'messageCreation',
+        'block', 'lambda', 'let', 'expression', 'descriptor',
+    ]) {
+        const methodName = 'has' + field[0].toUpperCase() + field.slice(1);
+        defMethod(methodName, function () {
+            return this[field] !== undefined && this[field] !== null;
+        });
+    }
+    // Proto field-name aliases — Dart's protobuf codegen renames some
+    // fields to avoid keyword collisions (field → field_2, etc.) but
+    // proto3 JSON uses the original names. Add getters so both work.
+    Object.defineProperty(op, 'field_2', {
+        configurable: true, enumerable: false,
+        get() { return this.field; },
+        set(v) { this.field = v; },
+    });
+    // descriptor_ → descriptor (same issue)
+    Object.defineProperty(op, 'descriptor_', {
+        configurable: true, enumerable: false,
+        get() { return this.descriptor; },
+        set(v) { this.descriptor = v; },
+    });
+    // .toInt() — Dart's Int64/fixnum returns int from string. In proto3
+    // JSON, int64 fields are serialized as strings ("42" not 42).
+    defMethod('toInt', function () {
+        if (typeof this === 'number')
+            return this;
+        if (typeof this === 'string')
+            return parseInt(this, 10);
+        if (typeof this.valueOf === 'function')
+            return parseInt(String(this.valueOf()), 10);
+        return 0;
+    });
+    // .toList() on Uint8Array (bytesValue)
+    defMethod('toList', function () {
+        if (this instanceof Uint8Array)
+            return Array.from(this);
+        if (Array.isArray(this))
+            return this.slice();
+        return [];
+    });
+})();
+// ── Reified generics helpers ────────────────────────────────────────
+export function __ball_with_type_args(obj, args) {
+    obj.__type_args__ = args;
+    return obj;
+}
+// ── Generic type checking helper ────────────────────────────────────
+export function __ball_split_type_args(s) {
+    const result = [];
+    let depth = 0, start = 0;
+    for (let i = 0; i < s.length; i++) {
+        if (s[i] === '<')
+            depth++;
+        else if (s[i] === '>')
+            depth--;
+        else if (s[i] === ',' && depth === 0) {
+            result.push(s.slice(start, i).trim());
+            start = i + 1;
+        }
+    }
+    const last = s.slice(start).trim();
+    if (last)
+        result.push(last);
+    return result;
+}
+export function __ball_is_type(value, typeStr) {
+    const t = typeStr.trim();
+    if (t.endsWith('?')) {
+        if (value == null)
+            return true;
+        return __ball_is_type(value, t.slice(0, -1));
+    }
+    const ltIdx = t.indexOf('<');
+    if (ltIdx === -1) {
+        switch (t) {
+            case 'int': return typeof value === 'number' && Number.isInteger(value);
+            case 'double': return value instanceof BallDouble || (typeof value === 'number' && !Number.isInteger(value));
+            case 'num':
+            case 'number': return typeof value === 'number' || value instanceof BallDouble;
+            case 'String':
+            case 'string': return typeof value === 'string';
+            case 'bool':
+            case 'boolean': return typeof value === 'boolean';
+            case 'List':
+            case 'Iterable': return Array.isArray(value);
+            case 'Map': return typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof BallDouble) && !(value instanceof Set);
+            case 'Set': return value instanceof Set;
+            case 'Null': return value == null;
+            case 'Function': return typeof value === 'function';
+            case 'Object':
+            case 'dynamic': return value != null;
+            default: {
+                const objType = value?.__type__ ?? value?.constructor?.name;
+                if (objType === t)
+                    return true;
+                return value != null;
+            }
+        }
+    }
+    const baseType = t.slice(0, ltIdx).trim();
+    const typeArgs = __ball_split_type_args(t.slice(ltIdx + 1, t.lastIndexOf('>')));
+    switch (baseType) {
+        case 'List':
+        case 'Iterable':
+            if (!Array.isArray(value))
+                return false;
+            if (typeArgs.length === 0)
+                return true;
+            return value.every((e) => __ball_is_type(e, typeArgs[0]));
+        case 'Map':
+            if (typeof value !== 'object' || value === null || Array.isArray(value) || value instanceof BallDouble || value instanceof Set)
+                return false;
+            if (typeArgs.length < 2)
+                return true;
+            return Object.keys(value).filter((k) => !k.startsWith('__')).every((k) => __ball_is_type(k, typeArgs[0]) && __ball_is_type(value[k], typeArgs[1]));
+        case 'Set':
+            if (!(value instanceof Set))
+                return false;
+            if (typeArgs.length === 0)
+                return true;
+            for (const e of value) {
+                if (!__ball_is_type(e, typeArgs[0]))
+                    return false;
+            }
+            return true;
+        default: {
+            const objType = value?.__type__ ?? value?.constructor?.name;
+            if (objType === baseType) {
+                const objArgs = value.__type_args__;
+                if (Array.isArray(objArgs)) {
+                    if (objArgs.length !== typeArgs.length)
+                        return false;
+                    return objArgs.every((a, i) => String(a).trim() === typeArgs[i].trim());
+                }
+                return false;
+            }
+            return __ball_is_type(value, baseType);
+        }
+    }
+}
+// Minimal DateTime / Duration / Future polyfills used by std_time and
+// the round-tripped engine's sleep_ms helper. Wide enough for the
+// conformance suite, narrow enough to stay out of users' way.
+export class DateTime {
+    _epochMs;
+    isUtc;
+    constructor(epochMs, isUtc = false) {
+        this._epochMs = typeof epochMs === 'number' ? epochMs : Date.now();
+        this.isUtc = isUtc;
+    }
+    static now() { return new DateTime(Date.now(), false); }
+    static fromMillisecondsSinceEpoch(ms, isUtc = false) {
+        return new DateTime(ms, isUtc === true || (isUtc && isUtc.isUtc === true));
+    }
+    static parse(s) { return new DateTime(Date.parse(s), true); }
+    get millisecondsSinceEpoch() { return this._epochMs; }
+    get microsecondsSinceEpoch() { return this._epochMs * 1000; }
+    toUtc() { return new DateTime(this._epochMs, true); }
+    toIso8601String() { return new Date(this._epochMs).toISOString(); }
+    get year() { return new Date(this._epochMs).getUTCFullYear(); }
+    get month() { return new Date(this._epochMs).getUTCMonth() + 1; }
+    get day() { return new Date(this._epochMs).getUTCDate(); }
+    get hour() { return new Date(this._epochMs).getUTCHours(); }
+    get minute() { return new Date(this._epochMs).getUTCMinutes(); }
+    get second() { return new Date(this._epochMs).getUTCSeconds(); }
+}
+export class Duration {
+    _us;
+    constructor(opts) {
+        const o = opts ?? {};
+        const ms = o.milliseconds ?? 0;
+        const s = o.seconds ?? 0;
+        const m = o.minutes ?? 0;
+        const us = o.microseconds ?? 0;
+        this._us = us + ms * 1000 + s * 1_000_000 + m * 60_000_000;
+    }
+    get inMilliseconds() { return Math.floor(this._us / 1000); }
+    get inMicroseconds() { return this._us; }
+}
+export const Future = {
+    delayed(d) {
+        const ms = (d && typeof d.inMilliseconds === 'number') ? d.inMilliseconds : Number(d ?? 0);
+        return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+    },
+    value(v) { return Promise.resolve(v); },
+};
+// ── dart:typed_data shims (ByteData, Endian) ───────────────────────
+// ball_protobuf uses ByteData for IEEE 754 float/double bit conversion.
+// Dart's ByteData wraps a fixed-size byte buffer with typed get/set methods.
+export const Endian = { little: true, big: false, host: true };
+export class ByteData {
+    _view;
+    _length;
+    constructor(size) {
+        this._view = new DataView(new ArrayBuffer(size));
+        this._length = size;
+    }
+    get lengthInBytes() { return this._length; }
+    getUint8(i) { return this._view.getUint8(i); }
+    setUint8(i, v) { this._view.setUint8(i, v); }
+    getInt8(i) { return this._view.getInt8(i); }
+    setInt8(i, v) { this._view.setInt8(i, v); }
+    getUint16(i, endian) { return this._view.getUint16(i, endian === Endian.little); }
+    setUint16(i, v, endian) { this._view.setUint16(i, v, endian === Endian.little); }
+    getInt16(i, endian) { return this._view.getInt16(i, endian === Endian.little); }
+    setInt16(i, v, endian) { this._view.setInt16(i, v, endian === Endian.little); }
+    getUint32(i, endian) { return this._view.getUint32(i, endian === Endian.little); }
+    setUint32(i, v, endian) { this._view.setUint32(i, v, endian === Endian.little); }
+    getInt32(i, endian) { return this._view.getInt32(i, endian === Endian.little); }
+    setInt32(i, v, endian) { this._view.setInt32(i, v, endian === Endian.little); }
+    getFloat32(i, endian) { return this._view.getFloat32(i, endian === Endian.little); }
+    setFloat32(i, v, endian) { this._view.setFloat32(i, v, endian === Endian.little); }
+    getFloat64(i, endian) { return this._view.getFloat64(i, endian === Endian.little); }
+    setFloat64(i, v, endian) { this._view.setFloat64(i, v, endian === Endian.little); }
+    getUint64(i, endian) {
+        const lo = this._view.getUint32(i, endian === Endian.little);
+        const hi = this._view.getUint32(i + 4, endian === Endian.little);
+        return endian === Endian.little
+            ? BigInt(lo) | (BigInt(hi) << 32n)
+            : (BigInt(lo) << 32n) | BigInt(hi);
+    }
+    setUint64(i, v, endian) {
+        const lo = Number(v & 0xffffffffn);
+        const hi = Number((v >> 32n) & 0xffffffffn);
+        if (endian === Endian.little) {
+            this._view.setUint32(i, lo, true);
+            this._view.setUint32(i + 4, hi, true);
+        }
+        else {
+            this._view.setUint32(i, hi, false);
+            this._view.setUint32(i + 4, lo, false);
+        }
+    }
+    getInt64(i, endian) {
+        const unsigned = this.getUint64(i, endian);
+        return unsigned >= 0x8000000000000000n ? unsigned - 0x10000000000000000n : unsigned;
+    }
+    setInt64(i, v, endian) {
+        this.setUint64(i, v < 0n ? v + 0x10000000000000000n : v, endian);
+    }
+    get buffer() {
+        const view = this._view;
+        return {
+            asUint8List: (start, length) => {
+                const s = start ?? 0;
+                const l = length ?? view.byteLength - s;
+                return [...new Uint8Array(view.buffer, s, l)];
+            },
+        };
+    }
+}
+// ── dart:convert shims (utf8, jsonEncode, jsonDecode) ───────────────
+// ball_protobuf uses utf8.encode/decode for string↔bytes and
+// jsonEncode/jsonDecode for JSON serialization.
+export const utf8 = {
+    encode(s) { return [...new TextEncoder().encode(s)]; },
+    decode(bytes) { return new TextDecoder().decode(new Uint8Array(bytes)); },
+};
+export function jsonEncode(obj) { return JSON.stringify(obj); }
+export function jsonDecode(s) { return JSON.parse(s); }
+export function __isUnknownFnError(e) {
+    const m = e && typeof e.message === 'string' ? e.message : (typeof e === 'string' ? e : '');
+    return m.startsWith('Unknown std function:') || m.startsWith('Unknown base module:');
+}
+export function versionLine(version) {
+    const input = version;
+    return ('ball ' + __ball_to_string(version));
+}
+export function infoReport(program) {
+    const input = program;
+    let lines = [];
+    lines = (lines.push(((('Program: ' + __ball_to_string(program.name)) + ' v') + __ball_to_string(program.version))), lines);
+    lines = (lines.push(((('Entry:   ' + __ball_to_string(program.entryModule)) + '.') + __ball_to_string(program.entryFunction))), lines);
+    lines = (lines.push(('Modules: ' + __ball_to_string(program.modules.length))), lines);
+    lines = (lines.push(''), lines);
+    for (const module of program.modules) {
+        let isBase = _allBase(module.functions);
+        lines = (lines.push((('  ' + __ball_to_string(module.name)) + __ball_to_string((isBase ? ' (base)' : '')))), lines);
+        if (!(module.typeDefs.length === 0)) {
+            lines = (lines.push(('    typeDefs:  ' + __ball_to_string(module.typeDefs.length))), lines);
+        }
+        if (!(module.typeAliases.length === 0)) {
+            lines = (lines.push(('    aliases:   ' + __ball_to_string(module.typeAliases.length))), lines);
+        }
+        if (!(module.enums.length === 0)) {
+            lines = (lines.push(('    enums:     ' + __ball_to_string(module.enums.length))), lines);
+        }
+        lines = (lines.push(('    functions: ' + __ball_to_string(module.functions.length))), lines);
+        if (!(module.description.length === 0)) {
+            lines = (lines.push(('    desc:      ' + __ball_to_string(module.description))), lines);
+        }
+    }
+    return lines.join('\n');
+}
+export function validationErrors(program) {
+    const input = program;
+    let errors = [];
+    if ((program.entryModule.length === 0)) {
+        errors = (errors.push('Missing entry_module'), errors);
+    }
+    if ((program.entryFunction.length === 0)) {
+        errors = (errors.push('Missing entry_function'), errors);
+    }
+    if ((!(program.entryModule.length === 0) && !(program.entryFunction.length === 0))) {
+        let entryMod;
+        for (const m of program.modules) {
+            if (__ball_eq(m.name, program.entryModule)) {
+                entryMod = m;
+                break;
+            }
+        }
+        if (__ball_eq(entryMod, null)) {
+            errors = (errors.push((('Entry module "' + __ball_to_string(program.entryModule)) + '" not found in modules')), errors);
+        }
+        else {
+            let entryFunc;
+            for (const f of entryMod.functions) {
+                if (__ball_eq(f.name, program.entryFunction)) {
+                    entryFunc = f;
+                    break;
+                }
+            }
+            if (__ball_eq(entryFunc, null)) {
+                errors = (errors.push(((('Entry function "' + __ball_to_string(program.entryFunction)) + '" not found ') + (('in module "' + __ball_to_string(program.entryModule)) + '"'))), errors);
+            }
+        }
+    }
+    for (let i = 0; __ball_lt(i, program.modules.length); (i++)) {
+        let m = __ball_index(program.modules, i);
+        if ((m.name.length === 0)) {
+            errors = (errors.push((('Module at index ' + __ball_to_string(i)) + ' has no name')), errors);
+        }
+    }
+    let seen = [];
+    for (const m of program.modules) {
+        if (!(m.name.length === 0)) {
+            if (seen.includes(m.name)) {
+                errors = (errors.push((('Duplicate module name: "' + __ball_to_string(m.name)) + '"')), errors);
+            }
+            else {
+                seen = (seen.push(m.name), seen);
+            }
+        }
+    }
+    for (const m of program.modules) {
+        for (const f of m.functions) {
+            if (((!f.isBase && !hasBody(f)) && !hasMetadata(f))) {
+                errors = (errors.push((((__ball_to_string(m.name) + '.') + __ball_to_string(f.name)) + ': non-base function with no body or metadata')), errors);
+            }
+        }
+    }
+    return errors;
+}
+export function validateOk(program) {
+    const input = program;
+    return (validationErrors(program).length === 0);
+}
+export function validateReport(program) {
+    const input = program;
+    let errors = validationErrors(program);
+    if ((errors.length === 0)) {
+        let totalFns = 0;
+        for (const m of program.modules) {
+            totalFns += m.functions.length;
+        }
+        return ((((('Valid: "' + __ball_to_string(program.name)) + '" v') + __ball_to_string(program.version)) + '\n') + (((('  ' + __ball_to_string(program.modules.length)) + ' modules, ') + __ball_to_string(totalFns)) + ' functions'));
+    }
+    let lines = [];
+    lines = (lines.push((('Invalid: ' + __ball_to_string(errors.length)) + ' error(s) found')), lines);
+    for (const e of errors) {
+        lines = (lines.push(('  - ' + __ball_to_string(e))), lines);
+    }
+    return lines.join('\n');
+}
+export function treeReport(program) {
+    const input = program;
+    let lines = [];
+    lines = (lines.push(((__ball_to_string(program.name) + ' v') + __ball_to_string(program.version))), lines);
+    for (const m of program.modules) {
+        let isBase = (_allBase(m.functions) && !(m.functions.length === 0));
+        let tag = (isBase ? ' (base)' : '');
+        let fnCount = m.functions.length;
+        lines = (lines.push(((((('  ' + __ball_to_string(m.name)) + __ball_to_string(tag)) + ' \u2014 ') + __ball_to_string(fnCount)) + ' functions')), lines);
+        for (const imp of m.moduleImports) {
+            lines = (lines.push((((('    \u2192 ' + __ball_to_string(imp.name)) + ' (') + __ball_to_string(_importSource(imp))) + ')')), lines);
+        }
+    }
+    return lines.join('\n');
+}
+export function _importSource(imp) {
+    const input = imp;
+    if (hasHttp(imp)) {
+        return ('http: ' + __ball_to_string(imp.http.url));
+    }
+    if (hasFile(imp)) {
+        return ('file: ' + __ball_to_string(imp.file.path));
+    }
+    if (hasGit(imp)) {
+        return ((('git: ' + __ball_to_string(imp.git.url)) + '@') + __ball_to_string(imp.git.ref));
+    }
+    if (hasRegistry(imp)) {
+        return ((__ball_to_string(imp.registry.registry.name) + ': ') + ((__ball_to_string(imp.registry.package) + '@') + __ball_to_string(imp.registry.version)));
+    }
+    if (hasInline(imp)) {
+        return 'inline';
+    }
+    return 'ref only';
+}
+export function auditReport(program) {
+    const input = program;
+    let report = analyzeCapabilities(program);
+    let buf = "";
+    buf.writeln(formatCapabilityReport(report));
+    let termReport = analyzeTermination(program);
+    if (!(termReport.warnings.length === 0)) {
+        buf.writeln('');
+        buf.writeln(formatTerminationReport(termReport));
+    }
+    return __ball_to_string(buf);
+}
+export function _allBase(functions) {
+    const input = functions;
+    for (const f of functions) {
+        if (!f.isBase) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=compiled_cli.js.map