@tishlang/tish-lsp 2.39.0 → 2.43.8

package/crates/tish_builtins/src/collections.rs

@@ -23,9 +23,13 @@
 //! - Keys/values use **SameValueZero** equality (NaN equals NaN; `+0`/`-0` are the same; objects by
 //!   identity).
 
-use std::any::Any;
-use std::hash::{Hash, Hasher};
-use std::sync::Arc;
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+
+use core::any::Any;
+use core::hash::{Hash, Hasher};
+use tishlang_core::Arc;
 
 use indexmap::IndexMap;
 use tishlang_core::{NativeFn, ObjectMap, TishOpaque, Value, VmRef};
@@ -120,7 +124,7 @@ impl indexmap::Equivalent<Key> for KeyRef<'_> {
 /// stores `Value::Null` values and iterates its keys; a `Map` stores the mapped value. Uses `ahash`
 /// (the same fast hasher `tish_core`'s `PropMap` uses) rather than the default SipHash — iteration
 /// order is insertion order regardless of the hasher, so this is a pure constant-factor speedup.
-type Store = VmRef<IndexMap<Key, Value, ahash::RandomState>>;
+type Store = VmRef<IndexMap<Key, Value, tishlang_core::RandomState>>;
 
 /// Opaque whose length reports a collection's live element count. Stored under [`SIZE_SLOT`] on every
 /// `Set`/`Map` instance.
