@tishlang/tish-format 2.12.0 → 2.35.0

package/crates/tish_builtins/src/collections.rs

@@ -54,38 +54,65 @@ impl PartialEq for Key {
 }
 impl Eq for Key {}
 
+/// The single source of truth for hashing a key `Value`. Both [`Key`] (owned, the stored key) and
+/// [`KeyRef`] (borrowed, the lookup probe) delegate here so an owned key and a borrowed probe of an
+/// equal value hash identically — the invariant that makes the zero-clone borrow lookup sound.
+#[inline]
+fn hash_key_value<H: Hasher>(v: &Value, state: &mut H) {
+    match v {
+        Value::Number(n) => {
+            0u8.hash(state);
+            // Canonicalize so `Eq` partners hash together: `+0` and `-0` share a key, and every
+            // NaN is one key.
+            let bits = if *n == 0.0 {
+                0u64
+            } else if n.is_nan() {
+                0x7ff8_0000_0000_0000
+            } else {
+                n.to_bits()
+            };
+            bits.hash(state);
+        }
+        Value::String(s) => {
+            1u8.hash(state);
+            s.as_str().hash(state);
+        }
+        Value::Bool(b) => {
+            2u8.hash(state);
+            b.hash(state);
+        }
+        Value::Null => 3u8.hash(state),
+        // Reference / identity values: per-variant tag only; `ptr_eq` in `Eq` does the rest.
+        Value::Symbol(_) => 4u8.hash(state),
+        Value::Array(_) => 5u8.hash(state),
+        Value::NumberArray(_) => 6u8.hash(state),
+        Value::Object(_) => 7u8.hash(state),
+        _ => 8u8.hash(state),
+    }
+}
+
 impl Hash for Key {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        match &self.0 {
-            Value::Number(n) => {
-                0u8.hash(state);
-                // Canonicalize so `Eq` partners hash together: `+0` and `-0` share a key, and every
-                // NaN is one key.
-                let bits = if *n == 0.0 {
-                    0u64
-                } else if n.is_nan() {
-                    0x7ff8_0000_0000_0000
-                } else {
-                    n.to_bits()
-                };
-                bits.hash(state);
-            }
-            Value::String(s) => {
-                1u8.hash(state);
-                s.as_str().hash(state);
-            }
-            Value::Bool(b) => {
-                2u8.hash(state);
-                b.hash(state);
-            }
-            Value::Null => 3u8.hash(state),
-            // Reference / identity values: per-variant tag only; `ptr_eq` in `Eq` does the rest.
-            Value::Symbol(_) => 4u8.hash(state),
-            Value::Array(_) => 5u8.hash(state),
-            Value::NumberArray(_) => 6u8.hash(state),
-            Value::Object(_) => 7u8.hash(state),
-            _ => 8u8.hash(state),
-        }
+        hash_key_value(&self.0, state);
+    }
+}
+
+/// Borrowed look-up probe for [`Key`]: wraps `&Value` so `get`/`contains_key`/`shift_remove` can
+/// query the store **without cloning the key into an owned `Key`** (no `Value` clone, no `Arc` bump).
+/// It hashes via [`hash_key_value`] (identical to `Key`) and compares via [`same_value_zero`]
+/// (identical to `Key`'s `Eq`), so it is `Equivalent<Key>` — the lookup is a drop-in for `&Key`.
+/// Only `set`/`add` (which must *store* the key) still build an owned `Key`.
+struct KeyRef<'a>(&'a Value);
+
+impl Hash for KeyRef<'_> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        hash_key_value(self.0, state);
+    }
+}
+
+impl indexmap::Equivalent<Key> for KeyRef<'_> {
+    fn equivalent(&self, key: &Key) -> bool {
+        same_value_zero(self.0, &key.0)
     }
 }
 
@@ -119,6 +146,57 @@ pub fn size_probe_len(op: &dyn TishOpaque) -> Option<f64> {
         .map(|p| p.0.borrow().len() as f64)
 }
 
