@ball-lang/compiler 1.6.2 → 1.6.4

package/dist/preamble.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preamble.d.ts","sourceRoot":"","sources":["../src/preamble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,QAm3C/B,CAAC"}
+{"version":3,"file":"preamble.d.ts","sourceRoot":"","sources":["../src/preamble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,QA67C/B,CAAC"}

package/dist/preamble.js

@@ -110,7 +110,15 @@ class BallObject extends BallMap {
 // (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; }
+  // Collapse nested wrapping (new BallDouble(new BallDouble(x))) down to the
+  // innermost raw number instead of storing a BallDouble-holding-a-BallDouble.
+  // This can legitimately arise now that string_to_double's OWN compiled
+  // form already wraps its result (#222): the self-hosted engine's Dart
+  // source explicitly does BallDouble(double.parse(s)) to make the parse
+  // result double-preserving, which — once double.parse (string_to_double)
+  // started wrapping on its own — would otherwise double-wrap. Unwrapping
+  // here is idempotent for every other caller, since v is a plain number.
+  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); }
@@ -244,6 +252,13 @@ function __ball_to_string(v: any): string {
     }
     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__'])) {
@@ -296,10 +311,13 @@ function __ball_to_int(v: any): any {
   return t;
 }
 
-function __ball_parse_double(s: string): number {
+// Returns a BallDouble (not a bare number) so a whole-valued result (e.g.
+// double.parse('7.0')) still prints "7.0", not "7" — JS numbers erase the
+// int/double distinction that the wrapper exists to preserve (#67/#222).
+function __ball_parse_double(s: string): BallDouble {
   const n = parseFloat(s);
   if (Number.isNaN(n)) throw new Error('FormatException: ' + s);
-  return n;
+  return new BallDouble(n);
 }
 
 function __ball_double_to_string(n: number): string {
@@ -307,6 +325,16 @@ function __ball_double_to_string(n: number): string {
   return n.toString();
 }
 
+// num.toStringAsFixed(digits). JS Number.prototype.toFixed drops the sign of
+// -0 (returns "0.00" not "-0.00"); Dart's toStringAsFixed keeps it, matching
+// the -0 handling __ball_to_string/BallDouble.toString already do.
+function __ball_to_fixed(v: 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
@@ -350,31 +378,77 @@ function __ball_push_all(target: any, items: any): void {
 // 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;
+  // 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;
 }
 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);
 }
-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)); }
+// Fast-path guard: true when v is a plain (non-bigint, non-BallDouble)
+// integer within the signed 32-bit range. AND/OR/XOR/NOT never grow a
+// result past its operands' bit width, so when both operands fit in 32
+// bits, JS's native 32-bit bitwise operators give a result numerically
+// IDENTICAL to the full 64-bit BigInt path (sign-extending a 32-bit value
+// to 64 bits before AND/OR/XOR/NOT never changes the low 32 result bits,
+// and — verified across the full boundary range — never changes whether
+// the high bits are the correct sign-extension of them either). Left/right
+// shift are NOT given this fast path: shifting can grow a result past 32
+// bits even when the input operand fits (e.g. large_int << 40), so their
+// overflow behavior isn't safely 32-bit-local the way AND/OR/XOR/NOT is.
+function __fits32(v: any): boolean {
+  return typeof v === 'number' && Number.isInteger(v) && v >= -2147483648 && v <= 2147483647;
+}
+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));
+}
+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));
+}
+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));
+}
+function __ball_bitnot(a: any): any {
+  if (__fits32(a)) return ~a;
+  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)); }
 // Unsigned/logical shift: reinterpret a as an unsigned 64-bit value (add
 // 2^64 if negative) before shifting, so zeros fill from the left instead of
 // the sign bit — unlike >>> on raw JS numbers, which is only 32-bit.
 function __ball_ushr(a: any, b: any): any {
-  const unsigned = ((__to_bigint(a) % __I64_MOD) + __I64_MOD) % __I64_MOD;
+  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());
+};
 function __ball_negate(a: any): any {
   if (typeof a === 'bigint') return __i64_wrap(-a);
   if (a instanceof BallDouble) return new BallDouble(-a.value);
@@ -805,7 +879,7 @@ function __ball_cascade(target: any, ops: any[]): any {
   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.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

package/dist/preamble.js.map

@@ -1 +1 @@
-{"version":3,"file":"preamble.js","sourceRoot":"","sources":["../src/preamble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAm3C5C,CAAC"}
+{"version":3,"file":"preamble.js","sourceRoot":"","sources":["../src/preamble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA67C5C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ball-lang/compiler",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "description": "Ball → TypeScript compiler. Consumes a Ball protobuf Program and emits idiomatic TypeScript via ts-morph. The canonical TS compiler for Ball — lives in TS land so TS syntax knowledge doesn't leak into other languages.",
   "type": "module",
   "main": "dist/index.js",

package/src/compiler.ts

@@ -3100,7 +3100,16 @@ function __isUnknownFnError(e: any): boolean {
       const name = this.resolveVarName(rawName);
       // Track this declaration in the current scope.
       this.scopeDeclaredVars.add(name);
-      if (stmt.let.value !== undefined) {
+      // The encoder marks "no initializer" with a reference to the sentinel
+      // name __no_init__ (rather than omitting `value`) — e.g. `int? maybe;`.
+      // Left uncaught, this compiles to `let maybe = __no_init__;`, which
+      // resolves to the runtime preamble's OWN __no_init__ Symbol (used
+      // internally by the compiled self-hosted engine) instead of leaving
+      // `maybe` genuinely undefined, so a later `??=` never fires (#225).
+      // Mirrors the same check already applied to for-loop init bindings
+      // in renderForInit.
+      const isNoInit = stmt.let.value?.reference?.name === "__no_init__";
+      if (stmt.let.value !== undefined && !isNoInit) {
         this.writeln(`${kw} ${name} = ${this.expr(stmt.let.value)};`);
       } else {
         this.writeln(`${kw} ${name};`);
@@ -4592,7 +4601,17 @@ function __isUnknownFnError(e: any): boolean {
             } else if (fd.value) {
               elems.push(fd.value);
             }
-          } else if (fd.name !== "__type_args__" && fd.name !== "__const__") {
+          } else if (
+            // A `<T>{}` empty-typed-set-literal (e.g. `<int>{}`) carries its
+            // type argument as a field literally named "type_args" (the
+            // encoder's current single-word convention, NOT the older
+            // MessageCreation-level "__type_args__" cosmetic marker checked
+            // elsewhere in this file). Excluding only "__type_args__" left
+            // it falling through to this generic branch and being pushed in
+            // as a bogus set ELEMENT (`<int>{}` -> `new Set(['int'])`
+            // instead of an empty Set, #219).
+            fd.name !== "__type_args__" && fd.name !== "__const__" && fd.name !== "type_args"
+          ) {
             elems.push(fd.value);
           }
         }
@@ -5029,7 +5048,11 @@ function __isUnknownFnError(e: any): boolean {
       }
       // Type ops
       case "type_literal": {
-        const v = f.get("value") ?? f.get("name");
+        // The encoder's canonical field is "type" (matches the Dart compiler's
+        // _stringFieldValue(f, 'type')) — a type literal's stored value is
+        // Type.toString() (e.g. 'int', 'List<dynamic>'), so this just needs to
+        // evaluate to that string; == and interpolation follow for free.
+        const v = f.get("type") ?? f.get("value") ?? f.get("name");
         return v ? this.expr(v) : "null";
       }
       default: {
@@ -5099,7 +5122,7 @@ function __isUnknownFnError(e: any): boolean {
           case "to_string_as_fixed": {
             const v = this.expr(fg("value", "arg0")!);
             const d = this.expr(fg("digits", "arg1", "right")!);
-            return `(+(${v})).toFixed(${d})`;
+            return `__ball_to_fixed(${v}, ${d})`;
           }
           // num.{round,floor,ceil,truncate}ToDouble() → double (issue #100).
           // Wrap in BallDouble so a whole result renders `4.0`, not `4`.
@@ -6376,8 +6399,14 @@ function dartInitializerToTs(
     return defaultInitializer(tsType, rawDartType);
   }
   const s = dartInit.trim();
-  // Already a JS-compatible literal: string, number, bool, null, []
-  if (/^(?:null|true|false|'.*'|".*"|-?\d+(?:\.\d+)?|\[\])$/.test(s)) {
+  // Already a JS-compatible literal: string, number, bool, null, list.
+  // A non-empty Dart list literal (e.g. `[10, 20, 30]`) is valid JS array
+  // syntax as-is — this used to only match the EMPTY `[]` case, so a field
+  // like `var widgets = [10, 20, 30];` fell through to defaultInitializer
+  // (which has no type info to fall back on when the field's declared type
+  // was inferred rather than explicit) and silently dropped to no
+  // initializer at all, i.e. undefined/null (#220).
+  if (/^(?:null|true|false|'.*'|".*"|-?\d+(?:\.\d+)?|\[[\s\S]*\])$/.test(s)) {
     return s;
   }
   // Dart `{}` can mean either an empty Map or an empty Set depending

package/src/preamble.ts

@@ -110,7 +110,15 @@ class BallObject extends BallMap {
 // (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; }
+  // Collapse nested wrapping (new BallDouble(new BallDouble(x))) down to the
+  // innermost raw number instead of storing a BallDouble-holding-a-BallDouble.
+  // This can legitimately arise now that string_to_double's OWN compiled
+  // form already wraps its result (#222): the self-hosted engine's Dart
+  // source explicitly does BallDouble(double.parse(s)) to make the parse
+  // result double-preserving, which — once double.parse (string_to_double)
+  // started wrapping on its own — would otherwise double-wrap. Unwrapping
+  // here is idempotent for every other caller, since v is a plain number.
+  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); }
@@ -244,6 +252,13 @@ function __ball_to_string(v: any): string {
     }
     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__'])) {
@@ -296,10 +311,13 @@ function __ball_to_int(v: any): any {
   return t;
 }
 
-function __ball_parse_double(s: string): number {
+// Returns a BallDouble (not a bare number) so a whole-valued result (e.g.
+// double.parse('7.0')) still prints "7.0", not "7" — JS numbers erase the
+// int/double distinction that the wrapper exists to preserve (#67/#222).
+function __ball_parse_double(s: string): BallDouble {
   const n = parseFloat(s);
   if (Number.isNaN(n)) throw new Error('FormatException: ' + s);
-  return n;
+  return new BallDouble(n);
 }
 
 function __ball_double_to_string(n: number): string {
@@ -307,6 +325,16 @@ function __ball_double_to_string(n: number): string {
   return n.toString();
 }
 
+// num.toStringAsFixed(digits). JS Number.prototype.toFixed drops the sign of
+// -0 (returns "0.00" not "-0.00"); Dart's toStringAsFixed keeps it, matching
+// the -0 handling __ball_to_string/BallDouble.toString already do.
+function __ball_to_fixed(v: 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
@@ -350,31 +378,77 @@ function __ball_push_all(target: any, items: any): void {
 // 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;
+  // 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;
 }
 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);
 }
-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)); }
+// Fast-path guard: true when v is a plain (non-bigint, non-BallDouble)
+// integer within the signed 32-bit range. AND/OR/XOR/NOT never grow a
+// result past its operands' bit width, so when both operands fit in 32
+// bits, JS's native 32-bit bitwise operators give a result numerically
+// IDENTICAL to the full 64-bit BigInt path (sign-extending a 32-bit value
+// to 64 bits before AND/OR/XOR/NOT never changes the low 32 result bits,
+// and — verified across the full boundary range — never changes whether
+// the high bits are the correct sign-extension of them either). Left/right
+// shift are NOT given this fast path: shifting can grow a result past 32
+// bits even when the input operand fits (e.g. large_int << 40), so their
+// overflow behavior isn't safely 32-bit-local the way AND/OR/XOR/NOT is.
+function __fits32(v: any): boolean {
+  return typeof v === 'number' && Number.isInteger(v) && v >= -2147483648 && v <= 2147483647;
+}
+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));
+}
+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));
+}
+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));
+}
+function __ball_bitnot(a: any): any {
+  if (__fits32(a)) return ~a;
+  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)); }
 // Unsigned/logical shift: reinterpret a as an unsigned 64-bit value (add
 // 2^64 if negative) before shifting, so zeros fill from the left instead of
 // the sign bit — unlike >>> on raw JS numbers, which is only 32-bit.
 function __ball_ushr(a: any, b: any): any {
-  const unsigned = ((__to_bigint(a) % __I64_MOD) + __I64_MOD) % __I64_MOD;
+  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());
+};
 function __ball_negate(a: any): any {
   if (typeof a === 'bigint') return __i64_wrap(-a);
   if (a instanceof BallDouble) return new BallDouble(-a.value);
@@ -805,7 +879,7 @@ function __ball_cascade(target: any, ops: any[]): any {
   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.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