@ball-lang/compiler 1.7.5 → 1.7.7

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

package/dist/preamble.js

@@ -247,7 +247,11 @@ function __ball_to_string(v: any): string {
   }
   if (v instanceof Map) {
     const parts: string[] = [];
-    for (const [k, val] of v.entries()) {
+    // v.entries() as a method call would hit the Dart-property-style
+    // getter of the same name (installed further down in this file) and
+    // try to invoke its return value -- an array -- as a function.
+    // _nativeMapEntries is the real, un-shadowed method (issue #259).
+    for (const [k, val] of _nativeMapEntries.call(v)) {
       parts.push(__ball_to_string(k) + ': ' + __ball_to_string(val));
     }
     return '{' + parts.join(', ') + '}';
@@ -719,6 +723,21 @@ function __ball_cascade(target: any, ops: any[]): any {
 // ── Dart \u2192 JS method-name polyfills ────────────────────────────────
 //
 // Idempotent: guarded so multiple preamble inclusions don't double-install.
+
+// Native Map.prototype.entries/keys/values, captured BEFORE the
+// installBallPolyfills IIFE below shadows them with Dart-property-style
+// getters of the same name. Top-level (not IIFE-scoped) so every internal
+// call site that needs the REAL iterator method -- not the property-style
+// getter -- can reach it: the getters themselves (which must call the
+// original to avoid recursing into themselves), __ball_to_string's Map
+// printer, the Map-like constructor copy sites, and the map_keys/values/
+// entries base-function helpers (issue #259 -- calling .entries()/etc.
+// as a METHOD on a real Map after the shadow is installed throws, since
+// the getter's return value -- an array -- isn't itself callable).
+const _nativeMapEntries = Map.prototype.entries;
+const _nativeMapKeys = Map.prototype.keys;
+const _nativeMapValues = Map.prototype.values;
+
 (function installBallPolyfills() {
   const mp: any = Map.prototype;
   if (!mp.containsKey) mp.containsKey = function (k: any) { return this.has(k); };
@@ -731,7 +750,9 @@ function __ball_cascade(target: any, ops: any[]): any {
   if (!mp.addAll) {
     mp.addAll = function (other: any) {
       if (other instanceof Map) {
-        for (const [k, v] of other.entries()) this.set(k, v);
+        // _nativeMapEntries, not other.entries() -- see __ball_to_string's
+        // Map printer above for why (issue #259).
+        for (const [k, v] of _nativeMapEntries.call(other)) this.set(k, v);
       } else if (other && typeof other === 'object') {
         for (const k of Object.keys(other)) this.set(k, other[k]);
       }
@@ -908,7 +929,8 @@ function __ball_cascade(target: any, ops: any[]): any {
       value: function (other: any) {
         if (this instanceof Map) {
           if (other instanceof Map) {
-            for (const [k, v] of other.entries()) this.set(k, v);
+            // _nativeMapEntries, not other.entries() (issue #259).
+            for (const [k, v] of _nativeMapEntries.call(other)) this.set(k, v);
           } else if (other && typeof other === 'object') {
             for (const k of Object.keys(other)) this.set(k, other[k]);
           }
@@ -961,9 +983,9 @@ function __ball_cascade(target: any, ops: any[]): any {
   // JS Map has them as METHODS (need parens). The compiled engine
   // accesses map.entries as a getter. Shadow BOTH Map.prototype AND
   // Object.prototype so Map and plain-object dispatch tables work.
-  const _nativeMapEntries = Map.prototype.entries;
-  const _nativeMapKeys = Map.prototype.keys;
-  const _nativeMapValues = Map.prototype.values;
+  // (_nativeMapEntries/_nativeMapKeys/_nativeMapValues are captured at
+  // top level above, not here, so other call sites outside this IIFE
+  // can reach them too -- issue #259.)
   // Shadow Map.prototype.entries with a getter (Dart uses it as a getter).
   Object.defineProperty(Map.prototype, 'entries', {
     configurable: true, enumerable: false,
@@ -1087,7 +1109,10 @@ function __ball_cascade(target: any, ops: any[]): any {
 // Map" check, exposed as top-level helpers so compileStdCall's emitted code
 // can call them (#218).
 function __ball_map_keys(m: any): any {
-  if (m instanceof Map) return [...m.keys()];
+  // _nativeMapKeys, not m.keys() -- m.keys() would hit the Dart-property-
+  // style getter shadowing Map.prototype.keys and try to invoke its
+  // return value (an array) as a function (issue #259).
+  if (m instanceof Map) return [..._nativeMapKeys.call(m)];
   if (typeof m !== 'object' || m === null || Array.isArray(m) ||
       m instanceof BallDouble || m instanceof Set ||
       m instanceof Number || m instanceof String || m instanceof Boolean) {
@@ -1096,7 +1121,8 @@ function __ball_map_keys(m: any): any {
   return Object.keys(m);
 }
 function __ball_map_values(m: any): any {
-  if (m instanceof Map) return [...m.values()];
+  // _nativeMapValues, not m.values() (issue #259 -- see __ball_map_keys).
+  if (m instanceof Map) return [..._nativeMapValues.call(m)];
   if (typeof m !== 'object' || m === null || Array.isArray(m) ||
       m instanceof BallDouble || m instanceof Set ||
       m instanceof Number || m instanceof String || m instanceof Boolean) {
@@ -1105,7 +1131,8 @@ function __ball_map_values(m: any): any {
   return Object.values(m);
 }
 function __ball_map_entries(m: any): any {
-  if (m instanceof Map) return [...m.entries()].map(([k, v]) => ({ key: k, value: v }));
+  // _nativeMapEntries, not m.entries() (issue #259 -- see __ball_map_keys).
+  if (m instanceof Map) return [..._nativeMapEntries.call(m)].map(([k, v]) => ({ key: k, value: v }));
   if (typeof m !== 'object' || m === null || Array.isArray(m) ||
       m instanceof BallDouble || m instanceof Set ||
       m instanceof Number || m instanceof String || m instanceof Boolean) {
@@ -1114,6 +1141,26 @@ function __ball_map_entries(m: any): any {
   return Object.entries(m).map(([k, v]) => ({ key: k, value: v }));
 }
 
+// Shared guard for the REMAINING map_* base-function-call cases
+// (map_get/map_set/map_delete/map_merge/map_length/map_is_empty/
+// map_contains_key/map_contains_value/map_foreach) that used to route a
+// bare map[key], Object.keys/values(map), or key in map straight to the
+// receiver with no type check at all -- silently returning undefined,
+// no-opping, or checking array-index membership instead of throwing on a
+// non-Map (issue #55's silent-degradation class, same family as #218's
+// map_keys/map_values/map_entries). Returns the validated Map/plain-object
+// itself (not a boolean) so a call site can keep using it directly, e.g.
+// __ball_require_map(x, 'map_get')[key].
+function __ball_require_map(v: any, opName: string): any {
+  if (v instanceof Map) return v;
+  if (typeof v !== 'object' || v === null || Array.isArray(v) ||
+      v instanceof BallDouble || v instanceof Set ||
+      v instanceof Number || v instanceof String || v instanceof Boolean) {
+    throw new Error('type \'' + __ball_to_string(v) + '\' is not a Map (' + opName + ')');
+  }
+  return v;
+}
+
 // ── Protobuf Struct/Value compatibility ─────────────────────────
 //
 // Dart's protobuf runtime wraps google.protobuf.Struct as a class

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA29C5C,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0gD5C,CAAC"}

package/package.json

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

@@ -4570,7 +4570,14 @@ function __isUnknownFnError(e: any): boolean {
       case "null_aware_call": {
         const target = f.get("target");
         const method = f.get("method");
-        if (!target || !method) return "/* null_aware_call missing */";
+        // A bare `/* ... */` comment used to stand in for the missing
+        // field — context-dependent behavior (silently becomes `undefined`
+        // in return position, a hard-to-diagnose SyntaxError mid-expression)
+        // instead of a clear compile-time error naming the malformed call
+        // (#257).
+        if (!target || !method) {
+          throw new Error("TS compiler: null_aware_call requires a \"target\" and a \"method\" field");
+        }
         const methodName = method.literal?.stringValue ?? "";
         const inputFields = call.input?.messageCreation?.fields ?? [];
         const otherArgs = inputFields
@@ -4582,13 +4589,17 @@ function __isUnknownFnError(e: any): boolean {
       case "null_aware_index": {
         const self_ = f.get("self") ?? f.get("target");
         const idx = f.get("index") ?? f.get("key");
-        if (!self_ || !idx) return "/* null_aware_index missing */";
+        if (!self_ || !idx) {
+          throw new Error("TS compiler: null_aware_index requires a \"self\"/\"target\" and an \"index\"/\"key\" field");
+        }
         return `${this.expr(self_)}[${this.expr(idx)}]`;
       }
       case "null_aware_access": {
         const target = f.get("target");
         const fieldE = f.get("field");
-        if (!target || !fieldE) return "/* null_aware_access missing */";
+        if (!target || !fieldE) {
+          throw new Error("TS compiler: null_aware_access requires a \"target\" and a \"field\" field");
+        }
         return `${this.expr(target)}?.${fieldE.literal?.stringValue ?? ""}`;
       }
       case "typed_list": {
@@ -4607,13 +4618,19 @@ function __isUnknownFnError(e: any): boolean {
         if (entryExprs.length === 0) return "new Map()";
         const pairs: string[] = [];
         for (const e of entryExprs) {
-          if (e.messageCreation) {
-            const mc = e.messageCreation;
-            const mFields = mc.fields ?? [];
-            const k = mFields.find((fd) => fd.name === "key")?.value;
-            const v = mFields.find((fd) => fd.name === "value")?.value;
-            if (k && v) pairs.push(`[${this.expr(k)}, ${this.expr(v)}]`);
+          // A malformed entry (not a messageCreation, or missing key/value)
+          // used to be silently dropped from the resulting Map instead of
+          // surfaced — fail loud on the malformed IR instead (#257).
+          if (!e.messageCreation) {
+            throw new Error("TS compiler: typed_map entry is not a key/value messageCreation");
           }
+          const mFields = e.messageCreation.fields ?? [];
+          const k = mFields.find((fd) => fd.name === "key")?.value;
+          const v = mFields.find((fd) => fd.name === "value")?.value;
+          if (!k || !v) {
+            throw new Error("TS compiler: typed_map entry is missing \"key\" or \"value\"");
+          }
+          pairs.push(`[${this.expr(k)}, ${this.expr(v)}]`);
         }
         return `new Map([${pairs.join(", ")}])`;
       }
@@ -4943,20 +4960,26 @@ function __isUnknownFnError(e: any): boolean {
       case "map_get": {
         const map = f.get("map");
         const key = f.get("key");
-        if (map && key) return `${this.expr(map)}[${this.expr(key)}]`;
+        // __ball_require_map fails loud on a non-Map instead of silently
+        // returning undefined via bare bracket access (#257, same family
+        // as #218's map_keys/map_values/map_entries).
+        if (map && key) return `__ball_require_map(${this.expr(map)}, 'map_get')[${this.expr(key)}]`;
         return "undefined";
       }
       case "map_set": {
         const map = f.get("map");
         const key = f.get("key");
         const value = f.get("value");
-        if (map && key && value) return `(${this.expr(map)}[${this.expr(key)}] = ${this.expr(value)})`;
+        if (map && key && value) return `(__ball_require_map(${this.expr(map)}, 'map_set')[${this.expr(key)}] = ${this.expr(value)})`;
         return "undefined";
       }
       case "map_contains_key": {
         const map = f.get("map");
         const key = f.get("key");
-        if (map && key) return `(${this.expr(key)} in ${this.expr(map)})`;
+        // `in` throws for a primitive receiver already, but not for a List
+        // (checks index membership instead of throwing "not a map") — the
+        // require-map guard closes that gap (#257).
+        if (map && key) return `(${this.expr(key)} in __ball_require_map(${this.expr(map)}, 'map_contains_key'))`;
         return "false";
       }
       case "map_keys": {
@@ -4981,22 +5004,24 @@ function __isUnknownFnError(e: any): boolean {
       }
       case "map_length": {
         const map = f.get("map") ?? f.get("value");
-        return map ? `Object.keys(${this.expr(map)}).length` : "0";
+        return map ? `Object.keys(__ball_require_map(${this.expr(map)}, 'map_length')).length` : "0";
       }
       case "map_is_empty": {
         const map = f.get("map") ?? f.get("value");
-        return map ? `(Object.keys(${this.expr(map)}).length === 0)` : "true";
+        return map ? `(Object.keys(__ball_require_map(${this.expr(map)}, 'map_is_empty')).length === 0)` : "true";
       }
       case "map_delete": case "map_remove": {
         const map = f.get("map");
         const key = f.get("key");
-        if (map && key) return `(() => { const __m = ${this.expr(map)}; const __k = ${this.expr(key)}; const __v = __m[__k]; delete __m[__k]; return __v; })()`;
+        if (map && key) return `(() => { const __m = __ball_require_map(${this.expr(map)}, 'map_delete'); const __k = ${this.expr(key)}; const __v = __m[__k]; delete __m[__k]; return __v; })()`;
         return "undefined";
       }
       case "map_merge": {
         const l = f.get("left") ?? f.get("map");
         const r = f.get("right") ?? f.get("other");
-        if (l && r) return `{...${this.expr(l)}, ...${this.expr(r)}}`;
+        // Spreading a non-object silently produces {} (or a partial merge)
+        // instead of throwing — same class as the other map_* guards (#257).
+        if (l && r) return `{...__ball_require_map(${this.expr(l)}, 'map_merge'), ...__ball_require_map(${this.expr(r)}, 'map_merge')}`;
         return "{}";
       }
       case "map_from_entries": {
@@ -5011,13 +5036,20 @@ function __isUnknownFnError(e: any): boolean {
         if (list) return `${this.expr(list)}.join('')`;
         return "''";
       }
+      // Neither encoder ever emits these as a direct `std.<fn>` base-
+      // function call — a Set method call (mySet.union(other), etc.)
+      // routes through compileCall's generic "self"-field method dispatch
+      // onto native JS Set.prototype methods instead, so this case is
+      // never actually reached. The old fallback compiled it to a call on
+      // a nonexistent bare identifier (a confusing runtime ReferenceError
+      // if it WERE ever hit); fail loud at compile time instead, matching
+      // the policy above (#257).
       case "set_add": case "set_remove": case "set_contains":
       case "set_union": case "set_intersection": case "set_difference":
-      case "set_length": case "set_is_empty": case "set_to_list": {
-        const allFields = call.input?.messageCreation?.fields ?? [];
-        const args = allFields.map((fd) => this.expr(fd.value)).join(", ");
-        return `/* std.${fn} */ ${sanitize(fn)}(${args})`;
-      }
+      case "set_length": case "set_is_empty": case "set_to_list":
+        throw new Error(
+          `TS compiler: std.${fn} is not implemented (compileStdCall) — Set method calls should route through native JS Set methods, not this base function`,
+        );
       // I/O
       case "print_error": {
         const msg = f.get("message") ?? f.get("value");
@@ -5126,7 +5158,10 @@ function __isUnknownFnError(e: any): boolean {
           // match first and any duplicate entry here would be genuinely
           // unreachable dead code. Removed (#62 Phase-2c); only cases with
           // no outer-switch equivalent belong in this fallback.
-          case "map_contains_value": return `Object.values(${this.expr(f.get("map")!)}).includes(${this.expr(f.get("value")!)})`;
+          // Same silent-degradation class as map_keys/map_values/map_entries
+          // (#218) — the sibling case that fix missed, since it lives in
+          // this SECOND nested switch under a different function name (#257).
+          case "map_contains_value": return `Object.values(__ball_require_map(${this.expr(f.get("map")!)}, 'map_contains_value')).includes(${this.expr(f.get("value")!)})`;
           case "list_insert": return `(${this.expr(f.get("list")!)}.splice(${this.expr(f.get("index")!)}, 0, ${this.expr(f.get("value")!)}), ${this.expr(f.get("list")!)})`;
           case "list_remove_at": return `${this.expr(f.get("list")!)}.splice(${this.expr(f.get("index")!)}, 1)[0]`;
           case "list_clear": return `(${this.expr(f.get("list")!)}.length = 0, ${this.expr(f.get("list")!)})`;
@@ -5154,7 +5189,7 @@ function __isUnknownFnError(e: any): boolean {
           case "map_foreach": {
             const map = this.expr(f.get("map") ?? f.get("value")!);
             const cb = this.expr(f.get("function") ?? f.get("callback") ?? f.get("value")!);
-            return `Object.entries(${map}).forEach(([k, v]) => ${cb}(k, v))`;
+            return `Object.entries(__ball_require_map(${map}, 'map_foreach')).forEach(([k, v]) => ${cb}(k, v))`;
           }
           case "list_reversed": return `[...${this.expr(f.get("list")!)}].reverse()`;
           case "compare_to": {
@@ -5225,10 +5260,18 @@ function __isUnknownFnError(e: any): boolean {
             );
             return `(() => { const __r: any[] = []; ${body} return __r; })()`;
           }
-          default: {
-            const args = Array.from(f.values()).map((e) => this.expr(e)).join(", ");
-            return `/* std.${fn} */ ${sanitize(fn)}(${args})`;
-          }
+          default:
+            // Fail loud (repo CLAUDE.md): never emit a bare/undefined
+            // identifier for an unimplemented std function — mirrors
+            // compileMemoryCall's rule above. The old
+            // `/* std.${fn} */ ${sanitize(fn)}(${args})` fallback compiled
+            // to a call on a nonexistent identifier, deferring the failure
+            // to a confusing runtime ReferenceError instead of a clear
+            // compile-time error naming the actual unimplemented function
+            // (#257).
+            throw new Error(
+              `TS compiler: std.${fn} is not implemented (compileStdCall)`,
+            );
         }
       }
     }

package/src/preamble.ts

@@ -247,7 +247,11 @@ function __ball_to_string(v: any): string {
   }
   if (v instanceof Map) {
     const parts: string[] = [];
-    for (const [k, val] of v.entries()) {
+    // v.entries() as a method call would hit the Dart-property-style
+    // getter of the same name (installed further down in this file) and
+    // try to invoke its return value -- an array -- as a function.
+    // _nativeMapEntries is the real, un-shadowed method (issue #259).
+    for (const [k, val] of _nativeMapEntries.call(v)) {
       parts.push(__ball_to_string(k) + ': ' + __ball_to_string(val));
     }
     return '{' + parts.join(', ') + '}';
@@ -719,6 +723,21 @@ function __ball_cascade(target: any, ops: any[]): any {
 // ── Dart \u2192 JS method-name polyfills ────────────────────────────────
 //
 // Idempotent: guarded so multiple preamble inclusions don't double-install.
+
+// Native Map.prototype.entries/keys/values, captured BEFORE the
+// installBallPolyfills IIFE below shadows them with Dart-property-style
+// getters of the same name. Top-level (not IIFE-scoped) so every internal
+// call site that needs the REAL iterator method -- not the property-style
+// getter -- can reach it: the getters themselves (which must call the
+// original to avoid recursing into themselves), __ball_to_string's Map
+// printer, the Map-like constructor copy sites, and the map_keys/values/
+// entries base-function helpers (issue #259 -- calling .entries()/etc.
+// as a METHOD on a real Map after the shadow is installed throws, since
+// the getter's return value -- an array -- isn't itself callable).
+const _nativeMapEntries = Map.prototype.entries;
+const _nativeMapKeys = Map.prototype.keys;
+const _nativeMapValues = Map.prototype.values;
+
 (function installBallPolyfills() {
   const mp: any = Map.prototype;
   if (!mp.containsKey) mp.containsKey = function (k: any) { return this.has(k); };
@@ -731,7 +750,9 @@ function __ball_cascade(target: any, ops: any[]): any {
   if (!mp.addAll) {
     mp.addAll = function (other: any) {
       if (other instanceof Map) {
-        for (const [k, v] of other.entries()) this.set(k, v);
+        // _nativeMapEntries, not other.entries() -- see __ball_to_string's
+        // Map printer above for why (issue #259).
+        for (const [k, v] of _nativeMapEntries.call(other)) this.set(k, v);
       } else if (other && typeof other === 'object') {
         for (const k of Object.keys(other)) this.set(k, other[k]);
       }
@@ -908,7 +929,8 @@ function __ball_cascade(target: any, ops: any[]): any {
       value: function (other: any) {
         if (this instanceof Map) {
           if (other instanceof Map) {
-            for (const [k, v] of other.entries()) this.set(k, v);
+            // _nativeMapEntries, not other.entries() (issue #259).
+            for (const [k, v] of _nativeMapEntries.call(other)) this.set(k, v);
           } else if (other && typeof other === 'object') {
             for (const k of Object.keys(other)) this.set(k, other[k]);
           }
@@ -961,9 +983,9 @@ function __ball_cascade(target: any, ops: any[]): any {
   // JS Map has them as METHODS (need parens). The compiled engine
   // accesses map.entries as a getter. Shadow BOTH Map.prototype AND
   // Object.prototype so Map and plain-object dispatch tables work.
-  const _nativeMapEntries = Map.prototype.entries;
-  const _nativeMapKeys = Map.prototype.keys;
-  const _nativeMapValues = Map.prototype.values;
+  // (_nativeMapEntries/_nativeMapKeys/_nativeMapValues are captured at
+  // top level above, not here, so other call sites outside this IIFE
+  // can reach them too -- issue #259.)
   // Shadow Map.prototype.entries with a getter (Dart uses it as a getter).
   Object.defineProperty(Map.prototype, 'entries', {
     configurable: true, enumerable: false,
@@ -1087,7 +1109,10 @@ function __ball_cascade(target: any, ops: any[]): any {
 // Map" check, exposed as top-level helpers so compileStdCall's emitted code
 // can call them (#218).
 function __ball_map_keys(m: any): any {
-  if (m instanceof Map) return [...m.keys()];
+  // _nativeMapKeys, not m.keys() -- m.keys() would hit the Dart-property-
+  // style getter shadowing Map.prototype.keys and try to invoke its
+  // return value (an array) as a function (issue #259).
+  if (m instanceof Map) return [..._nativeMapKeys.call(m)];
   if (typeof m !== 'object' || m === null || Array.isArray(m) ||
       m instanceof BallDouble || m instanceof Set ||
       m instanceof Number || m instanceof String || m instanceof Boolean) {
@@ -1096,7 +1121,8 @@ function __ball_map_keys(m: any): any {
   return Object.keys(m);
 }
 function __ball_map_values(m: any): any {
-  if (m instanceof Map) return [...m.values()];
+  // _nativeMapValues, not m.values() (issue #259 -- see __ball_map_keys).
+  if (m instanceof Map) return [..._nativeMapValues.call(m)];
   if (typeof m !== 'object' || m === null || Array.isArray(m) ||
       m instanceof BallDouble || m instanceof Set ||
       m instanceof Number || m instanceof String || m instanceof Boolean) {
@@ -1105,7 +1131,8 @@ function __ball_map_values(m: any): any {
   return Object.values(m);
 }
 function __ball_map_entries(m: any): any {
-  if (m instanceof Map) return [...m.entries()].map(([k, v]) => ({ key: k, value: v }));
+  // _nativeMapEntries, not m.entries() (issue #259 -- see __ball_map_keys).
+  if (m instanceof Map) return [..._nativeMapEntries.call(m)].map(([k, v]) => ({ key: k, value: v }));
   if (typeof m !== 'object' || m === null || Array.isArray(m) ||
       m instanceof BallDouble || m instanceof Set ||
       m instanceof Number || m instanceof String || m instanceof Boolean) {
@@ -1114,6 +1141,26 @@ function __ball_map_entries(m: any): any {
   return Object.entries(m).map(([k, v]) => ({ key: k, value: v }));
 }
 
+// Shared guard for the REMAINING map_* base-function-call cases
+// (map_get/map_set/map_delete/map_merge/map_length/map_is_empty/
+// map_contains_key/map_contains_value/map_foreach) that used to route a
+// bare map[key], Object.keys/values(map), or key in map straight to the
+// receiver with no type check at all -- silently returning undefined,
+// no-opping, or checking array-index membership instead of throwing on a
+// non-Map (issue #55's silent-degradation class, same family as #218's
+// map_keys/map_values/map_entries). Returns the validated Map/plain-object
+// itself (not a boolean) so a call site can keep using it directly, e.g.
+// __ball_require_map(x, 'map_get')[key].
+function __ball_require_map(v: any, opName: string): any {
+  if (v instanceof Map) return v;
+  if (typeof v !== 'object' || v === null || Array.isArray(v) ||
+      v instanceof BallDouble || v instanceof Set ||
+      v instanceof Number || v instanceof String || v instanceof Boolean) {
+    throw new Error('type \'' + __ball_to_string(v) + '\' is not a Map (' + opName + ')');
+  }
+  return v;
+}
+
 // ── Protobuf Struct/Value compatibility ─────────────────────────
 //
 // Dart's protobuf runtime wraps google.protobuf.Struct as a class