@ball-lang/cli 1.24.0 → 1.25.0

package/src/compiled_cli.ts

@@ -0,0 +1,1736 @@
+// @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: boolean, t: string): boolean {
+  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?: any) {
+    super();
+    if (entries && typeof entries === 'object') {
+      if (entries instanceof Map) {
+        for (const [k, v] of entries) (this as any)[k] = v;
+      } else {
+        for (const k of Object.keys(entries)) (this as any)[k] = entries[k];
+      }
+    }
+  }
+}
+
+export class BallList extends Array {
+  constructor(items?: any) {
+    super();
+    if (Array.isArray(items)) for (const it of items) this.push(it);
+  }
+}
+
+export class BallObject extends BallMap {
+  constructor(arg0?: any, superObject?: any, fields?: any, methods?: any) {
+    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: any = 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 as any)[k] = fieldMap[k];
+    // Class bookkeeping → own props the engine reads/writes by bracket name.
+    (this as any)['__type__'] = typeName ?? '';
+    (this as any)['__super__'] = superObject ?? null;
+    (this as any)['__fields__'] = fieldMap;
+    (this as any)['__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],
+    ] as Array<[string, any]>) {
+      Object.defineProperty(this, name, {
+        value, writable: true, configurable: true, enumerable: false,
+      });
+    }
+  }
+
+  setField(name: any, value: any): void {
+    (this as any).fields[name] = value;
+    (this as any)[name] = value;
+  }
+}
+(globalThis as any).BallMap = BallMap;
+(globalThis as any).BallList = BallList;
+(globalThis as any).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 {
+  readonly value: number;
+  // 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: number) { this.value = v instanceof BallDouble ? v.value : v; }
+  valueOf(): number { return this.value; }
+  get isNaN(): boolean { return Number.isNaN(this.value); }
+  get isFinite(): boolean { return Number.isFinite(this.value); }
+  get isInfinite(): boolean { return !Number.isFinite(this.value) && !Number.isNaN(this.value); }
+  get isNegative(): boolean { 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: any): number { return this.value % Number(other); }
+  toString(): string {
+    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: string): any {
+    if (hint === 'string') return this.toString();
+    return this.value;
+  }
+}
+(globalThis as any).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: any, b: any): any {
+  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: any, b: any): any {
+  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: any, b: any): any {
+  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: any, b: any): boolean {
+  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: any, b: any): any {
+  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: any, b: any): any {
+  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: any, b: any): any {
+  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: any, b: any): any {
+  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: any): string {
+  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: string[] = [];
+    // 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: string) => !k.startsWith('__'));
+    if (keys.length > 0) {
+      return '{' + keys.map((k: string) => __ball_to_string(k) + ': ' + __ball_to_string(v[k])).join(', ') + '}';
+    }
+    return '{}';
+  }
+  return String(v);
+}
+
+export function __ball_parse_int(s: string): number {
+  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: any): any {
+  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: string): BallDouble {
+  const n = parseFloat(s);
+  if (Number.isNaN(n)) throw new Error('FormatException: ' + s);
+  return new BallDouble(n);
+}
+
+export function __ball_double_to_string(n: number): string {
+  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: any, digits: any): string {
+  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: any, b: any): any {
+  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: any, items: any): void {
+  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: bigint): any {
+  // 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: any): bigint {
+  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: any): boolean {
+  return typeof v === 'number' && Number.isInteger(v) && v >= -2147483648 && v <= 2147483647;
+}
+export function __ball_bitand(a: any, b: any): any {
+  if (__fits32(a) && __fits32(b)) return a & b;
+  return __i64_wrap(__to_bigint(a) & __to_bigint(b));
+}
+export function __ball_bitor(a: any, b: any): any {
+  if (__fits32(a) && __fits32(b)) return a | b;
+  return __i64_wrap(__to_bigint(a) | __to_bigint(b));
+}
+export function __ball_bitxor(a: any, b: any): any {
+  if (__fits32(a) && __fits32(b)) return a ^ b;
+  return __i64_wrap(__to_bigint(a) ^ __to_bigint(b));
+}
+export function __ball_bitnot(a: any): any {
+  if (__fits32(a)) return ~a;
+  return __i64_wrap(~__to_bigint(a));
+}
+export function __ball_shl(a: any, b: any): any { return __i64_wrap(__to_bigint(a) << __to_bigint(b)); }
+export function __ball_shr(a: any, b: any): any { 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: any, b: any): any {
+  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 as any).toJSON = function (this: bigint) {
+  return (JSON as any).rawJSON(this.toString());
+};
+export function __ball_negate(a: any): any {
+  if (typeof a === 'bigint') return __i64_wrap(-a);
+  if (a instanceof BallDouble) return new BallDouble(-a.value);
+  return -a;
+}
+export function __ball_divide(a: any, b: any): any {
+  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: any): any {
+  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: any, b: any): any {
+  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: any, b: any): any {
+  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: any, b: any): any {
+  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: any = 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: any, idx: any): any {
+  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: any) => { const n = parseInt(String(s), 10); if (isNaN(n)) throw new Error('FormatException: ' + s); return n; },
+  tryParse: (s: any) => { const n = parseInt(String(s), 10); return isNaN(n) ? null : n; },
+};
+export const double = {
+  parse: (s: any) => { const n = parseFloat(String(s)); if (isNaN(n)) throw new Error('FormatException: ' + s); return n; },
+  tryParse: (s: any) => { const n = parseFloat(String(s)); return isNaN(n) ? null : n; },
+  infinity: Infinity,
+  nan: NaN,
+  negativeInfinity: -Infinity,
+};
+export const num = {
+  parse: (s: any) => { const n = Number(s); if (isNaN(n)) throw new Error('FormatException: ' + s); return n; },
+  tryParse: (s: any) => { const n = Number(s); return isNaN(n) ? null : n; },
+};
+export const bool = {
+  parse: (s: any) => { if (s === 'true') return true; if (s === 'false') return false; throw new Error('FormatException: ' + s); },
+  tryParse: (s: any) => { 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__: unique symbol = 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: any): any {
+  if (v == null || v === __no_init__) return [];
+  return v;
+}
+
+// Dart type constructor shims — List, Map, etc.
+export const List = {
+  filled: (count: any, value: any) => Array(count).fill(value),
+  generate: (count: any, generator: any) => {
+    const r: any[] = [];
+    for (let i = 0; i < count; i++) r.push(generator(i));
+    return r;
+  },
+  from: (iter: any) => Array.isArray(iter) ? [...iter] : [...iter],
+  of: (iter: any) => Array.isArray(iter) ? [...iter] : [...iter],
+  unmodifiable: (iter: any) => Object.freeze(Array.isArray(iter) ? [...iter] : [...iter]),
+  empty: (opts?: any) => [],
+  castFrom: (source: any) => Array.isArray(source) ? [...source] : [],
+};
+
+// Set.unmodifiable
+export const _nativeSet = Set;
+(Set as any).unmodifiable = (iter: any) => {
+  const s = new _nativeSet(iter);
+  return Object.freeze(s);
+};
+(Set as any).from = (iter: any) => new _nativeSet(iter);
+(Set as any).of = (iter: any) => 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 as any).push) (Set.prototype as any).push = function(v: any) { 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: any) {
+  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: any, value: any) {
+    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: any, field: string): boolean { return obj?.[field] !== undefined && obj?.[field] !== null; }
+export function hasMetadata(obj: any): boolean { return _has(obj, 'metadata'); }
+export function hasBody(obj: any): boolean { return _has(obj, 'body'); }
+export function hasInput(obj: any): boolean { return _has(obj, 'input'); }
+export function hasDescriptor(obj: any): boolean { 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: any): boolean { return _has(obj, 'http'); }
+export function hasFile(obj: any): boolean { return _has(obj, 'file'); }
+export function hasGit(obj: any): boolean { return _has(obj, 'git'); }
+export function hasRegistry(obj: any): boolean { return _has(obj, 'registry'); }
+export function hasInline(obj: any): boolean { return _has(obj, 'inline'); }
+export function hasStringValue(obj: any): boolean { return _has(obj, 'stringValue'); }
+export function hasBoolValue(obj: any): boolean { return _has(obj, 'boolValue'); }
+export function hasNumberValue(obj: any): boolean { return _has(obj, 'numberValue'); }
+export function hasResult(obj: any): boolean { return _has(obj, 'result'); }
+export function hasCall(obj: any): boolean { return _has(obj, 'call'); }
+export function hasListValue(obj: any): boolean { return _has(obj, 'listValue'); }
+export function hasNullValue(obj: any): boolean { return _has(obj, 'nullValue'); }
+export function hasStructValue(obj: any): boolean { return _has(obj, 'structValue'); }
+export function hasMatch(obj: any): boolean { return _has(obj, 'match'); }
+export function hasXxx(obj: any): boolean { return false; }
+export function whichXxx(obj: any): string { 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: any): string {
+  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: any): string {
+  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: any): string {
+  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: any): string {
+  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: any): string {
+  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: any, b: any): boolean { return a === b; }
+
+// Function.apply shim (Dart Function.apply)
+(Function as any).apply = function(fn: any, positionalArgs: any, namedArgs?: any) {
+  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: any, ops: any[]): any {
+  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: any = Map.prototype;
+  if (!mp.containsKey) mp.containsKey = function (k: any) { return this.has(k); };
+  if (!mp.putIfAbsent) {
+    mp.putIfAbsent = function (k: any, supplier: any) {
+      if (!this.has(k)) this.set(k, supplier());
+      return this.get(k);
+    };
+  }
+  if (!mp.addAll) {
+    mp.addAll = function (other: any) {
+      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: any = Array.prototype;
+  if (!ap.add) ap.add = function (v: any) { this.push(v); };
+  if (!ap.addAll) ap.addAll = function (iter: any) {
+    for (const v of iter) this.push(v);
+  };
+  if (!ap.removeLast) ap.removeLast = function () { return this.pop(); };
+  if (!ap.removeAt) ap.removeAt = function (i: any) { return this.splice(i, 1)[0]; };
+  if (!ap.insert) ap.insert = function (i: any, v: any) { this.splice(i, 0, v); };
+  if (!ap.setAll) ap.setAll = function (idx: number, values: any[]) { 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: any) { return this.indexOf(v) >= 0; };
+  if (!ap.sublist) ap.sublist = function (start: any, end?: any) { return this.slice(start, end); };
+  if (!ap.asMap) ap.asMap = function () {
+    const m: any = {};
+    for (let i = 0; i < this.length; i++) m[i] = this[i];
+    return m;
+  };
+  if (!ap.expand) ap.expand = function (fn: any) { return this.flatMap(fn); };
+  if (!ap.take) ap.take = function (n: any) { return this.slice(0, n); };
+  if (!ap.skip) ap.skip = function (n: any) { return this.slice(n); };
+  if (!ap.any) ap.any = function (fn: any) { return this.some(fn); };
+  if (!ap.fold) ap.fold = function (init: any, fn: any) { return this.reduce(fn, init); };
+  if (!ap.followedBy) ap.followedBy = function (other: any) { return [...this, ...other]; };
+  if (!ap.getRange) ap.getRange = function (start: any, end: any) { return this.slice(start, end); };
+  if (!ap.fillRange) ap.fillRange = function (start: any, end: any, fill: any) {
+    for (let i = start; i < end; i++) this[i] = fill;
+  };
+  if (!ap.setRange) ap.setRange = function (start: any, end: any, iterable: any, skipCount?: any) {
+    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: any = Set.prototype;
+  if (!setp.contains) setp.contains = function (v: any) { return this.has(v); };
+  if (!setp.includes) setp.includes = function (v: any) { 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: any) { 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: any = 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: any) { return this.includes(s); };
+  if (!sp.replaceFirst) sp.replaceFirst = function (from: any, to: any) {
+    return this.replace(from instanceof RegExp ? from : String(from), to);
+  };
+  if (!sp.codeUnitAt) sp.codeUnitAt = function (i: any) { return this.charCodeAt(i); };
+  if (!sp.compareTo) sp.compareTo = function (other: any) {
+    return this < other ? -1 : this > other ? 1 : 0;
+  };
+  if (!sp.allMatches) sp.allMatches = function (pattern: any, start: any) {
+    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: any = RegExp.prototype;
+  if (!rp.firstMatch) rp.firstMatch = function (s: any) {
+    const m = this.exec(s);
+    if (m) m.group = (i: any) => m[i];
+    return m;
+  };
+  if (!rp.allMatches) rp.allMatches = function (s: any) {
+    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: any) { return this.test(s); };
+
+  // Dart Number polyfills — Dart num/int methods not on JS Number.prototype.
+  const _ballNp: any = Number.prototype;
+  if (!_ballNp.gcd) _ballNp.gcd = function (other: any) {
+    let a = Math.abs(this as number), 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: any, hi: any) { const n = Number(this); return n < lo ? lo : n > hi ? hi : n; };
+  if (!_ballNp.compareTo) _ballNp.compareTo = function (other: any) { const a = Number(this), b = Number(other); return a < b ? -1 : a > b ? 1 : 0; };
+  if (!_ballNp.toStringAsFixed) _ballNp.toStringAsFixed = function (digits: any) { return __ball_to_fixed(this, digits); };
+  if (!_ballNp.remainder) _ballNp.remainder = function (other: any) { return Number(this) % Number(other); };
+
+  // Object.prototype polyfills — used by the compiled engine when
+  // checking Ball program inputs (plain objects, not Maps).
+  const op2: any = Object.prototype;
+  if (!op2.containsKey) {
+    Object.defineProperty(op2, 'containsKey', {
+      configurable: true, writable: true, enumerable: false,
+      value: function (k: any) {
+        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: any, supplier: any) {
+        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: any) {
+        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: any) {
+      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: any) {
+        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]: any) => ({ 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: string, getter: () => any) {
+    Object.defineProperty(op2, name, {
+      configurable: true, enumerable: false,
+      get: getter,
+      set(v: any) {
+        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: any) =>
+    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 (this: any) {
+    if (this instanceof Map) return [..._nativeMapEntries.call(this)].map(([k, v]: any) => ({ 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]: any) => ({ key: k, value: v }));
+  });
+  defDartGetter('keys', function (this: any) {
+    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 (this: any) {
+    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 (this: any) {
+    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: string) => !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: any): any {
+  // _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: any): any {
+  // _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: any): any {
+  // _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: any, opName: string): any {
+  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',
+} as const;
+
+export class __BallValueWrapper {
+  private _raw: any;
+  constructor(raw: any) { this._raw = raw; }
+  whichKind(): string {
+    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(): string { return typeof this._raw === 'string' ? this._raw : String(this._raw ?? ''); }
+  get boolValue(): boolean { return !!this._raw; }
+  get numberValue(): number { return Number(this._raw); }
+  get nullValue(): null { return null; }
+  get listValue(): { values: __BallValueWrapper[] } {
+    const arr = Array.isArray(this._raw) ? this._raw : [];
+    return { values: arr.map((v: any) => new __BallValueWrapper(v)) };
+  }
+  get structValue(): { fields: Record<string, __BallValueWrapper> } {
+    const obj = (typeof this._raw === 'object' && this._raw !== null) ? this._raw : {};
+    const fields: Record<string, __BallValueWrapper> = {};
+    for (const [k, v] of Object.entries(obj)) fields[k] = new __BallValueWrapper(v);
+    return { fields };
+  }
+  // Also proxy hasXxx for sub-values.
+  hasNullValue(): boolean { return this._raw == null; }
+  hasStringValue(): boolean { return typeof this._raw === 'string'; }
+  hasBoolValue(): boolean { return typeof this._raw === 'boolean'; }
+  hasNumberValue(): boolean { return typeof this._raw === 'number'; }
+  hasListValue(): boolean { return Array.isArray(this._raw); }
+  hasStructValue(): boolean { return typeof this._raw === 'object' && this._raw !== null && !Array.isArray(this._raw); }
+  // Pass-through for when the wrapper is used in expressions.
+  toString(): string { return String(this._raw); }
+  valueOf(): any { 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',
+} as const;
+
+export const Literal_Value = {
+  intValue: 'intValue', doubleValue: 'doubleValue',
+  stringValue: 'stringValue', boolValue: 'boolValue',
+  listValue: 'listValue', bytesValue: 'bytesValue', notSet: 'notSet',
+} as const;
+
+export const Statement_Stmt = {
+  let: 'let', expression: 'expression', notSet: 'notSet',
+} as const;
+
+export const ModuleImport_Source = {
+  http: 'http', file: 'file', inline: 'inline',
+  git: 'git', registry: 'registry', notSet: 'notSet',
+} as const;
+
+// 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: any = Object.prototype;
+
+  function defMethod(name: string, fn: Function) {
+    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 (this: any) {
+    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 (this: any) {
+    for (const k of ['intValue','doubleValue','stringValue','boolValue','listValue','bytesValue']) {
+      if (this[k] !== undefined && this[k] !== null) return k;
+    }
+    return 'notSet';
+  });
+  defMethod('whichStmt', function (this: any) {
+    if (this['let'] !== undefined && this['let'] !== null) return 'let';
+    if (this['expression'] !== undefined && this['expression'] !== null) return 'expression';
+    return 'notSet';
+  });
+  defMethod('whichSource', function (this: any) {
+    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 (this: any) {
+      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: any) { this.field = v; },
+  });
+  // descriptor_ → descriptor (same issue)
+  Object.defineProperty(op, 'descriptor_', {
+    configurable: true, enumerable: false,
+    get() { return this.descriptor; },
+    set(v: any) { 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 (this: any) {
+    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 (this: any) {
+    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<T>(obj: T, args: string[]): T {
+  (obj as any).__type_args__ = args;
+  return obj;
+}
+
+// ── Generic type checking helper ────────────────────────────────────
+export function __ball_split_type_args(s: string): string[] {
+  const result: string[] = [];
+  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: any, typeStr: string): boolean {
+  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: any) => __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: string) => !k.startsWith('__')).every((k: string) => __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: any, i: number) => 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 {
+  readonly _epochMs: number;
+  readonly isUtc: boolean;
+  constructor(epochMs?: number, isUtc: boolean = false) {
+    this._epochMs = typeof epochMs === 'number' ? epochMs : Date.now();
+    this.isUtc = isUtc;
+  }
+  static now(): DateTime { return new DateTime(Date.now(), false); }
+  static fromMillisecondsSinceEpoch(ms: number, isUtc: any = false): DateTime {
+    return new DateTime(ms, isUtc === true || (isUtc && (isUtc as any).isUtc === true));
+  }
+  static parse(s: string): DateTime { return new DateTime(Date.parse(s), true); }
+  get millisecondsSinceEpoch(): number { return this._epochMs; }
+  get microsecondsSinceEpoch(): number { return this._epochMs * 1000; }
+  toUtc(): DateTime { return new DateTime(this._epochMs, true); }
+  toIso8601String(): string { return new Date(this._epochMs).toISOString(); }
+  get year(): number { return new Date(this._epochMs).getUTCFullYear(); }
+  get month(): number { return new Date(this._epochMs).getUTCMonth() + 1; }
+  get day(): number { return new Date(this._epochMs).getUTCDate(); }
+  get hour(): number { return new Date(this._epochMs).getUTCHours(); }
+  get minute(): number { return new Date(this._epochMs).getUTCMinutes(); }
+  get second(): number { return new Date(this._epochMs).getUTCSeconds(); }
+}
+export class Duration {
+  readonly _us: number;
+  constructor(opts?: any) {
+    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(): number { return Math.floor(this._us / 1000); }
+  get inMicroseconds(): number { return this._us; }
+}
+export const Future = {
+  delayed(d: any): Promise<void> {
+    const ms = (d && typeof d.inMilliseconds === 'number') ? d.inMilliseconds : Number(d ?? 0);
+    return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+  },
+  value(v: any): Promise<any> { 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: DataView;
+  _length: number;
+  constructor(size: number) {
+    this._view = new DataView(new ArrayBuffer(size));
+    this._length = size;
+  }
+  get lengthInBytes(): number { return this._length; }
+  getUint8(i: number): number { return this._view.getUint8(i); }
+  setUint8(i: number, v: number): void { this._view.setUint8(i, v); }
+  getInt8(i: number): number { return this._view.getInt8(i); }
+  setInt8(i: number, v: number): void { this._view.setInt8(i, v); }
+  getUint16(i: number, endian?: any): number { return this._view.getUint16(i, endian === Endian.little); }
+  setUint16(i: number, v: number, endian?: any): void { this._view.setUint16(i, v, endian === Endian.little); }
+  getInt16(i: number, endian?: any): number { return this._view.getInt16(i, endian === Endian.little); }
+  setInt16(i: number, v: number, endian?: any): void { this._view.setInt16(i, v, endian === Endian.little); }
+  getUint32(i: number, endian?: any): number { return this._view.getUint32(i, endian === Endian.little); }
+  setUint32(i: number, v: number, endian?: any): void { this._view.setUint32(i, v, endian === Endian.little); }
+  getInt32(i: number, endian?: any): number { return this._view.getInt32(i, endian === Endian.little); }
+  setInt32(i: number, v: number, endian?: any): void { this._view.setInt32(i, v, endian === Endian.little); }
+  getFloat32(i: number, endian?: any): number { return this._view.getFloat32(i, endian === Endian.little); }
+  setFloat32(i: number, v: number, endian?: any): void { this._view.setFloat32(i, v, endian === Endian.little); }
+  getFloat64(i: number, endian?: any): number { return this._view.getFloat64(i, endian === Endian.little); }
+  setFloat64(i: number, v: number, endian?: any): void { this._view.setFloat64(i, v, endian === Endian.little); }
+  getUint64(i: number, endian?: any): bigint {
+    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: number, v: bigint, endian?: any): void {
+    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: number, endian?: any): bigint {
+    const unsigned = this.getUint64(i, endian);
+    return unsigned >= 0x8000000000000000n ? unsigned - 0x10000000000000000n : unsigned;
+  }
+  setInt64(i: number, v: bigint, endian?: any): void {
+    this.setUint64(i, v < 0n ? v + 0x10000000000000000n : v, endian);
+  }
+  get buffer(): { asUint8List: (start?: number, length?: number) => number[] } {
+    const view = this._view;
+    return {
+      asUint8List: (start?: number, length?: number) => {
+        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: string): number[] { return [...new TextEncoder().encode(s)]; },
+  decode(bytes: any): string { return new TextDecoder().decode(new Uint8Array(bytes)); },
+};
+
+export function jsonEncode(obj: any): string { return JSON.stringify(obj); }
+export function jsonDecode(s: string): any { return JSON.parse(s); }
+
+
+export function __isUnknownFnError(e: any): boolean {
+  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: any): any {
+  const input = version;
+  return ('ball ' + __ball_to_string(version));
+}
+
+export function infoReport(program: any): any {
+  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: any): any {
+  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: any): any {
+  const input = program;
+  return (validationErrors(program).length === 0);
+}
+
+export function validateReport(program: any): any {
+  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: any): any {
+  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: any): any {
+  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: any): any {
+  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: any): any {
+  const input = functions;
+  for (const f of functions) {
+    if (!f.isBase) {
+      return false;
+    }
+  }
+  return true;
+}