@ball-lang/compiler 1.7.4 → 1.7.6

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

package/dist/preamble.js

@@ -994,14 +994,11 @@ function __ball_cascade(target: any, ops: any[]): any {
       },
     });
   }
-  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 }));
-  });
-  // .keys/.values on a non-Map must FAIL LOUD (throw a catchable error), not
-  // silently return [] — the silent-degradation class of bug that hid issue
-  // #55 (mirrors the fix already applied to the Dart/C++ compilers).
+  // .entries/.keys/.values on a non-Map must FAIL LOUD (throw a catchable
+  // error), not silently return [] — the silent-degradation class of bug
+  // that hid issue #55 (mirrors the fix already applied to the Dart/C++
+  // compilers). .entries used to be the odd one out here, silently
+  // returning [] instead of throwing — same bug family as #218.
   //
   // A getter installed on Object.prototype is invoked in "sloppy" (non-strict)
   // script contexts with this auto-boxed to a Number/String/Boolean WRAPPER
@@ -1014,6 +1011,13 @@ function __ball_cascade(target: any, ops: any[]): any {
     typeof v === 'object' && v !== null && !Array.isArray(v) &&
     !(v instanceof BallDouble) && !(v instanceof Set) &&
     !(v instanceof Number) && !(v instanceof String) && !(v instanceof Boolean);
+  defDartGetter('entries', function (this: any) {
+    if (this instanceof Map) return [..._nativeMapEntries.call(this)].map(([k, v]: any) => ({ key: k, value: v }));
+    if (!__isGenuineMap(this)) {
+      throw new Error('type \'' + __ball_to_string(this) + '\' has no .entries getter (not a Map)');
+    }
+    return Object.entries(this).map(([k, v]: any) => ({ key: k, value: v }));
+  });
   defDartGetter('keys', function (this: any) {
     if (this instanceof Map) return [..._nativeMapKeys.call(this)];
     if (!__isGenuineMap(this)) {
@@ -1076,6 +1080,60 @@ function __ball_cascade(target: any, ops: any[]): any {
   });
 })();
 
+// std.map_keys/std.map_values/std.map_entries (the base-function-call form,
+// as opposed to the .keys/.values/.entries DART-GETTER-STYLE property
+// access the defDartGetter block above already guards) must ALSO fail loud
+// on a non-Map receiver instead of silently returning [] — same "genuine
+// Map" check, exposed as top-level helpers so compileStdCall's emitted code
+// can call them (#218).
+function __ball_map_keys(m: any): any {
+  if (m instanceof Map) return [...m.keys()];
+  if (typeof m !== 'object' || m === null || Array.isArray(m) ||
+      m instanceof BallDouble || m instanceof Set ||
+      m instanceof Number || m instanceof String || m instanceof Boolean) {
+    throw new Error('type \'' + __ball_to_string(m) + '\' has no .keys getter (not a Map)');
+  }
+  return Object.keys(m);
+}
+function __ball_map_values(m: any): any {
+  if (m instanceof Map) return [...m.values()];
+  if (typeof m !== 'object' || m === null || Array.isArray(m) ||
+      m instanceof BallDouble || m instanceof Set ||
+      m instanceof Number || m instanceof String || m instanceof Boolean) {
+    throw new Error('type \'' + __ball_to_string(m) + '\' has no .values getter (not a Map)');
+  }
+  return Object.values(m);
+}
+function __ball_map_entries(m: any): any {
+  if (m instanceof Map) return [...m.entries()].map(([k, v]) => ({ key: k, value: v }));
+  if (typeof m !== 'object' || m === null || Array.isArray(m) ||
+      m instanceof BallDouble || m instanceof Set ||
+      m instanceof Number || m instanceof String || m instanceof Boolean) {
+    throw new Error('type \'' + __ball_to_string(m) + '\' has no .entries getter (not a Map)');
+  }
+  return Object.entries(m).map(([k, v]) => ({ key: k, value: v }));
+}
+
+// Shared guard for the REMAINING map_* base-function-call cases
+// (map_get/map_set/map_delete/map_merge/map_length/map_is_empty/
+// map_contains_key/map_contains_value/map_foreach) that used to route a
+// bare map[key], Object.keys/values(map), or key in map straight to the
+// receiver with no type check at all -- silently returning undefined,
+// no-opping, or checking array-index membership instead of throwing on a
+// non-Map (issue #55's silent-degradation class, same family as #218's
+// map_keys/map_values/map_entries). Returns the validated Map/plain-object
+// itself (not a boolean) so a call site can keep using it directly, e.g.
+// __ball_require_map(x, 'map_get')[key].
+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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAq7C5C,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA++C5C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ball-lang/compiler",
-  "version": "1.7.4",
+  "version": "1.7.6",
   "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,52 +4960,68 @@ 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": {
         const map = f.get("map") ?? f.get("value");
-        return map ? `Object.keys(${this.expr(map)})` : "[]";
+        // Fail loud on a non-Map receiver instead of silently returning [] —
+        // that silent degradation is the class of bug that hid issue #55
+        // (mirrors the .keys DART-GETTER guard already installed in
+        // preamble.ts's defDartGetter block, and the engine/C++-compiler
+        // guards for the same base function, #218).
+        return map ? `__ball_map_keys(${this.expr(map)})` : "[]";
       }
       case "map_values": {
         const map = f.get("map") ?? f.get("value");
-        return map ? `Object.values(${this.expr(map)})` : "[]";
+        return map ? `__ball_map_values(${this.expr(map)})` : "[]";
       }
       case "map_entries": {
         const map = f.get("map") ?? f.get("value");
-        return map ? `Object.entries(${this.expr(map)}).map(([k, v]) => ({key: k, value: v}))` : "[]";
+        // Same silent-degradation class as map_keys/map_values (#218): a
+        // bare Object.entries(...) on a non-Map silently returns garbage
+        // instead of failing loud.
+        return map ? `__ball_map_entries(${this.expr(map)})` : "[]";
       }
       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": {
@@ -5003,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");
@@ -5118,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")!)})`;
@@ -5146,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": {
@@ -5217,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

@@ -994,14 +994,11 @@ function __ball_cascade(target: any, ops: any[]): any {
       },
     });
   }