+fn map_store(map: &Value) -> Option<Store> {
+    if let Value::Object(o) = map {
+        if let Some(Value::Opaque(op)) = o.borrow().strings.get(SIZE_SLOT) {
+            if let Some(probe) = op.as_ref().as_any().downcast_ref::<SizeProbe>() {
+                return Some(probe.0.clone());
+            }
+        }
+    }
+    None
+}
+
+/// Direct `Map.prototype.has` — skips bound-method `get_prop` + `value_call` (k-nucleotide hot path).
+/// Looks up via a borrowed [`KeyRef`]: no key clone, no owned `Key` allocation.
+pub fn map_has(map: &Value, key: &Value) -> Value {
+    match map_store(map) {
+        Some(s) => Value::Bool(s.borrow().contains_key(&KeyRef(key))),
+        None => Value::Bool(false),
+    }
+}
+
+/// Direct `Map.prototype.get`. Looks up via a borrowed [`KeyRef`] (no key clone / no owned `Key`).
+pub fn map_get(map: &Value, key: &Value) -> Value {
+    match map_store(map) {
+        Some(s) => s.borrow().get(&KeyRef(key)).cloned().unwrap_or(Value::Null),
+        None => Value::Null,
+    }
+}
+
+/// Direct `Map.prototype.set` (mutates in place; returns `undefined` = `Null`).
+///
+/// Takes the key/val by reference and clones on insert (the map owns its entries). Passing by
+/// reference lets the native emitter BORROW the caller's place instead of moving it, so
+/// `m.set(k, v); …use k…` no longer produces `E0382 use of moved value` in the generated Rust (#442).
+pub fn map_set(map: &Value, key: &Value, val: &Value) -> Value {
+    if let Some(s) = map_store(map) {
+        s.borrow_mut().insert(Key(key.clone()), val.clone());
+    }
+    Value::Null
+}
+
+/// Direct `Map.prototype.values` — snapshot iterator (same as the bound native method).
+pub fn map_values(map: &Value) -> Value {
+    match map_store(map) {
+        Some(s) => {
+            let out: Vec<Value> = s.borrow().values().cloned().collect();
+            crate::iterator::array_iterator(out)
+        }
+        None => crate::iterator::array_iterator(vec![]),
+    }
+}
+
 /// Wrap a backing store as the hidden [`SIZE_SLOT`] opaque. `Value::Opaque`'s payload is always
 /// `Arc<dyn TishOpaque>`, so on the single-threaded build (`Rc`-based `VmRef`) clippy's
 /// `arc_with_non_send_sync` fires spuriously — the `Arc` is mandated by the API, not a thread choice.
@@ -196,8 +274,8 @@ pub fn set_instance(initial: &[Value]) -> Value {
         m.insert(
             Arc::from("has"),
             Value::native(move |args: &[Value]| {
-                let v = args.first().cloned().unwrap_or(Value::Null);
-                Value::Bool(s.borrow().contains_key(&Key(v)))
+                let v = args.first().unwrap_or(&Value::Null);
+                Value::Bool(s.borrow().contains_key(&KeyRef(v)))
             }),
         );
     }
@@ -206,9 +284,9 @@ pub fn set_instance(initial: &[Value]) -> Value {
         m.insert(
             Arc::from("delete"),
             Value::native(move |args: &[Value]| {
-                let v = args.first().cloned().unwrap_or(Value::Null);
+                let v = args.first().unwrap_or(&Value::Null);
                 // `shift_remove` preserves iteration order (vs `swap_remove`).
-                Value::Bool(s.borrow_mut().shift_remove(&Key(v)).is_some())
+                Value::Bool(s.borrow_mut().shift_remove(&KeyRef(v)).is_some())
             }),
         );
     }
@@ -246,6 +324,20 @@ pub fn set_instance(initial: &[Value]) -> Value {
             }),
         );
     }
+    // `__drain__`: the default-iteration array a Set yields (its elements). `drain_iterator`
+    // (and the interp/native equivalents) check `__drain__` FIRST, so exposing it here makes a
+    // Set directly iterable — `[...set]`, `for (x of set)`, `Array.from(set)` — across all three
+    // backends with no changes to any spread/for-of site. (#440)
+    {
+        let s = store.clone();
+        m.insert(
+            Arc::from("__drain__"),
+            Value::native(move |_args: &[Value]| {
+                let out: Vec<Value> = s.borrow().keys().map(|k| k.0.clone()).collect();
+                Value::Array(VmRef::new(out))
+            }),
+        );
+    }
 
     Value::object(m)
 }
