@ball-lang/compiler 1.5.4 → 1.5.5

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,QA2yC/B,CAAC"}
+{"version":3,"file":"preamble.d.ts","sourceRoot":"","sources":["../src/preamble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,QAk1C/B,CAAC"}

package/dist/preamble.js

@@ -133,8 +133,14 @@ class 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).
 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 (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;
@@ -142,7 +148,7 @@ function __ball_mul(a: any, b: any): any {
   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 (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;
@@ -150,7 +156,7 @@ function __ball_add(a: any, b: any): any {
   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 (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;
@@ -160,7 +166,7 @@ function __ball_sub(a: any, b: any): any {
 
 // 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 (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);
@@ -178,6 +184,39 @@ function __ball_eq(a: any, b: any): boolean {
   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.
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+
 function __ball_to_string(v: any): string {
   if (v === null || v === undefined) return 'null';
   if (typeof v === 'bigint') return v.toString();

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2yC5C,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAk1C5C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ball-lang/compiler",
-  "version": "1.5.4",
+  "version": "1.5.5",
   "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

@@ -4245,10 +4245,13 @@ function __isUnknownFnError(e: any): boolean {
         if (l && r) return `!__ball_eq(${this.expr(l)}, ${this.expr(r)})`;
         return `!__ball_eq(${this.expr(fg("left", "value", "arg0")!)}, ${this.expr(fg("right", "other", "arg1")!)})`;
       }
-      case "less_than":    return bin("<");
-      case "greater_than": return bin(">");
-      case "lte":          return bin("<=");
-      case "gte":          return bin(">=");
+      // Relational comparisons route through __ball_lt/__ball_gt/__ball_le/__ball_ge
+      // so operator-overloaded types (e.g. a class defining `<`) dispatch to
+      // their `__op_lt__`-style method instead of raw JS comparison (#205).
+      case "less_than":    return `__ball_lt(${this.expr(fg("left", "value", "arg0")!)}, ${this.expr(fg("right", "other", "arg1")!)})`;
+      case "greater_than": return `__ball_gt(${this.expr(fg("left", "value", "arg0")!)}, ${this.expr(fg("right", "other", "arg1")!)})`;
+      case "lte":          return `__ball_le(${this.expr(fg("left", "value", "arg0")!)}, ${this.expr(fg("right", "other", "arg1")!)})`;
+      case "gte":          return `__ball_ge(${this.expr(fg("left", "value", "arg0")!)}, ${this.expr(fg("right", "other", "arg1")!)})`;
       // Logical
       case "and":          return bin("&&");
       case "or":           return bin("||");
@@ -5870,6 +5873,12 @@ const KNOWN_PATTERN_KINDS = new Set([
   "ConstPattern", "VarPattern", "var", "WildcardPattern", "wildcard", "_",
   "ListPattern", "RestPattern", "rest", "record", "RecordPattern",
   "LogicalOrPattern", "CastPattern", "NullCheckPattern", "NullAssertPattern",
+  // MapPattern/LogicalAndPattern/ObjectPattern/RelationalPattern were missing
+  // (#206, #207) — every pattern kind the encoder can emit (see
+  // dart/encoder/lib/encoder.dart's `_encodePattern`) must be listed here, or
+  // it falls to the legacy cosmetic-text parser, which cannot round-trip
+  // `final`-bound entries and other structured shapes.
+  "MapPattern", "LogicalAndPattern", "ObjectPattern", "RelationalPattern",
 ]);
 
 /** Generate a JS type-check condition for a Dart type name against `subject`.
@@ -5960,6 +5969,102 @@ function compileStructuredPattern(
       }
       return undefined;
     }
+    case "LogicalAndPattern": {
+      // `p1 && p2` matches only if BOTH alternatives match against the SAME
+      // subject (Dart's guard-combinator syntax, e.g. `int n && > 0`). Mirrors
+      // LogicalOrPattern but ANDs the conditions instead of ORing them; bindings
+      // from both sides are unioned (in practice the right operand of a
+      // relational combinator binds nothing). Falls through (undefined) if
+      // either operand isn't structured.
+      const left = fields.get("left");
+      const right = fields.get("right");
+      if (left && right) {
+        const lr = compileStructuredPattern(left, subject, exprFn);
+        const rr = compileStructuredPattern(right, subject, exprFn);
+        if (lr && rr) {
+          return {
+            condition: `(${lr.condition} && ${rr.condition})`,
+            bindings: [...lr.bindings, ...rr.bindings],
+          };
+        }
+      }
+      return undefined;
+    }
+    case "RelationalPattern": {
+      // `== x` / `!= x` / `> x` / `< x` / `>= x` / `<= x` as a standalone
+      // (or LogicalAndPattern-combined) pattern. Numeric comparisons require
+      // BOTH the subject and operand to be `num` (mirrors engine_std.dart's
+      // `_matchRelationalPattern`) — a non-numeric subject simply fails to
+      // match rather than throwing.
+      const op = fields.get("operator")?.literal?.stringValue;
+      const operandExpr = fields.get("operand");
+      if (!op || !operandExpr) return { condition: "true", bindings: [] };
+      const operandStr = exprFn(operandExpr);
+      if (op === "==") return { condition: `__ball_eq(${subject}, ${operandStr})`, bindings: [] };
+      if (op === "!=") return { condition: `(!__ball_eq(${subject}, ${operandStr}))`, bindings: [] };
+      const isNum = (v: string) => `(typeof (${v}) === 'number' || (${v}) instanceof BallDouble)`;
+      const numVal = (v: string) => `((${v}) instanceof BallDouble ? (${v}).value : (${v}))`;
+      return {
+        condition: `(${isNum(subject)} && ${isNum(operandStr)} && (${numVal(subject)} ${op} ${numVal(operandStr)}))`,
+        bindings: [],
+      };
+    }
+    case "MapPattern": {
+      // `{'key': subpattern, ...}`. Ball maps compile to a plain JS object for
+      // the common `map_create` path (bracket access, e.g. `{'k': 7}`) but to a
+      // native `Map` for the `typed_map` path (`<K,V>{}` / `Map()`) — both
+      // representations must match. A Ball Set compiles to a native `Set`
+      // (set_create), which IS `typeof 'object'` and not an array, so it must
+      // be explicitly excluded (issue #178's "MapPattern must exclude Set").
+      // Extra keys beyond the ones listed are fine (unlike RecordPattern's
+      // exact-arity rule) — mirrors engine_std.dart's 'map' case.
+      const entries = fields.get("entries")?.literal?.listValue?.elements ?? [];
+      const conds: string[] = [
+        `(typeof ${subject} === 'object' && ${subject} !== null && !Array.isArray(${subject}) && !(${subject} instanceof Set))`,
+      ];
+      const binds: Array<{ varName: string; expr: string }> = [];
+      for (const entry of entries) {
+        const ef = mcFields(entry);
+        const keyExpr = ef.get("key");
+        const valuePattern = ef.get("value");
+        if (!keyExpr) continue;
+        const keyStr = exprFn(keyExpr);
+        conds.push(`(${subject} instanceof Map ? ${subject}.has(${keyStr}) : (${keyStr} in ${subject}))`);
+        if (valuePattern) {
+          const valueExpr = `(${subject} instanceof Map ? ${subject}.get(${keyStr}) : ${subject}[${keyStr}])`;
+          const sub = compileStructuredPattern(valuePattern, valueExpr, exprFn);
+          if (sub) {
+            if (sub.condition !== "true") conds.push(sub.condition);
+            binds.push(...sub.bindings);
+          }
+        }
+      }
+      return { condition: conds.join(" && "), bindings: binds };
+    }
+    case "ObjectPattern": {
+      // `Type(field: subpattern, ...)` matches by TYPE (reusing the same
+      // instanceof/`__type__` gate CastPattern relies on via typeCheckCondition)
+      // plus each named field's GETTER against its sub-pattern — field access,
+      // not positional arity (mirrors engine_std.dart's 'object' case, which
+      // reads `objMap[fieldName]` rather than requiring an exact key set).
+      const typeName = fields.get("type")?.literal?.stringValue;
+      const objFields = fields.get("fields")?.literal?.listValue?.elements ?? [];
+      const conds: string[] = [];
+      if (typeName) conds.push(typeCheckCondition(typeName, subject));
+      const binds: Array<{ varName: string; expr: string }> = [];
+      for (const of_ of objFields) {
+        const ofFields = mcFields(of_);
+        const fieldName = ofFields.get("name")?.literal?.stringValue;
+        const fieldPattern = ofFields.get("pattern");
+        if (!fieldName || !fieldPattern) continue;
+        const sub = compileStructuredPattern(fieldPattern, `${subject}.${fieldName}`, exprFn);
+        if (sub) {
+          if (sub.condition !== "true") conds.push(sub.condition);
+          binds.push(...sub.bindings);
+        }
+      }
+      return { condition: conds.length > 0 ? conds.join(" && ") : "true", bindings: binds };
+    }
     case "CastPattern": {
       // A cast pattern (subpat as T) ASSERTS the runtime type — it matches
       // structurally (like its sub-pattern) but THROWS on a mismatch (Dart

package/src/preamble.ts

@@ -133,8 +133,14 @@ class 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).
 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 (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;
@@ -142,7 +148,7 @@ function __ball_mul(a: any, b: any): any {
   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 (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;
@@ -150,7 +156,7 @@ function __ball_add(a: any, b: any): any {
   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 (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;
@@ -160,7 +166,7 @@ function __ball_sub(a: any, b: any): any {
 
 // 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 (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);
@@ -178,6 +184,39 @@ function __ball_eq(a: any, b: any): boolean {
   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.
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+
 function __ball_to_string(v: any): string {
   if (v === null || v === undefined) return 'null';
   if (typeof v === 'bigint') return v.toString();