-  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 }));
-  });
-  // .keys/.values on a non-Map must FAIL LOUD (throw a catchable error), not
-  // silently return [] — the silent-degradation class of bug that hid issue
-  // #55 (mirrors the fix already applied to the Dart/C++ compilers).
+  // .entries/.keys/.values on a non-Map must FAIL LOUD (throw a catchable
+  // error), not silently return [] — the silent-degradation class of bug
+  // that hid issue #55 (mirrors the fix already applied to the Dart/C++
+  // compilers). .entries used to be the odd one out here, silently
+  // returning [] instead of throwing — same bug family as #218.
   //
   // A getter installed on Object.prototype is invoked in "sloppy" (non-strict)
   // script contexts with this auto-boxed to a Number/String/Boolean WRAPPER
@@ -1014,6 +1011,13 @@ function __ball_cascade(target: any, ops: any[]): any {
     typeof v === 'object' && v !== null && !Array.isArray(v) &&
     !(v instanceof BallDouble) && !(v instanceof Set) &&
     !(v instanceof Number) && !(v instanceof String) && !(v instanceof Boolean);
+  defDartGetter('entries', function (this: any) {
+    if (this instanceof Map) return [..._nativeMapEntries.call(this)].map(([k, v]: any) => ({ key: k, value: v }));
+    if (!__isGenuineMap(this)) {
+      throw new Error('type \'' + __ball_to_string(this) + '\' has no .entries getter (not a Map)');
+    }
+    return Object.entries(this).map(([k, v]: any) => ({ key: k, value: v }));
+  });
   defDartGetter('keys', function (this: any) {
     if (this instanceof Map) return [..._nativeMapKeys.call(this)];
     if (!__isGenuineMap(this)) {
@@ -1076,6 +1080,60 @@ function __ball_cascade(target: any, ops: any[]): any {
   });
 })();
 
+// std.map_keys/std.map_values/std.map_entries (the base-function-call form,
+// as opposed to the .keys/.values/.entries DART-GETTER-STYLE property
+// access the defDartGetter block above already guards) must ALSO fail loud
+// on a non-Map receiver instead of silently returning [] — same "genuine
+// Map" check, exposed as top-level helpers so compileStdCall's emitted code
+// can call them (#218).
+function __ball_map_keys(m: any): any {
+  if (m instanceof Map) return [...m.keys()];
+  if (typeof m !== 'object' || m === null || Array.isArray(m) ||
+      m instanceof BallDouble || m instanceof Set ||
+      m instanceof Number || m instanceof String || m instanceof Boolean) {
+    throw new Error('type \'' + __ball_to_string(m) + '\' has no .keys getter (not a Map)');
+  }
+  return Object.keys(m);
+}
+function __ball_map_values(m: any): any {
+  if (m instanceof Map) return [...m.values()];
+  if (typeof m !== 'object' || m === null || Array.isArray(m) ||
+      m instanceof BallDouble || m instanceof Set ||
+      m instanceof Number || m instanceof String || m instanceof Boolean) {
+    throw new Error('type \'' + __ball_to_string(m) + '\' has no .values getter (not a Map)');
+  }
+  return Object.values(m);
+}
+function __ball_map_entries(m: any): any {
+  if (m instanceof Map) return [...m.entries()].map(([k, v]) => ({ key: k, value: v }));
+  if (typeof m !== 'object' || m === null || Array.isArray(m) ||
+      m instanceof BallDouble || m instanceof Set ||
+      m instanceof Number || m instanceof String || m instanceof Boolean) {
+    throw new Error('type \'' + __ball_to_string(m) + '\' has no .entries getter (not a Map)');
+  }
+  return Object.entries(m).map(([k, v]) => ({ key: k, value: v }));
+}
+
+// Shared guard for the REMAINING map_* base-function-call cases
+// (map_get/map_set/map_delete/map_merge/map_length/map_is_empty/
+// map_contains_key/map_contains_value/map_foreach) that used to route a
+// bare map[key], Object.keys/values(map), or key in map straight to the
+// receiver with no type check at all -- silently returning undefined,
+// no-opping, or checking array-index membership instead of throwing on a
+// non-Map (issue #55's silent-degradation class, same family as #218's
+// map_keys/map_values/map_entries). Returns the validated Map/plain-object
+// itself (not a boolean) so a call site can keep using it directly, e.g.
+// __ball_require_map(x, 'map_get')[key].
+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