@@ -299,8 +391,8 @@ pub fn map_instance(pairs: &[Value]) -> Value {
         m.insert(
             Arc::from("get"),
             Value::native(move |args: &[Value]| {
-                let key = args.first().cloned().unwrap_or(Value::Null);
-                s.borrow().get(&Key(key)).cloned().unwrap_or(Value::Null)
+                let key = args.first().unwrap_or(&Value::Null);
+                s.borrow().get(&KeyRef(key)).cloned().unwrap_or(Value::Null)
             }),
         );
     }
@@ -309,8 +401,8 @@ pub fn map_instance(pairs: &[Value]) -> Value {
         m.insert(
             Arc::from("has"),
             Value::native(move |args: &[Value]| {
-                let key = args.first().cloned().unwrap_or(Value::Null);
-                Value::Bool(s.borrow().contains_key(&Key(key)))
+                let key = args.first().unwrap_or(&Value::Null);
+                Value::Bool(s.borrow().contains_key(&KeyRef(key)))
             }),
         );
     }
@@ -319,8 +411,8 @@ pub fn map_instance(pairs: &[Value]) -> Value {
         m.insert(
             Arc::from("delete"),
             Value::native(move |args: &[Value]| {
-                let key = args.first().cloned().unwrap_or(Value::Null);
-                Value::Bool(s.borrow_mut().shift_remove(&Key(key)).is_some())
+                let key = args.first().unwrap_or(&Value::Null);
+                Value::Bool(s.borrow_mut().shift_remove(&KeyRef(key)).is_some())
             }),
         );
     }
@@ -368,6 +460,23 @@ pub fn map_instance(pairs: &[Value]) -> Value {
             }),
         );
     }
+    // `__drain__`: a Map's default iteration yields `[key, value]` entries. Exposed so the shared
+    // `drain_iterator` (checked first) makes a Map directly iterable — `[...map]`, `for (x of map)`,
+    // `Array.from(map)` — across interp/vm/native with no spread/for-of site changes. (#440)
+    {
+        let s = store.clone();
+        m.insert(
+            Arc::from("__drain__"),
+            Value::native(move |_args: &[Value]| {
+                let pairs: Vec<Value> = s
+                    .borrow()
+                    .iter()
+                    .map(|(k, v)| Value::Array(VmRef::new(vec![k.0.clone(), v.clone()])))
+                    .collect();
+                Value::Array(VmRef::new(pairs))
+            }),
+        );
+    }
 
     Value::object(m)
 }

package/crates/tish_builtins/src/globals.rs

@@ -5,7 +5,7 @@
 
 use std::sync::Arc;
 use tishlang_core::VmRef;