@@ -226,7 +230,7 @@ fn same_value_zero(a: &Value, b: &Value) -> bool {
 fn iter_elements(v: &Value) -> Vec<Value> {
     match v {
         Value::Array(a) => a.borrow().iter().cloned().collect(),
-        Value::NumberArray(a) => a.borrow().iter().map(|n| Value::Number(*n)).collect(),
+        Value::NumberArray(a) => a.borrow().to_values(),
         _ => Vec::new(),
     }
 }

package/crates/tish_builtins/src/construct.rs

@@ -1,7 +1,13 @@
 //! `new` lowering for non-JS targets: `construct(callee, args)` approximates JS `[[Construct]]`.
 //! Browser-exact behavior remains on `tish build --target js`.
 
-use std::sync::Arc;
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+#[cfg(feature = "portable")]
+use tishlang_core::FloatExt;
+
+use tishlang_core::Arc;
 use tishlang_core::{ObjectMap, Value, VmRef};
 
 const CONSTRUCT: &str = "__construct";

package/crates/tish_builtins/src/date.rs

@@ -11,7 +11,13 @@
 //! is no timezone database in the core builtins (keeps them lean + wasm-friendly). `getTime`,
 //! `valueOf`, the `getUTC*` family and `toISOString` are therefore fully deterministic everywhere.
 
-use std::sync::Arc;
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+#[cfg(feature = "portable")]
+use tishlang_core::FloatExt;
+
+use tishlang_core::Arc;
 use tishlang_core::{ObjectMap, Value, VmRef};
 
 const CONSTRUCT: &str = "__construct";
@@ -23,6 +29,7 @@ const MONTHS: [&str; 12] = [
 ];
 
 /// Current wall-clock time as epoch milliseconds.
+#[cfg(not(feature = "portable"))]
 fn now_ms() -> f64 {
     std::time::SystemTime::now()
         .duration_since(std::time::UNIX_EPOCH)
@@ -30,6 +37,13 @@ fn now_ms() -> f64 {
         .unwrap_or(0.0)
 }
 
+/// No OS clock on GBA: read the runtime-installed clock hook (defaults to 0 until
+/// the facade wires up an agb timer). See `tishlang_core::install_clock`.
+#[cfg(feature = "portable")]
+fn now_ms() -> f64 {
+    tishlang_core::now_ms()
+}
+
 /// A `(method name, field extractor)` pair for the numeric `Date` getters. The explicit
 /// `fn(&Civil) -> i64` coerces the (non-capturing) extractor closures to a single fn-pointer type so
 /// they can live in one array.

package/crates/tish_builtins/src/globals.rs

@@ -3,7 +3,13 @@
 //! Used by both tishlang_vm (bytecode) and tishlang_runtime (compiled). Keeps tishlang_vm
 //! independent of tishlang_runtime.
 
-use std::sync::Arc;
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+#[cfg(feature = "portable")]
+use tishlang_core::FloatExt;
+
+use tishlang_core::Arc;
 use tishlang_core::VmRef;
 use tishlang_core::{percent_decode, percent_decode_component, percent_encode, percent_encode_component, ObjectMap, Value};
 
@@ -79,7 +85,7 @@ pub fn array_from(args: &[Value]) -> Value {
     let source = args.first().cloned().unwrap_or(Value::Null);
     let items: Vec<Value> = match &source {
         Value::Array(a) => a.borrow().clone(),
-        Value::NumberArray(a) => a.borrow().iter().map(|n| Value::Number(*n)).collect(),
+        Value::NumberArray(a) => a.borrow().to_values(),
         // `drain_iterator` covers String (chars), Set/Map, and any iterator object.
         other => {
             if let Some(d) = tishlang_core::drain_iterator(other) {
@@ -296,6 +302,25 @@ pub fn string_from_char_code(args: &[Value]) -> Value {
     Value::String(s.into())
 }
 
+/// Object.freeze(obj) — mark the object frozen so later property writes throw a catchable
+/// TypeError (#437). Returns the same object; non-objects pass through unchanged (JS semantics).
+pub fn object_freeze(args: &[Value]) -> Value {
+    if let Some(Value::Object(obj)) = args.first() {
+        obj.borrow_mut().frozen = true;
+    }
+    args.first().cloned().unwrap_or(Value::Null)
+}
+
+/// Object.isFrozen(obj) — true if the object was frozen. Primitives are considered frozen (JS).
+pub fn object_is_frozen(args: &[Value]) -> Value {
+    match args.first() {
+        Some(Value::Object(obj)) => Value::Bool(obj.borrow().frozen),
+        // Arrays are mutable and not freezable in this slice → not frozen; other primitives are.
+        Some(Value::Array(_)) => Value::Bool(false),
+        _ => Value::Bool(true),
+    }
+}
+
 /// Object.keys(obj)
 pub fn object_keys(args: &[Value]) -> Value {
     match args.first() {
@@ -319,6 +344,16 @@ pub fn object_keys(args: &[Value]) -> Value {
                 .collect();
             Value::Array(VmRef::new(keys))
         }
+        // A packed `NumberArray` has the same own enumerable keys (its index strings) — without
+        // this, `for (k in arr)` (lowered to `for-of Object.keys`) enumerated NOTHING under
+        // TISH_PACKED_ARRAYS=1. Mirrors the Array arm.
+        Some(Value::NumberArray(arr)) => {
+            let len = arr.borrow().len();
+            let keys: Vec<Value> = (0..len)
+                .map(|i| Value::String(tishlang_core::ArcStr::from(i.to_string().as_str())))
+                .collect();
+            Value::Array(VmRef::new(keys))
+        }
         _ => Value::Array(VmRef::new(Vec::new())),
     }
 }
@@ -495,7 +530,7 @@ pub fn js_parse_float(s: &str) -> f64 {
 pub fn object_from_entries(args: &[Value]) -> Value {
     if let Some(Value::Array(entries)) = args.first() {
         let entries_borrow = entries.borrow();
-        let mut obj: ObjectMap = ObjectMap::with_capacity(entries_borrow.len());
+        let mut obj: ObjectMap = ObjectMap::with_capacity_and_hasher(entries_borrow.len(), Default::default());
 
         for entry in entries_borrow.iter() {
             if let Value::Array(pair) = entry {

package/crates/tish_builtins/src/helpers.rs

@@ -1,6 +1,10 @@
 //! Common helper functions used across builtin implementations.
 
-use std::sync::Arc;
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+
+use tishlang_core::Arc;
 use tishlang_core::{ObjectMap, Value};
 
 /// Normalize an array index, handling negative indices.
@@ -20,8 +24,8 @@ pub fn normalize_index(idx: &Value, len: i64, default: usize) -> usize {
 }
 
 /// Create an error object with a single "error" field.
-pub fn make_error_value(e: impl std::fmt::Display) -> Value {
-    let mut obj = ObjectMap::with_capacity(1);
+pub fn make_error_value(e: impl core::fmt::Display) -> Value {
+    let mut obj = ObjectMap::with_capacity_and_hasher(1, Default::default());
     obj.insert(Arc::from("error"), Value::String(e.to_string().into()));
     Value::object(obj)
 }

package/crates/tish_builtins/src/iterator.rs

@@ -12,7 +12,11 @@
 //! array-returning version behaved; mid-iteration mutation of the source is not reflected (a
 //! live iterator is a follow-up).
 
-use std::sync::Arc;
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+
+use tishlang_core::Arc;
 
 use tishlang_core::{ObjectMap, Value, VmRef};
 

package/crates/tish_builtins/src/lib.rs

@@ -3,6 +3,9 @@
 //! Used by the compiled runtime (tishlang_runtime) and bytecode VM (tishlang_vm). The
 //! interpreter (tishlang_eval) implements builtins inline due to different Value
 //! and native signatures.
+#![cfg_attr(feature = "portable", no_std)]
+
+extern crate alloc;
 
 pub mod array;
 pub mod collections;

package/crates/tish_builtins/src/math.rs

@@ -1,5 +1,11 @@
 //! Math builtin functions.
 
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+#[cfg(feature = "portable")]
+use tishlang_core::FloatExt;
+
 use crate::helpers::extract_num;
 use tishlang_core::{to_int32, to_uint32, Value};
 
@@ -120,10 +126,18 @@ pub fn pow(args: &[Value]) -> Value {
     Value::Number(base.powf(exp))
 }
 
+#[cfg(not(feature = "portable"))]
 pub fn random(_args: &[Value]) -> Value {
     Value::Number(rand::random::<f64>())
 }
 
+/// No OS entropy on GBA: read the runtime-installed RNG hook (a seedable xorshift
+/// fallback until the facade wires up `agb::rng`). See `tishlang_core::install_rng`.
+#[cfg(feature = "portable")]
+pub fn random(_args: &[Value]) -> Value {
+    Value::Number(tishlang_core::random_f64())
+}
+
 pub fn sign(args: &[Value]) -> Value {
     let n = extract_num(args.first()).unwrap_or(f64::NAN);
     Value::Number(if n.is_nan() {

package/crates/tish_builtins/src/number.rs

@@ -5,6 +5,12 @@
 //! and the tree-walk interpreter all route through here so every backend produces
 //! byte-identical output — see `tish/docs/full-backend-parity-plan.md` (Workstream A).
 
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+#[cfg(feature = "portable")]
+use tishlang_core::FloatExt;
+
 use tishlang_core::Value;
 
 /// `Number.prototype.toFixed(digits)` — ECMA-262 §21.1.3.3.
@@ -25,8 +31,16 @@ pub fn to_fixed(n: &Value, digits: &Value) -> Value {
 }
 
 /// f64-domain `Number.prototype.toFixed` so the tree-walk interpreter (distinct `Value`) shares the
-/// exact behavior. Rust's `{:.*}` rounds half-to-even (`(2.5).toFixed(0)` → "2"); JS rounds half away
-/// from zero (→ "3"), so pre-round the scaled value with `.round()` (half-away) before formatting. #247
+/// exact behavior. tish's rule (#438): round the number's *true* decimal value to `digits` places,
+/// ties away from zero — matching V8/node's observable `toFixed`.
+///
+/// The obvious `(num * 10^digits).round()` is wrong: float scaling nudges values that are actually
+/// just below a tie up over it, so `(2.675).toFixed(2)` came out `2.68` where node gives `2.67`
+/// (2.675 is stored as 2.67499999…). Instead we render the double's exact decimal expansion to well
+/// beyond `digits` — f64 fractions terminate, so a generous precision captures the real digits — then
+/// round that digit string: if the first dropped digit is ≥ 5, increment with decimal carry; else
+/// truncate. On the magnitude, "first dropped ≥ 5" is round-half-up = round-half-away-from-zero, and
+/// because the expansion is exact, non-ties round the way the true value dictates. #438
 pub fn to_fixed_str(num: f64, digits: usize) -> String {
     if num.is_nan() {
         return "NaN".to_string();
@@ -38,9 +52,61 @@ pub fn to_fixed_str(num: f64, digits: usize) -> String {
     if num.abs() >= 1e21 {
         return format!("{}", num);
     }
-    let factor = 10f64.powi(digits as i32);
-    let rounded = (num * factor).round() / factor;
-    format!("{:.*}", digits, rounded)
+
+    let negative = num.is_sign_negative() && num != 0.0;
+    let magnitude = num.abs();
+
+    // Exact-enough decimal expansion. The digit just past `digits` then reflects the double's TRUE
+    // value; +25 guard digits sit far beyond any position we inspect, so the half-to-even rounding
+    // Rust applies at the cutoff can't perturb our decision (it would take 25 consecutive 9s to carry
+    // back that far, and such a value already rounds up under the exact rule anyway).
+    let guard = digits + 25;
+    let rendered = format!("{:.*}", guard, magnitude);
+    let dot = rendered.find('.').expect("fixed formatting always has a decimal point");
+    let int_str = &rendered[..dot];
+    let frac = rendered[dot + 1..].as_bytes();
+
+    // Kept digits: the whole integer part, then `digits` fractional digits.
+    let mut ds: Vec<u8> = int_str
+        .bytes()
+        .chain(frac[..digits].iter().copied())
+        .map(|b| b - b'0')
+        .collect();
+
+    // Round half-away-from-zero on the magnitude: increment iff the first dropped digit is >= 5.
+    if frac[digits] - b'0' >= 5 {
+        let mut i = ds.len();
+        loop {
+            if i == 0 {
+                ds.insert(0, 1);
+                break;
+            }
+            i -= 1;
+            if ds[i] == 9 {
+                ds[i] = 0;
+            } else {
+                ds[i] += 1;
+                break;
+            }
+        }
+    }
+
+    // Split back into integer (all but the last `digits`) and fractional digits.
+    let int_len = ds.len() - digits;
+    let mut out = String::with_capacity(ds.len() + 2);
+    if negative {
+        out.push('-');
+    }
+    for &d in &ds[..int_len] {
+        out.push((d + b'0') as char);
+    }
+    if digits > 0 {
+        out.push('.');
+        for &d in &ds[int_len..] {
+            out.push((d + b'0') as char);
+        }
+    }
+    out
 }
 
 /// `Number.prototype.toExponential(fractionDigits?)` — ECMA-262 §21.1.3.2. Exponential notation with
@@ -270,7 +336,7 @@ pub fn number_to_string_radix(num: f64, radix: i64) -> Option<String> {
     if negative {
         out.push('-');
     }
-    out.push_str(std::str::from_utf8(&int_digits).unwrap());
+    out.push_str(core::str::from_utf8(&int_digits).unwrap());
 
     // Fractional part: multiply-by-radix, emitting the integer overflow each step.
     if frac > 0.0 {

package/crates/tish_builtins/src/object.rs

@@ -3,7 +3,11 @@
 //! This module will contain shared object method implementations.
 //! Functions will be migrated here from tishlang_runtime and tishlang_eval.
 
-use std::sync::Arc;
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+
+use tishlang_core::Arc;
 use tishlang_core::{ObjectData, PropMap, Value, VmRef};
 
 /// Create a new empty object Value.
@@ -16,6 +20,7 @@ pub fn with_capacity(capacity: usize) -> Value {
     Value::Object(VmRef::new(ObjectData {
         strings: PropMap::with_capacity(capacity),
         symbols: None,
+        frozen: false,
     }))
 }
 

package/crates/tish_builtins/src/string.rs

@@ -3,11 +3,17 @@
 //! All indices use character (Unicode scalar) positions for consistency with
 //! JavaScript, matching .length and .charAt(). Byte offsets are never exposed.
 
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+
 use crate::helpers::normalize_index;
-use std::cell::RefCell;
+use core::cell::RefCell;
 use tishlang_core::ArcStr;
 use tishlang_core::Value;
 use tishlang_core::VmRef;
+#[cfg(feature = "portable")]
+use tishlang_core::FloatExt;
 
 // #203: a per-thread cursor cache that makes repeated character indexing (`charCodeAt(i)`, `s[i]`,
 // `charAt(i)`) O(1)/near-O(1) instead of O(i). tish strings are UTF-8, so `chars().nth(i)` scans from
@@ -29,9 +35,14 @@ struct CharCursor {
     byte_off: usize,
 }
 
+#[cfg(not(feature = "portable"))]
 thread_local! {
     static INDEX_CURSOR: RefCell<Option<CharCursor>> = const { RefCell::new(None) };
 }
+// Single-core: one shared cursor cache with the same `.with()` API.
+#[cfg(feature = "portable")]
+static INDEX_CURSOR: tishlang_core::SingleCore<RefCell<Option<CharCursor>>> =
+    tishlang_core::SingleCore::new(RefCell::new(None));
 
 /// Borrow the cursor entry for `s`, reseeding (compute ASCII flag + character count) if it currently
 /// caches a different backing allocation, then run `f` against it. Centralises the pointer-keyed
@@ -40,7 +51,7 @@ fn with_cursor<R>(s: &ArcStr, f: impl FnOnce(&mut CharCursor, &ArcStr) -> R) ->
     INDEX_CURSOR.with(|cell| {
         let mut slot = cell.borrow_mut();
         let hit = matches!(slot.as_ref(), Some(c)
-            if std::ptr::eq(c.s.as_bytes().as_ptr(), s.as_bytes().as_ptr()) && c.s.len() == s.len());
+            if core::ptr::eq(c.s.as_bytes().as_ptr(), s.as_bytes().as_ptr()) && c.s.len() == s.len());
         if !hit {
             let ascii = s.as_bytes().is_ascii();
             // ASCII → character count equals byte length (free); otherwise count once.

package/crates/tish_builtins/src/symbol.rs

@@ -1,30 +1,30 @@
 //! ECMAScript-style `Symbol`, `Symbol.for`, `Symbol.keyFor`.
 
-use std::collections::hash_map::Entry;
-use std::sync::{Arc, Mutex, OnceLock};
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
 
-use std::collections::HashMap;
+use tishlang_core::sync::{Mutex, OnceLock};
+use tishlang_core::{alloc_symbol_id, AHashMap, Arc, ObjectMap, TishSymbol, Value};
 
-use tishlang_core::{alloc_symbol_id, ObjectMap, TishSymbol, Value};
+static SYMBOL_FOR_REGISTRY: OnceLock<Mutex<AHashMap<Arc<str>, Arc<TishSymbol>>>> = OnceLock::new();
 
-static SYMBOL_FOR_REGISTRY: OnceLock<Mutex<HashMap<Arc<str>, Arc<TishSymbol>>>> = OnceLock::new();
-
-fn symbol_registry() -> &'static Mutex<HashMap<Arc<str>, Arc<TishSymbol>>> {
-    SYMBOL_FOR_REGISTRY.get_or_init(|| Mutex::new(HashMap::new()))
+fn symbol_registry() -> &'static Mutex<AHashMap<Arc<str>, Arc<TishSymbol>>> {
+    SYMBOL_FOR_REGISTRY.get_or_init(|| Mutex::new(AHashMap::default()))
 }
 
 fn symbol_for_impl(key: &str) -> Value {
     let k: Arc<str> = key.into();
     let mut reg = symbol_registry().lock().unwrap();
-    let sym = match reg.entry(Arc::clone(&k)) {
-        Entry::Occupied(e) => e.get().clone(),
-        Entry::Vacant(v) => {
-            let id = alloc_symbol_id();
-            let sym = TishSymbol::new_registry(id, Arc::clone(&k), None);
-            v.insert(Arc::clone(&sym));
-            sym
-        }
-    };
+    // get-then-insert (rather than the `Entry` API) so this compiles against both
+    // std `HashMap` and the portable `hashbrown` map without a hasher-specific
+    // `Entry` import. `Symbol.for` is not a hot path.
+    if let Some(existing) = reg.get(&k) {
+        return Value::Symbol(existing.clone());
+    }
+    let id = alloc_symbol_id();
+    let sym = TishSymbol::new_registry(id, Arc::clone(&k), None);
+    reg.insert(k, Arc::clone(&sym));
     Value::Symbol(sym)
 }
 

package/crates/tish_builtins/src/typedarrays.rs

@@ -17,7 +17,13 @@
 //! - A typed array is a regular array at runtime, so `Array.isArray(ta)` is `true` and there is no
 //!   `instanceof` distinction.
 
-use std::sync::Arc;
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+#[cfg(feature = "portable")]
+use tishlang_core::FloatExt;
+
+use tishlang_core::Arc;
 use tishlang_core::{ObjectMap, Value, VmRef};
 
 const CONSTRUCT: &str = "__construct";
@@ -93,7 +99,7 @@ fn bytes_per_element(kind: Kind) -> f64 {
 fn elements(value: &Value) -> Vec<Value> {
     match value {
         Value::Array(a) => a.borrow().clone(),
-        Value::NumberArray(a) => a.borrow().iter().map(|n| Value::Number(*n)).collect(),
+        Value::NumberArray(a) => a.borrow().to_values(),
         _ => Vec::new(),
     }
 }
@@ -291,6 +297,7 @@ mod tests {
         match &packed {
             Value::NumberArray(a) => {
                 let v = a.borrow();
+                let v = v.as_packed().expect("packed backing");
                 assert_eq!(v[0], 1.1);
                 assert_eq!(v[1], 2.2);
                 assert!(v[2].is_nan());

package/crates/tish_bytecode/src/compiler.rs

@@ -11,7 +11,7 @@ use tishlang_ast::{
 
 use crate::chunk::{Chunk, Constant};
 use crate::encoding::{binop_to_u8, compound_op_to_u8, unaryop_to_u8};
-use crate::opcode::{MathUnaryFn, Opcode};
+use crate::opcode::{MathBinaryFn, MathUnaryFn, Opcode};
 
 enum SimpleMapResult {
     Identity,
@@ -452,6 +452,23 @@ fn expr_rebinds(e: &Expr, name: &str) -> bool {
 /// so it can't run program-wide), this has an explicit `FunDecl` arm: a `function name` is itself a
 /// binding, and every function body is recursed into. `true` (or any node it can't analyze) ⇒ NOT
 /// stable — which only forgoes the cross-function-call optimization, never risks a miscompile.
+/// #203: the f64 value of a `Math.<name>` constant, or `None` if `name` isn't one. The values are the
+/// IEEE doubles ECMAScript specifies (identical to Rust's `std::f64::consts` and to the `Math` object
+/// built on every backend, #539), so emitting them as a `LoadConst` is byte-identical to `Math.PI` etc.
+fn math_constant(name: &str) -> Option<f64> {
+    Some(match name {
+        "PI" => std::f64::consts::PI,
+        "E" => std::f64::consts::E,
+        "LN2" => std::f64::consts::LN_2,
+        "LN10" => std::f64::consts::LN_10,
+        "LOG2E" => std::f64::consts::LOG2_E,
+        "LOG10E" => std::f64::consts::LOG10_E,
+        "SQRT2" => std::f64::consts::SQRT_2,
+        "SQRT1_2" => std::f64::consts::FRAC_1_SQRT_2,
+        _ => return None,
+    })
+}
+
 fn name_rebinds_in_stmt(s: &Statement, name: &str) -> bool {
     match s {
         Statement::FunDecl {
@@ -1968,6 +1985,9 @@ impl<'a> Compiler<'a> {
                 }
                 let mut inner_comp = Compiler::new(&mut inner, false);
                 inner_comp.stable_globals = Arc::clone(&self.stable_globals);
+                // #203: `Math` unshadowed is a whole-program property; thread it so `Math.<fn>` in this
+                // function body lowers to the MathUnary intrinsic (else the numeric JIT bails).
+                inner_comp.math_is_global = self.math_is_global;
                 // Recursion-JIT enabler: if `name`'s binding is provably stable in the body (no
                 // param shadows it, no reassignment/redeclaration), direct `name(args)` calls inside
                 // compile to `SelfCall` — no name lookup, and the numeric JIT lowers it to a native
@@ -2399,6 +2419,31 @@ impl<'a> Compiler<'a> {
                         }
                     }
                 }
+                // #203: `Math.<binfn>(a, b)` → `<a>; <b>; MathBinary(id)` — the same unshadowed-global
+                // gate, for exactly two positional args (variadic `Math.max(a,b,c)` falls through to a
+                // generic call). Lets the numeric JIT lower clamp/pow kernels instead of bailing.
+                if self.math_is_global && args.len() == 2 {
+                    if let Expr::Member {
+                        object,
+                        prop: MemberProp::Name { name: fname, .. },
+                        optional: false,
+                        ..
+                    } = callee.as_ref()
+                    {
+                        if let (Expr::Ident { name: obj, .. }, CallArg::Expr(a0), CallArg::Expr(a1)) =
+                            (object.as_ref(), &args[0], &args[1])
+                        {
+                            if obj.as_ref() == "Math" && self.resolve_slot("Math").is_none() {
+                                if let Some(bfn) = MathBinaryFn::from_name(fname.as_ref()) {
+                                    self.compile_expr(a0)?;
+                                    self.compile_expr(a1)?;
+                                    self.emit_u16(Opcode::MathBinary, bfn as u16);
+                                    return Ok(());
+                                }
+                            }
+                        }
+                    }
+                }
                 // Fast path: arr.sort((a,b)=>a-b) or arr.sort((a,b)=>b-a) -> ArraySortNumeric
                 if !args.iter().any(|a| matches!(a, CallArg::Spread(_)))
                     && args.len() == 1
@@ -2520,6 +2565,26 @@ impl<'a> Compiler<'a> {
                 optional,
                 ..
             } => {
+                // #203: `Math.<CONST>` (PI / E / LN2 / …) when `Math` is the provably-unshadowed
+                // global → a plain `LoadConst`, so the numeric JIT sees a constant instead of bailing
+                // on a `GetMember`. The values match the `Math` object's on every backend (both use
+                // `std::f64::consts`, #539), so this is byte-identical. Same gate as the intrinsics.
+                if !*optional && self.math_is_global {
+                    if let (
+                        Expr::Ident { name: obj, .. },
+                        MemberProp::Name { name: p, .. },
+                    ) = (object.as_ref(), prop)
+                    {
+                        if obj.as_ref() == "Math" && self.resolve_slot("Math").is_none() {
+                            if let Some(v) = math_constant(p.as_ref()) {
+                                let idx = self.constant_idx(Constant::Number(v));
+                                self.emit(Opcode::LoadConst);
+                                self.chunk.write_u16(idx);
+                                return Ok(());
+                            }
+                        }
+                    }
+                }
                 self.compile_expr(object)?;
                 if *optional {
                     self.emit(Opcode::Dup);
@@ -2686,6 +2751,7 @@ impl<'a> Compiler<'a> {
                 }
                 let mut inner_comp = Compiler::new(&mut inner, false);
                 inner_comp.stable_globals = Arc::clone(&self.stable_globals); // #187
+                inner_comp.math_is_global = self.math_is_global; // #203 (see other call site)
                 if let Some(map) = simple_slots {
                     inner_comp.slot_ctx = Some(map);
                 } else {
@@ -3116,7 +3182,15 @@ fn compile_internal(
     // #186 — `Math` intrinsics are sound only if `Math` is never rebound anywhere in the program.
     // `stmt_rebinds` is conservative (any rebind, destructure, FunDecl, or unknown node → true), so a
     // `false` here only forgoes the optimization, never risks a miscompile.
-    compiler.math_is_global = !program.statements.iter().any(|s| stmt_rebinds(s, "Math"));
+    // #203: whole-program scan (recurses into function bodies/params, unlike `stmt_rebinds` which is
+    // conservatively `true` on any FunDecl) — so `Math` is provably-global even when the program
+    // defines functions, letting `Math.<fn>` inside a function lower to the MathUnary intrinsic (the
+    // numeric/array JIT then compiles the kernel instead of bailing on a generic call). Errs toward
+    // "rebound" ⇒ never falsely global ⇒ no miscompile. Threaded into nested compilers below.
+    compiler.math_is_global = !program
+        .statements
+        .iter()
+        .any(|s| name_rebinds_in_stmt(s, "Math"));
     // #187 — the set of top-level functions safe to call directly from JIT'd code (never reassigned/
     // shadowed/redeclared anywhere). Conservative: a name absent here only forgoes the optimization.
     compiler.stable_globals = Arc::new(compute_stable_globals(program));

package/crates/tish_bytecode/src/lib.rs

@@ -16,5 +16,5 @@ pub use compiler::{
     compile_with_source, CompileError,
 };
 pub use encoding::{binop_to_u8, compound_op_to_u8, u8_to_binop, u8_to_unaryop, unaryop_to_u8};
-pub use opcode::{MathUnaryFn, Opcode};
+pub use opcode::{MathBinaryFn, MathUnaryFn, Opcode};
 pub use serialize::{deserialize, serialize};