@ball-lang/compiler 0.1.0 → 1.3.5

package/src/preamble.ts

@@ -14,10 +14,178 @@
  */
 export const TS_RUNTIME_PREAMBLE = String.raw`// ── Ball runtime preamble (generated by @ball-lang/compiler) ────────
 
+// Base class for all Ball runtime values.
+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)
+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.
+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];
+      }
+    }
+  }
+}
+
+class BallList extends Array {
+  constructor(items?: any) {
+    super();
+    if (Array.isArray(items)) for (const it of items) this.push(it);
+  }
+}
+
+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.
+class BallDouble {
+  readonly value: number;
+  constructor(v: number) { this.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); }
+  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).
+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;
+}
+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;
+}
+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.
+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;
+}
+
 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';
@@ -33,6 +201,22 @@ function __ball_to_string(v: any): string {
     }
     return '{' + parts.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);
 }
 
@@ -44,6 +228,31 @@ function __ball_parse_int(s: string): number {
   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.
+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;
+}
+
 function __ball_parse_double(s: string): number {
   const n = parseFloat(s);
   if (Number.isNaN(n)) throw new Error('FormatException: ' + s);
@@ -55,9 +264,161 @@ function __ball_double_to_string(n: number): string {
   return n.toString();
 }
 
+// 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).
+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.
+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.
+const __I64_MAX = 9223372036854775807n;
+const __I64_MIN = -9223372036854775808n;
+const __I64_MOD = 18446744073709551616n;
+function __i64_wrap(v: bigint): any {
+  v = ((v % __I64_MOD) + __I64_MOD) % __I64_MOD;
+  if (v > __I64_MAX) v = v - __I64_MOD;
+  if (v >= -9007199254740991n && v <= 9007199254740991n) return Number(v);
+  return v;
+}
+function __to_bigint(v: any): bigint {
+  if (typeof v === 'bigint') return v;
+  if (v instanceof BallDouble) return BigInt(Math.trunc(v.value));
+  return BigInt(v);
+}
+function __ball_bitand(a: any, b: any): any { return __i64_wrap(__to_bigint(a) & __to_bigint(b)); }
+function __ball_bitor(a: any, b: any): any { return __i64_wrap(__to_bigint(a) | __to_bigint(b)); }
+function __ball_bitxor(a: any, b: any): any { return __i64_wrap(__to_bigint(a) ^ __to_bigint(b)); }
+function __ball_bitnot(a: any): any { return __i64_wrap(~__to_bigint(a)); }
+function __ball_shl(a: any, b: any): any { return __i64_wrap(__to_bigint(a) << __to_bigint(b)); }
+function __ball_shr(a: any, b: any): any { return __i64_wrap(__to_bigint(a) >> __to_bigint(b)); }
+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;
+}
+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);
+}
+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.
+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.
+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.
+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.
 let __ball_active_error: any = undefined;
 
+// Safe own-property lookup. Returns undefined if key is not an own property.
+// Avoids triggering Object.prototype getters (entries, keys, values) on
+// plain objects that aren't meant to be Dart Maps.
+function __ball_own(obj: any, key: any): any {
+  if (obj == null || typeof obj !== 'object') return undefined;
+  return Object.prototype.hasOwnProperty.call(obj, key) ? obj[key] : undefined;
+}
+
+// Dart-style index access. Dart's List '[]' operator throws RangeError on
+// out-of-bounds access, whereas JS array indexing silently returns undefined.
+// To make 'on RangeError' catch clauses behave like Dart we bounds-check list
+// (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.
+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).
 const int = {
@@ -84,6 +445,161 @@ const bool = {
 // late-initialized variables and block-scoped flow tracking.
 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.
+function __ball_spread_iter(v: any): any {
+  if (v == null || v === __no_init__) return [];
+  return v;
+}
+
+// Dart type constructor shims — List, Map, etc.
+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
+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.
+const _origScopeInit = { patched: false };
+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
+function _has(obj: any, field: string): boolean { return obj?.[field] !== undefined && obj?.[field] !== null; }
+function hasMetadata(obj: any): boolean { return _has(obj, 'metadata'); }
+function hasBody(obj: any): boolean { return _has(obj, 'body'); }
+function hasInput(obj: any): boolean { return _has(obj, 'input'); }
+function hasDescriptor(obj: any): boolean { return _has(obj, 'descriptor'); }
+function hasStringValue(obj: any): boolean { return _has(obj, 'stringValue'); }
+function hasBoolValue(obj: any): boolean { return _has(obj, 'boolValue'); }
+function hasNumberValue(obj: any): boolean { return _has(obj, 'numberValue'); }
+function hasResult(obj: any): boolean { return _has(obj, 'result'); }
+function hasCall(obj: any): boolean { return _has(obj, 'call'); }
+function hasListValue(obj: any): boolean { return _has(obj, 'listValue'); }
+function hasNullValue(obj: any): boolean { return _has(obj, 'nullValue'); }
+function hasStructValue(obj: any): boolean { return _has(obj, 'structValue'); }
+function hasMatch(obj: any): boolean { return _has(obj, 'match'); }
+function hasXxx(obj: any): boolean { return false; }
+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.
+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';
+}
+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';
+}
+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';
+}
+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';
+}
+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())
+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.
+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.
@@ -118,14 +634,39 @@ const __no_init__: unique symbol = Symbol('__no_init__');
     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); };
@@ -149,6 +690,9 @@ const __no_init__: unique symbol = Symbol('__no_init__');
   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) {
@@ -180,6 +724,37 @@ const __no_init__: unique symbol = Symbol('__no_init__');
   };
   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; },
+  });
+  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 Number(this).toFixed(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;
@@ -189,7 +764,7 @@ const __no_init__: unique symbol = Symbol('__no_init__');
       value: function (k: any) {
         if (this instanceof Map) return this.has(k);
         if (this == null || typeof this !== 'object') return false;
-        return k in this;
+        return Object.prototype.hasOwnProperty.call(this, k);
       },
     });
   }
@@ -207,6 +782,44 @@ const __no_init__: unique symbol = Symbol('__no_init__');
       },
     });
   }
+  // 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) {
+            for (const [k, v] of other.entries()) 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', {
@@ -217,6 +830,14 @@ const __no_init__: unique symbol = Symbol('__no_init__');
       },
     });
   }
+  // 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
@@ -240,41 +861,81 @@ const __no_init__: unique symbol = Symbol('__no_init__');
     get() { return [..._nativeMapValues.call(this)]; },
   });
   // For plain objects — same getters on Object.prototype.
-  Object.defineProperty(op2, 'entries', {
+  // 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,
+        });
+      },
+    });
+  }
+  defDartGetter('entries', function (this: any) {
+    if (this instanceof Map) return [..._nativeMapEntries.call(this)].map(([k, v]: any) => ({ key: k, value: v }));
+    if (this == null || typeof this !== 'object') return [];
+    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 (this == null || typeof this !== 'object') return [];
+    return Object.keys(this);
+  });
+  defDartGetter('values', function (this: any) {
+    if (this instanceof Map) return [..._nativeMapValues.call(this)];
+    if (this == null || typeof this !== 'object') return [];
+    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 instanceof Map) return [..._nativeMapEntries.call(this)].map(([k, v]: any) => ({ key: k, value: v }));
-      if (this == null || typeof this !== 'object') return [];
-      return Object.entries(this).map(([k, v]: any) => ({ key: k, value: v }));
+      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';
     },
   });
-  Object.defineProperty(op2, 'keys', {
+  // 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() {
-      if (this instanceof Map) return [..._nativeMapKeys.call(this)];
-      if (this == null || typeof this !== 'object') return [];
-      return Object.keys(this);
-    },
+    get() { return Number.isInteger(+this) ? 'int' : 'double'; },
   });
-  Object.defineProperty(op2, 'values', {
+  Object.defineProperty(String.prototype, 'runtimeType', {
     configurable: true, enumerable: false,
-    get() {
-      if (this instanceof Map) return [..._nativeMapValues.call(this)];
-      if (this == null || typeof this !== 'object') return [];
-      return Object.values(this);
-    },
+    get() { return 'String'; },
+  });
+  Object.defineProperty(Boolean.prototype, 'runtimeType', {
+    configurable: true, enumerable: false,
+    get() { return 'bool'; },
   });
-
-  // Number polyfills for Dart-style methods.
-  const np: any = Number.prototype;
-  if (!np.toInt) np.toInt = function () { return Math.trunc(this); };
-  if (!np.toDouble) np.toDouble = function () { return this + 0.0; };
-  if (!np.compareTo) np.compareTo = function (other: any) {
-    return this < other ? -1 : this > other ? 1 : 0;
-  };
-  if (!np.clamp) np.clamp = function (lo: any, hi: any) {
-    return Math.min(Math.max(this, lo), hi);
-  };
 })();
 
 // ── Protobuf Struct/Value compatibility ─────────────────────────
@@ -470,4 +1131,208 @@ const ModuleImport_Source = {
     return [];
   });
 })();
+
+// ── Reified generics helpers ────────────────────────────────────────
+function __ball_with_type_args<T>(obj: T, args: string[]): T {
+  (obj as any).__type_args__ = args;
+  return obj;
+}
+
+// ── Generic type checking helper ────────────────────────────────────
+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;
+}
+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.
+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(); }
+}
+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; }
+}
+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.
+const Endian = { little: true, big: false, host: true };
+
+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.
+const utf8 = {
+  encode(s: string): number[] { return [...new TextEncoder().encode(s)]; },
+  decode(bytes: any): string { return new TextDecoder().decode(new Uint8Array(bytes)); },
+};
+
+function jsonEncode(obj: any): string { return JSON.stringify(obj); }
+function jsonDecode(s: string): any { return JSON.parse(s); }
 `;