-use tishlang_core::{percent_decode, percent_encode, ObjectMap, Value};
+use tishlang_core::{percent_decode, percent_decode_component, percent_encode, percent_encode_component, ObjectMap, Value};
 
 /// Boolean(value) - coerce to bool
 pub fn boolean(args: &[Value]) -> Value {
@@ -13,7 +13,7 @@ pub fn boolean(args: &[Value]) -> Value {
     Value::Bool(v.is_truthy())
 }
 
-/// decodeURI(str)
+/// decodeURI(str) — preserves the URI reserved delimiters (the inverse of encodeURI).
 pub fn decode_uri(args: &[Value]) -> Value {
     let s = args
         .first()
@@ -31,19 +31,34 @@ pub fn encode_uri(args: &[Value]) -> Value {
     Value::String(percent_encode(&s).into())
 }
 
-/// isFinite(value)
+/// encodeURIComponent(str) — stricter than encodeURI (also escapes the URI reserved delimiters).
+pub fn encode_uri_component(args: &[Value]) -> Value {
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
+    Value::String(percent_encode_component(&s).into())
+}
+
+/// decodeURIComponent(str) — decodes ALL `%XX` escapes (including the reserved delimiters).
+pub fn decode_uri_component(args: &[Value]) -> Value {
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
+    Value::String(percent_decode_component(&s).unwrap_or(s).into())
+}
+
+/// isFinite(value) — coerces via ToNumber (like `Number()`), then tests finiteness. `isFinite("3")`
+/// is `true`, `isFinite("x")`/`isFinite()` is `false`. (The non-coercing form is `Number.isFinite`.)
 pub fn is_finite(args: &[Value]) -> Value {
-    Value::Bool(
-        args.first()
-            .is_some_and(|v| matches!(v, Value::Number(n) if n.is_finite())),
-    )
+    Value::Bool(args.first().map_or(f64::NAN, to_number).is_finite())
 }
 
-/// isNaN(value)
+/// isNaN(value) — coerces via ToNumber, then tests NaN. `isNaN("3")` is `false`; an absent arg
+/// (undefined) coerces to NaN → `true`. (The non-coercing form is `Number.isNaN`.)
 pub fn is_nan(args: &[Value]) -> Value {
-    Value::Bool(args.first().is_none_or(|v| {
-        matches!(v, Value::Number(n) if n.is_nan()) || !matches!(v, Value::Number(_))
-    }))
+    Value::Bool(args.first().map_or(f64::NAN, to_number).is_nan())
 }
 
 /// Array.isArray(value)
@@ -51,6 +66,142 @@ pub fn array_is_array(args: &[Value]) -> Value {
     Value::Bool(matches!(args.first(), Some(Value::Array(_)) | Some(Value::NumberArray(_))))
 }
 
+/// `Array.of(...items)` — build an array from the args (unlike `Array(n)`, a single number is an
+/// element, not a length: `Array.of(7)` is `[7]`).
+pub fn array_of(args: &[Value]) -> Value {
+    Value::Array(VmRef::new(args.to_vec()))
+}
+
+/// `Array.from(source, mapFn?)` — build an array from an iterable (array, string, Set/Map, or any
+/// `__drain__`/`next` iterator — via the shared iterator protocol) or an array-like `{ length }`
+/// object, optionally mapping each element through `mapFn(item, index)`.
+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(),
+        // `drain_iterator` covers String (chars), Set/Map, and any iterator object.
+        other => {
+            if let Some(d) = tishlang_core::drain_iterator(other) {
+                d
+            } else if matches!(other, Value::Object(_)) {
+                let len = tishlang_core::object_get(other, &Value::String("length".into()))
+                    .and_then(|v| match v {
+                        Value::Number(n) if n.is_finite() && n >= 0.0 => Some(n as usize),
+                        _ => None,
+                    })
+                    .unwrap_or(0);
+                (0..len)
+                    .map(|i| {
+                        tishlang_core::object_get(other, &Value::String(i.to_string().into()))
+                            .unwrap_or(Value::Null)
+                    })
+                    .collect()
+            } else {
+                Vec::new()
+            }
+        }
+    };
+    let out: Vec<Value> = match args.get(1) {
+        Some(Value::Function(f)) => items
+            .into_iter()
+            .enumerate()
+            .map(|(i, x)| f.call(&[x, Value::Number(i as f64)]))
+            .collect(),
+        _ => items,
+    };
+    Value::Array(VmRef::new(out))
+}
+
+/// `structuredClone(value)` — a recursive deep copy of arrays, objects, and primitives, with cycles
+/// preserved (a repeated reference clones to the same new node). Functions and exotic types (Date,
+/// RegExp, Map, Set) are shared/shallow — a pragmatic subset covering plain data structures.
+pub fn structured_clone(args: &[Value]) -> Value {
+    let mut seen: Vec<(*const (), Value)> = Vec::new();
+    deep_clone(args.first().unwrap_or(&Value::Null), &mut seen)
+}
+
+fn deep_clone(v: &Value, seen: &mut Vec<(*const (), Value)>) -> Value {
+    match v {
+        Value::Array(a) => {
+            let ptr = a.as_ptr();
+            if let Some((_, c)) = seen.iter().find(|(p, _)| *p == ptr) {
+                return c.clone();
+            }
+            let new: VmRef<Vec<Value>> = VmRef::new(Vec::new());
+            seen.push((ptr, Value::Array(new.clone())));
+            let src = a.borrow().clone();
+            let cloned: Vec<Value> = src.iter().map(|e| deep_clone(e, seen)).collect();
+            *new.borrow_mut() = cloned;
+            Value::Array(new)
+        }
+        Value::NumberArray(a) => Value::NumberArray(VmRef::new(a.borrow().clone())),
+        Value::Object(o) => {
+            let ptr = o.as_ptr();
+            if let Some((_, c)) = seen.iter().find(|(p, _)| *p == ptr) {
+                return c.clone();
+            }
+            let entries: Vec<(Arc<str>, Value)> = o
+                .borrow()
+                .strings
+                .iter()
+                .map(|(k, val)| (k.clone(), val.clone()))
+                .collect();
+            let new_obj = Value::object(ObjectMap::default());
+            // register the (empty) new object before recursing so cycles resolve back to it
+            if let Value::Object(no) = &new_obj {
+                seen.push((ptr, new_obj.clone()));
+                for (k, val) in entries {
+                    let cloned = deep_clone(&val, seen);
+                    no.borrow_mut().strings.insert(k, cloned);
+                }
+            }
+            new_obj
+        }
+        other => other.clone(),
+    }
+}
+
+/// `Object.hasOwn(obj, key)` (ES2022) — true if `key` is an OWN property of `obj`. For arrays an
+/// in-range integer index or `"length"` counts; for plain objects, a key present in the string map.
+pub fn object_has_own(args: &[Value]) -> Value {
+    let key = match args.get(1) {
+        Some(Value::String(s)) => s.to_string(),
+        Some(Value::Number(n)) => tishlang_core::js_number_to_string(*n),
+        Some(v) => v.to_display_string(),
+        None => return Value::Bool(false),
+    };
+    match args.first() {
+        Some(Value::Object(obj)) => Value::Bool(obj.borrow().strings.contains_key(key.as_str())),
+        Some(Value::Array(arr)) => Value::Bool(
+            key == "length" || matches!(key.parse::<usize>(), Ok(i) if i < arr.borrow().len()),
+        ),
+        Some(Value::NumberArray(arr)) => Value::Bool(
+            key == "length" || matches!(key.parse::<usize>(), Ok(i) if i < arr.borrow().len()),
+        ),
+        _ => Value::Bool(false),
+    }
+}
+
+/// `Object.is(a, b)` — SameValue: like `===`, but NaN equals NaN and `+0` is NOT equal to `-0`.
+pub fn object_is(args: &[Value]) -> Value {
+    let a = args.first().unwrap_or(&Value::Null);
+    let b = args.get(1).unwrap_or(&Value::Null);
+    let same = match (a, b) {
+        (Value::Number(x), Value::Number(y)) => {
+            if x.is_nan() && y.is_nan() {
+                true
+            } else if *x == 0.0 && *y == 0.0 {
+                x.is_sign_negative() == y.is_sign_negative()
+            } else {
+                x == y
+            }
+        }
+        _ => a.strict_eq(b),
+    };
+    Value::Bool(same)
+}
+
 /// String(value) — convert value to string (JS String constructor as function).
 /// Uses JS `ToString` (arrays comma-join recursively, objects → "[object Object]"),
 /// not the inspect/display form.
@@ -64,8 +215,14 @@ pub fn string_convert(args: &[Value]) -> Value {
 /// otherwise NaN); arrays/objects go via their string form (so `Number([5])` → 5,
 /// `Number([])` → 0, objects → NaN).
 pub fn number_convert(args: &[Value]) -> Value {
-    let v = args.first().unwrap_or(&Value::Null);
-    let n = match v {
+    Value::Number(to_number(args.first().unwrap_or(&Value::Null)))
+}
+
+/// JS `ToNumber(v)`: Number → itself; Bool → 1/0; Null → 0; String → parsed (trimmed, `0x`/`0b`/`0o`
+/// and `Infinity`; `""` → 0, else NaN); anything else via its string form. The single ToNumber path
+/// shared by `Number()`, `isNaN`/`isFinite`, etc.
+pub fn to_number(v: &Value) -> f64 {
+    match v {
         Value::Number(n) => *n,
         Value::Bool(b) => {
             if *b {
@@ -77,8 +234,29 @@ pub fn number_convert(args: &[Value]) -> Value {
         Value::Null => 0.0,
         Value::String(s) => parse_numeric_string(s),
         other => parse_numeric_string(&other.to_js_string()),
-    };
-    Value::Number(n)
+    }
+}
+
+/// `Number.isInteger(v)` — true iff `v` IS a finite Number with no fractional part. No coercion
+/// (`Number.isInteger("3")` is `false`, unlike a bare `isNaN`-style coercion).
+pub fn number_is_integer(args: &[Value]) -> Value {
+    Value::Bool(matches!(args.first(), Some(Value::Number(n)) if n.is_finite() && n.fract() == 0.0))
+}
+
+/// `Number.isSafeInteger(v)` — `isInteger` AND exactly representable (|v| ≤ 2^53 − 1).
+pub fn number_is_safe_integer(args: &[Value]) -> Value {
+    Value::Bool(matches!(args.first(),
+        Some(Value::Number(n)) if n.is_finite() && n.fract() == 0.0 && n.abs() <= 9_007_199_254_740_991.0))
+}
+
+/// `Number.isNaN(v)` — true iff `v` IS the number NaN. No coercion (unlike the global `isNaN`).
+pub fn number_is_nan(args: &[Value]) -> Value {
+    Value::Bool(matches!(args.first(), Some(Value::Number(n)) if n.is_nan()))
+}
+
+/// `Number.isFinite(v)` — true iff `v` is a finite Number. No coercion (unlike the global `isFinite`).
+pub fn number_is_finite(args: &[Value]) -> Value {
+    Value::Bool(matches!(args.first(), Some(Value::Number(n)) if n.is_finite()))
 }
 
 /// Parse a string as JS `Number` does: trimmed; `""` → 0; `0x`/`0o`/`0b` radix prefixes;
@@ -120,16 +298,28 @@ pub fn string_from_char_code(args: &[Value]) -> Value {
 
 /// Object.keys(obj)
 pub fn object_keys(args: &[Value]) -> Value {
-    if let Some(Value::Object(obj)) = args.first() {
-        let obj_borrow = obj.borrow();
-        let keys: Vec<Value> = obj_borrow
-            .strings
-            .keys()
-            .map(|k| Value::String(tishlang_core::ArcStr::from(k.as_ref())))
-            .collect();
-        Value::Array(VmRef::new(keys))
-    } else {
-        Value::Array(VmRef::new(Vec::new()))
+    match args.first() {
+        Some(Value::Object(obj)) => {
+            let obj_borrow = obj.borrow();
+            let keys: Vec<Value> = obj_borrow
+                .strings
+                .keys()
+                .map(|k| Value::String(tishlang_core::ArcStr::from(k.as_ref())))
+                .collect();
+            Value::Array(VmRef::new(keys))
+        }
+        // `Object.keys(array)` yields the index strings "0".."len-1" (an array's own enumerable keys
+        // are its indices, per JS). Previously returned `[]` — a node divergence, and the reason
+        // `for (k in array)` enumerated nothing on the vm/native backends (they lower for-in to
+        // for-of over `Object.keys`).
+        Some(Value::Array(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())),
     }
 }
 

package/crates/tish_builtins/src/math.rs

@@ -1,7 +1,7 @@
 //! Math builtin functions.
 
 use crate::helpers::extract_num;
-use tishlang_core::Value;
+use tishlang_core::{to_int32, to_uint32, Value};
 
 macro_rules! math_unary {
     ($name:ident, $op:ident) => {
@@ -28,6 +28,20 @@ math_unary!(log2, log2);
 math_unary!(exp, exp);
 math_unary!(trunc, trunc);
 math_unary!(cbrt, cbrt);
+math_unary!(expm1, exp_m1);
+math_unary!(log1p, ln_1p);
+
+/// `Math.clz32(x)` — count leading zero bits of `ToUint32(x)` (0..=32).
+pub fn clz32(args: &[Value]) -> Value {
+    let n = to_uint32(extract_num(args.first()).unwrap_or(0.0));
+    Value::Number(n.leading_zeros() as f64)
+}
+
+/// `Math.fround(x)` — round `x` to the nearest 32-bit float, back to f64.
+pub fn fround(args: &[Value]) -> Value {
+    let x = extract_num(args.first()).unwrap_or(f64::NAN);
+    Value::Number(x as f32 as f64)
+}
 
 // --- f64-domain semantics (single source of truth) -------------------------------------------------
 // These hold the JS-specific Math rules so every backend agrees: the vm/native paths call the
@@ -119,7 +133,9 @@ pub fn sign(args: &[Value]) -> Value {
     } else if n < 0.0 {
         -1.0
     } else {
-        0.0
+        // ±0 → return the input unchanged so `Math.sign(-0)` is `-0` (per ES);
+        // `n < 0.0` is false for -0, so it lands here — bare `0.0` would drop the sign.
+        n
     })
 }
 
@@ -129,15 +145,57 @@ pub fn atan2(args: &[Value]) -> Value {
     Value::Number(y.atan2(x))
 }
 
+/// ECMAScript `Math.hypot(...args)` core: sqrt of the sum of squares, VARIADIC and
+/// NaN/Infinity-correct. Infinity takes precedence over NaN (any ±∞ arg → +∞, even alongside a NaN);
+/// otherwise any NaN → NaN; the finite case is scaled by the max magnitude to avoid intermediate
+/// overflow/underflow (matches V8). `Math.hypot()` (no args) → 0. Shared so interp/vm/native agree
+/// (#247 — the interp/native path was 2-arg only, so `Math.hypot(3,4,12)` gave 5 not 13, and the vm
+/// dropped non-number args instead of propagating NaN).
+pub fn hypot_f64(nums: &[f64]) -> f64 {
+    let mut any_nan = false;
+    let mut max = 0.0_f64;
+    for &n in nums {
+        if n.is_infinite() {
+            return f64::INFINITY;
+        }
+        if n.is_nan() {
+            any_nan = true;
+        }
+        let a = n.abs();
+        if a > max {
+            max = a;
+        }
+    }
+    if any_nan {
+        return f64::NAN;
+    }
+    if max == 0.0 {
+        return 0.0;
+    }
+    let mut sum = 0.0_f64;
+    for &n in nums {
+        let r = n / max;
+        sum += r * r;
+    }
+    max * sum.sqrt()
+}
+
 pub fn hypot(args: &[Value]) -> Value {
-    let x = extract_num(args.first()).unwrap_or(0.0);
-    let y = extract_num(args.get(1)).unwrap_or(0.0);
-    Value::Number(x.hypot(y))
+    let nums: Vec<f64> = args
+        .iter()
+        .map(|v| extract_num(Some(v)).unwrap_or(f64::NAN))
+        .collect();
+    Value::Number(hypot_f64(&nums))
 }
 
 /// ES6 `Math.imul`: 32-bit integer multiply (used by xmur3 PRNG in juke-cards).
+///
+/// Operands go through JS `ToInt32` (modulo 2³², NaN/±Infinity → 0), NOT a saturating `as i32`
+/// cast: the latter clamps any argument ≥ 2³¹ (e.g. a full uint32 hash state) to `i32::MAX` and
+/// diverges from ECMAScript / V8 (`Math.imul(3e9, 1)` = -1294967296, not 2147483647). The typed
+/// native path inlines the same ToInt32 + wrapping multiply, so all backends agree.
 pub fn imul(args: &[Value]) -> Value {
-    let a = extract_num(args.first()).unwrap_or(0.0) as i32;
-    let b = extract_num(args.get(1)).unwrap_or(0.0) as i32;
+    let a = to_int32(extract_num(args.first()).unwrap_or(0.0));
+    let b = to_int32(extract_num(args.get(1)).unwrap_or(0.0));
     Value::Number(a.wrapping_mul(b) as f64)
 }