@tishlang/tish 2.2.7 → 2.8.0

package/crates/tish_core/src/value.rs

@@ -834,6 +834,31 @@ pub fn to_uint32(x: f64) -> u32 {
     }
 }
 
+/// `ToNumber` for the native boxed runtime: a `Value::Number` passes through, every other variant
+/// coerces to `NaN`. This is the same `as_number().unwrap_or(NaN)` convention used by the
+/// interpreter (`binop_number` / `to_int32`), the VM (`eval_binop`), and `ops::add`/`sub`/`mul`/`div`
+/// — so the native backend stays bit-for-bit in lock-step with them at runtime (a string/bool/null
+/// operand is `NaN`, hence `0` for bitwise). The compiler constant-folds literal cases like
+/// `"5" | 0 === 5` separately, so this only governs runtime (non-constant) operands.
+#[inline]
+pub fn to_number_value(v: &Value) -> f64 {
+    v.as_number().unwrap_or(f64::NAN)
+}
+
+/// `ToInt32` of an arbitrary [`Value`] (coerce via [`to_number_value`], then [`to_int32`]). Designed
+/// to compose in generated code: unlike a `let Value::Number(a) = &(..) else { panic!() }` block,
+/// it binds no name, so nested bitwise/shift operands can never shadow each other.
+#[inline]
+pub fn to_int32_value(v: &Value) -> i32 {
+    to_int32(to_number_value(v))
+}
+
+/// `ToUint32` companion to [`to_int32_value`].
+#[inline]
+pub fn to_uint32_value(v: &Value) -> u32 {
+    to_uint32(to_number_value(v))
+}
+
 /// Invoke a callable [`Value`]: [`Value::Function`], or an object exposing `__call` (e.g. `Symbol`).
 pub fn value_call(callee: &Value, args: &[Value]) -> Value {
     match callee {
@@ -910,20 +935,36 @@ impl std::fmt::Debug for Value {
 /// We take the shortest round-tripping digits from Rust's `{:e}` (a Ryū/Grisu-class shortest
 /// formatter, matching V8's digit choice) and lay them out per the ECMAScript rule: plain
 /// decimal when the point position `n` is in `(-6, 21]`, otherwise `d[.ddd]e±E` with `E = n-1`
-/// (sign always shown, no leading zeros in the exponent). `-0` renders as `"-0"` (matching
-/// `console.log` and tish's existing behavior).
+/// (sign always shown, no leading zeros in the exponent). This is the ECMAScript `Number::toString`
+/// used by `.toString()`, `String(n)`, `+` concatenation, and template literals, so `-0` renders as
+/// `"0"` (the sign is dropped — `(-0).toString() === "0"`). The *inspect* form (`console.log` of a
+/// bare number / array element) keeps `"-0"`; that distinction lives in [`Value::to_display_string`].
 pub fn js_number_to_string(value: f64) -> String {
+    let mut out = String::new();
+    js_number_to_string_into(&mut out, value);
+    out
+}
+
+/// Append the ECMAScript `Number::toString` of `value` to `out` — identical result to
+/// [`js_number_to_string`] but with no intermediate `String` allocation. The JSON.stringify
+/// hot path appends millions of numbers into a single buffer, so the alloc-free form matters.
+pub fn js_number_to_string_into(out: &mut String, value: f64) {
     if value.is_nan() {
-        return "NaN".to_string();
+        out.push_str("NaN");
+        return;
     }
     if value == f64::INFINITY {
-        return "Infinity".to_string();
+        out.push_str("Infinity");
+        return;
     }
     if value == f64::NEG_INFINITY {
-        return "-Infinity".to_string();
+        out.push_str("-Infinity");
+        return;
     }
     if value == 0.0 {
-        return if value.is_sign_negative() { "-0" } else { "0" }.to_string();
+        // ECMAScript `Number::toString`: both `+0` and `-0` stringify to `"0"`.
+        out.push('0');
+        return;
     }
 
     let negative = value < 0.0;
@@ -939,7 +980,6 @@ pub fn js_number_to_string(value: f64) -> String {
     let k = digits.len() as i32; // significant digit count (≤ 17 for an f64)
     let point = exp + 1; // ECMAScript's `n`: value = digits × 10^(point − k)
 
-    let mut out = String::new();
     if negative {
         out.push('-');
     }
@@ -969,13 +1009,15 @@ pub fn js_number_to_string(value: f64) -> String {
         out.push(if e >= 0 { '+' } else { '-' });
         out.push_str(&e.abs().to_string());
     }
-    out
 }
 
 impl Value {
     /// Convert value to display string (for console output).
     pub fn to_display_string(&self) -> String {
         match self {
+            // Inspect form keeps the sign of negative zero (`console.log(-0)` → `-0`), unlike the
+            // ECMAScript ToString used by `to_js_string`. See `js_number_to_string`. (#247)
+            Value::Number(n) if *n == 0.0 && n.is_sign_negative() => "-0".to_string(),
             Value::Number(n) => js_number_to_string(*n),
             Value::String(s) => s.to_string(),
             Value::Bool(b) => b.to_string(),
@@ -1046,6 +1088,9 @@ impl Value {
                 .collect::<Vec<_>>()
                 .join(","),
             Value::Object(_) => "[object Object]".to_string(),
+            // ECMAScript ToString of a number (drops `-0`'s sign), distinct from the inspect form
+            // that `to_display_string` would give for `-0`. (#247)
+            Value::Number(n) => js_number_to_string(*n),
             // Primitives (and the remaining cases) coincide with the display form.
             _ => self.to_display_string(),
         }
@@ -1148,12 +1193,18 @@ impl Value {
     // -------------------------------------------------------------------------
 
     /// Whether packed f64 arrays are enabled this run. Default: **off** (`TISH_PACKED_ARRAYS=1`
-    /// opts in). Checked at every creation site so flag changes take effect per-process.
+    /// opts in). Read once per process and cached — the VM calls this once per executed array
+    /// literal, and a `std::env::var` there is a libc env lock plus a `String` allocation per
+    /// `NewArray` for a flag that never changes after startup (#166). Set the variable before the
+    /// process starts (as the CI sweep does); mid-process toggling is not observed by design.
     /// The flag is intentionally backwards from the slot/JIT flags (those were default-on) to
     /// keep the default binary behaviour byte-identical while we validate coverage.
     #[inline]
     pub fn packed_arrays_enabled() -> bool {
-        std::env::var("TISH_PACKED_ARRAYS").map(|v| v == "1").unwrap_or(false)
+        static PACKED_ARRAYS: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+        *PACKED_ARRAYS.get_or_init(|| {
+            std::env::var("TISH_PACKED_ARRAYS").map(|v| v == "1").unwrap_or(false)
+        })
     }
 
     /// Wrap a `Vec<f64>` as a `Value::NumberArray`. Only call when `packed_arrays_enabled()`.
@@ -1310,9 +1361,11 @@ mod number_to_string_tests {
     #[test]
     fn matches_javascript_number_tostring() {
         // (value, expected) — every `expected` is what Node's `String(value)` produces.
+        // `String(-0) === "0"`: ToString drops the sign of negative zero (the inspect form keeps
+        // it, but that path is `Value::to_display_string`, not this function). (#247)
         let cases: &[(f64, &str)] = &[
             (0.0, "0"),
-            (-0.0, "-0"),
+            (-0.0, "0"),
             (123.0, "123"),
             (123.456, "123.456"),
             (0.5, "0.5"),

package/crates/tish_eval/src/eval.rs

@@ -144,6 +144,11 @@ impl Evaluator {
             math.insert("round".into(), Value::Native(natives::math_round));
             math.insert("random".into(), Value::Native(natives::math_random));
             math.insert("pow".into(), Value::Native(natives::math_pow));
+            math.insert("hypot".into(), Value::Native(natives::math_hypot));
+            math.insert("asin".into(), Value::Native(natives::math_asin));
+            math.insert("acos".into(), Value::Native(natives::math_acos));
+            math.insert("atan".into(), Value::Native(natives::math_atan));
+            math.insert("atan2".into(), Value::Native(natives::math_atan2));
             math.insert("sin".into(), Value::Native(natives::math_sin));
             math.insert("cos".into(), Value::Native(natives::math_cos));
             math.insert("tan".into(), Value::Native(natives::math_tan));
@@ -180,6 +185,26 @@ impl Evaluator {
                 true,
             );
 
+            // Bare `process` global (node-compatible), mirroring the VM. `process.argv` reads the
+            // configurable argv so `tish run <file> [args...]` reaches the script. #88
+            #[cfg(feature = "process")]
+            {
+                let mut process_obj = PropMap::default();
+                process_obj.insert("exit".into(), Value::Native(natives::process_exit));
+                process_obj.insert("cwd".into(), Value::Native(natives::process_cwd));
+                process_obj.insert("exec".into(), Value::Native(natives::process_exec));
+                let argv: Vec<Value> = tishlang_core::process_argv()
+                    .into_iter()
+                    .map(|s| Value::String(s.into()))
+                    .collect();
+                process_obj.insert("argv".into(), Value::Array(Rc::new(RefCell::new(argv))));
+                let env_obj: PropMap = std::env::vars()
+                    .map(|(k, v)| (Arc::from(k.as_str()), Value::String(v.into())))
+                    .collect();
+                process_obj.insert("env".into(), Value::object(env_obj));
+                s.set("process".into(), Value::object(process_obj), true);
+            }
+
             let mut object = PropMap::with_capacity(5);
             object.insert("keys".into(), Value::Native(Self::object_keys));
             object.insert("values".into(), Value::Native(Self::object_values));
@@ -1032,8 +1057,10 @@ impl Evaluator {
                     exports.insert("exit".into(), Value::Native(natives::process_exit));
                     exports.insert("cwd".into(), Value::Native(natives::process_cwd));
                     exports.insert("exec".into(), Value::Native(natives::process_exec));
-                    let argv: Vec<Value> =
-                        std::env::args().map(|s| Value::String(s.into())).collect();
+                    let argv: Vec<Value> = tishlang_core::process_argv()
+                        .into_iter()
+                        .map(|s| Value::String(s.into()))
+                        .collect();
                     exports.insert(
                         "argv".into(),
                         Value::Array(Rc::new(RefCell::new(argv.clone()))),
@@ -1106,11 +1133,35 @@ impl Evaluator {
                 op,
                 right,
                 ..
-            } => {
-                let l = self.eval_expr(left)?;
-                let r = self.eval_expr(right)?;
-                self.eval_binop(&l, *op, &r).map_err(EvalError::Error)
-            }
+            } => match op {
+                // Short-circuit + value-returning && / || (JS, #240): evaluate the left; if it
+                // already decides the result, return IT without evaluating (and running the side
+                // effects of) the right. The result is always an operand value, never a coerced
+                // boolean. The generic path below eagerly evaluated both operands and `eval_binop`
+                // coerced And/Or to `Bool`, so `five() && 7` was `true` and `false && f()` still
+                // ran `f()`.
+                BinOp::And => {
+                    let l = self.eval_expr(left)?;
+                    if l.is_truthy() {
+                        self.eval_expr(right)
+                    } else {
+                        Ok(l)
+                    }
+                }
+                BinOp::Or => {
+                    let l = self.eval_expr(left)?;
+                    if l.is_truthy() {
+                        Ok(l)
+                    } else {
+                        self.eval_expr(right)
+                    }
+                }
+                _ => {
+                    let l = self.eval_expr(left)?;
+                    let r = self.eval_expr(right)?;
+                    self.eval_binop(&l, *op, &r).map_err(EvalError::Error)
+                }
+            },
             Expr::Unary { op, operand, .. } => {
                 let o = self.eval_expr(operand)?;
                 self.eval_unary(*op, &o).map_err(EvalError::Error)
@@ -1173,7 +1224,11 @@ impl Evaluator {
                                     _ => 0,
                                 };
                                 for v in arr_borrow.iter().skip(start) {
-                                    if v.strict_eq(&search) {
+                                    // SameValueZero: NaN matches NaN (JS Array.includes, unlike
+                                    // indexOf). #247
+                                    if v.strict_eq(&search)
+                                        || matches!((v, &search), (Value::Number(a), Value::Number(b)) if a.is_nan() && b.is_nan())
+                                    {
                                         return Ok(Value::Bool(true));
                                     }
                                 }
@@ -1496,6 +1551,54 @@ impl Evaluator {
                                 }
                                 return Ok(Value::Number(-1.0));
                             }
+                            "findLast" => {
+                                // Like find, from the end (#247). Callback gets (value, original index).
+                                let callback = arg_vals.first().cloned().unwrap_or(Value::Null);
+                                let arr_borrow = arr.borrow();
+                                let scoped = self.create_callback_scope(&callback);
+                                for i in (0..arr_borrow.len()).rev() {
+                                    let v = arr_borrow[i].clone();
+                                    let args = [v.clone(), Value::Number(i as f64)];
+                                    let found = match &scoped {
+                                        Some((scope, params, body)) => self.call_with_scope(scope, params, body, &args)?,
+                                        None => self.call_func(&callback, &args)?,
+                                    };
+                                    if found.is_truthy() {
+                                        return Ok(v);
+                                    }
+                                }
+                                return Ok(Value::Null);
+                            }
+                            "findLastIndex" => {
+                                let callback = arg_vals.first().cloned().unwrap_or(Value::Null);
+                                let arr_borrow = arr.borrow();
+                                let scoped = self.create_callback_scope(&callback);
+                                for i in (0..arr_borrow.len()).rev() {
+                                    let args = [arr_borrow[i].clone(), Value::Number(i as f64)];
+                                    let found = match &scoped {
+                                        Some((scope, params, body)) => self.call_with_scope(scope, params, body, &args)?,
+                                        None => self.call_func(&callback, &args)?,
+                                    };
+                                    if found.is_truthy() {
+                                        return Ok(Value::Number(i as f64));
+                                    }
+                                }
+                                return Ok(Value::Number(-1.0));
+                            }
+                            "at" => {
+                                // Negative index counts from the end; out of range → null (#247).
+                                let i = match arg_vals.first() {
+                                    Some(Value::Number(n)) => *n as i64,
+                                    _ => 0,
+                                };
+                                let arr_borrow = arr.borrow();
+                                let len = arr_borrow.len() as i64;
+                                let idx = if i < 0 { len + i } else { i };
+                                if idx >= 0 && idx < len {
+                                    return Ok(arr_borrow[idx as usize].clone());
+                                }
+                                return Ok(Value::Null);
+                            }
                             "forEach" => {
                                 let callback = arg_vals.first().cloned().unwrap_or(Value::Null);
                                 let arr_borrow = arr.borrow();
@@ -1788,6 +1891,20 @@ impl Evaluator {
                                     .map(|c| Value::String(c.to_string().into()))
                                     .unwrap_or(Value::String("".into())));
                             }
+                            "at" => {
+                                // Negative index from end; out of range → null (#247).
+                                let i = match arg_vals.first() {
+                                    Some(Value::Number(n)) => *n as i64,
+                                    _ => 0,
+                                };
+                                let chars: Vec<char> = s.chars().collect();
+                                let len = chars.len() as i64;
+                                let idx = if i < 0 { len + i } else { i };
+                                if idx >= 0 && idx < len {
+                                    return Ok(Value::String(chars[idx as usize].to_string().into()));
+                                }
+                                return Ok(Value::Null);
+                            }
                             "charCodeAt" => {
                                 let idx = match arg_vals.first() {
                                     Some(Value::Number(n)) => *n as usize,
@@ -1868,7 +1985,8 @@ impl Evaluator {
                                 })
                                 .unwrap_or(0)
                                 .clamp(0, 20); // ECMA-262: 0–20
-                            let formatted = format!("{:.*}", digits as usize, n);
+                            // Shared half-away-from-zero rounding so interp matches vm/native/node (#247).
+                            let formatted = tishlang_builtins::number::to_fixed_str(*n, digits as usize);
                             return Ok(Value::String(formatted.into()));
                         }
                         if method_name.as_ref() == "toString" {
@@ -2011,7 +2129,7 @@ impl Evaluator {
                 let mut data = EvalObjectData::default();
                 for prop in props {
                     match prop {
-                        tishlang_ast::ObjectProp::KeyValue(k, v) => {
+                        tishlang_ast::ObjectProp::KeyValue(k, v, _) => {
                             data
                                 .strings
                                 .insert(Arc::clone(k), self.eval_expr(v)?);
@@ -3546,188 +3664,16 @@ impl Evaluator {
     }
 
     fn json_parse(s: &str) -> Value {
-        let s = s.trim();
-        if s.is_empty() {
-            return Value::Null;
-        }
-        match Self::json_parse_str(s) {
-            Ok(v) => v,
-            Err(()) => Value::Null,
-        }
-    }
-
-    fn json_parse_str(s: &str) -> Result<Value, ()> {
-        let s = s.trim();
-        if s.is_empty() {
-            return Err(());
-        }
-        if s == "null" {
-            return Ok(Value::Null);
-        }
-        if s == "true" {
-            return Ok(Value::Bool(true));
-        }
-        if s == "false" {
-            return Ok(Value::Bool(false));
-        }
-        if s.starts_with('"') {
-            return Self::json_parse_string_full(s);
-        }
-        if s.starts_with('[') {
-            return Self::json_parse_array(s);
-        }
-        if s.starts_with('{') {
-            return Self::json_parse_object(s);
-        }
-        if let Ok(n) = s.parse::<f64>() {
-            return Ok(Value::Number(n));
-        }
-        Err(())
-    }
-
-    fn json_parse_string(s: &str) -> Result<(Value, &str), ()> {
-        let s = &s[1..];
-        let mut out = String::new();
-        let mut i = 0;
-        let chars: Vec<char> = s.chars().collect();
-        while i < chars.len() {
-            if chars[i] == '"' {
-                let rest_start = s.chars().take(i + 1).map(|c| c.len_utf8()).sum::<usize>();
-                return Ok((Value::String(out.into()), &s[rest_start..]));
-            }
-            if chars[i] == '\\' {
-                i += 1;
-                if i >= chars.len() {
-                    return Err(());
-                }
-                match chars[i] {
-                    '"' => out.push('"'),
-                    '\\' => out.push('\\'),
-                    'n' => out.push('\n'),
-                    'r' => out.push('\r'),
-                    't' => out.push('\t'),
-                    _ => return Err(()),
-                }
-            } else {
-                out.push(chars[i]);
-            }
-            i += 1;
-        }
-        Err(())
-    }
-
-    fn json_parse_string_full(s: &str) -> Result<Value, ()> {
-        Self::json_parse_string(s).map(|(v, _)| v)
-    }
-
-    fn json_parse_array(s: &str) -> Result<Value, ()> {
-        let s = s[1..].trim_start();
-        if s.starts_with(']') {
-            return Ok(Value::Array(Rc::new(RefCell::new(vec![]))));
-        }
-        let mut vals = Vec::new();
-        let mut rest = s;
-        loop {
-            let (v, next) = Self::json_parse_one(rest)?;
-            vals.push(v);
-            rest = next.trim_start();
-            if rest.starts_with(']') {
-                break;
-            }
-            if !rest.starts_with(',') {
-                return Err(());
-            }
-            rest = rest[1..].trim_start();
-        }
-        Ok(Value::Array(Rc::new(RefCell::new(vals))))
-    }
-
-    fn json_parse_object(s: &str) -> Result<Value, ()> {
-        let s = s[1..].trim_start();
-        if s.starts_with('}') {
-            return Ok(Value::object(PropMap::default()));
-        }
-        let mut map = PropMap::default();
-        let mut rest = s;
-        loop {
-            if !rest.starts_with('"') {
-                return Err(());
-            }
-            let (key_val, next) = Self::json_parse_string(rest)?;
-            let key = match &key_val {
-                Value::String(k) => Arc::clone(k),
-                _ => return Err(()),
-            };
-            rest = next.trim_start();
-            if !rest.starts_with(':') {
-                return Err(());
-            }
-            rest = rest[1..].trim_start();
-            let (val, next) = Self::json_parse_one(rest)?;
-            map.insert(key, val);
-            rest = next.trim_start();
-            if rest.starts_with('}') {
-                break;
-            }
-            if !rest.starts_with(',') {
-                return Err(());
-            }
-            rest = rest[1..].trim_start();
-        }
-        Ok(Value::object(map))
-    }
-
-    fn json_parse_one(s: &str) -> Result<(Value, &str), ()> {
-        let s = s.trim();
-        if s.is_empty() {
-            return Err(());
-        }
-        if s.starts_with('"') {
-            let (v, rest) = Self::json_parse_string(s)?;
-            Ok((v, rest))
-        } else if s.starts_with('[') {
-            let mut depth = 0;
-            for (i, c) in s.char_indices() {
-                if c == '[' {
-                    depth += 1;
-                } else if c == ']' {
-                    depth -= 1;
-                    if depth == 0 {
-                        let v = Self::json_parse_array(&s[..=i])?;
-                        return Ok((v, &s[i + c.len_utf8()..]));
-                    }
-                }
-            }
-            Err(())
-        } else if s.starts_with('{') {
-            let mut depth = 0;
-            for (i, c) in s.char_indices() {
-                if c == '{' {
-                    depth += 1;
-                } else if c == '}' {
-                    depth -= 1;
-                    if depth == 0 {
-                        let v = Self::json_parse_object(&s[..=i])?;
-                        return Ok((v, &s[i + c.len_utf8()..]));
-                    }
-                }
-            }
-            Err(())
-        } else if let Some(rest) = s.strip_prefix("null") {
-            Ok((Value::Null, rest))
-        } else if let Some(rest) = s.strip_prefix("true") {
-            Ok((Value::Bool(true), rest))
-        } else if let Some(rest) = s.strip_prefix("false") {
-            Ok((Value::Bool(false), rest))
-        } else {
-            let end = s
-                .find(|c: char| {
-                    !c.is_ascii_digit() && c != '-' && c != '+' && c != '.' && c != 'e' && c != 'E'
-                })
-                .unwrap_or(s.len());
-            let num_str = &s[..end];
-            let n: f64 = num_str.parse().map_err(|_| ())?;
-            Ok((Value::Number(n), &s[end..]))
+        // Delegate to the shared, spec-correct parser in `tishlang_core` and convert into
+        // interpreter Values — one source of truth with the VM/native/cranelift/wasi backends.
+        // The previous hand-rolled parser depth-counted `{}`/`[]` brackets WITHOUT skipping string
+        // contents, so a nested value whose string held `}`/`]`/`{`/`[` (e.g. `{"a":{"s":"}"}}`)
+        // mis-sliced and the whole parse failed to `null` where Node/VM succeed; it also re-scanned
+        // each nested value O(n^2). The core parser is string-aware and builds insertion-ordered
+        // PropMaps. Invalid input still yields `null` (unchanged interpreter behavior).
+        match tishlang_core::json_parse(s) {
+            Ok(core) => crate::value_convert::core_to_eval(core),
+            Err(_) => Value::Null,
         }
     }
 
@@ -3736,11 +3682,12 @@ impl Evaluator {
             Value::Null => "null".to_string(),
             Value::Bool(b) => b.to_string(),
             Value::Number(n) => {
-                if n.is_finite() {
-                    n.to_string()
-                } else {
-                    "null".to_string()
-                }
+                // Format numbers exactly like the VM/native path (shared helper) so JSON output
+                // matches across backends and Node — Rust's `{}` Display diverges (e.g. `1e21`,
+                // `1e-7`, `-0`). #180.
+                let mut s = String::new();
+                tishlang_core::write_json_number(&mut s, *n);
+                s
             }
             Value::String(s) => format!(
                 "\"{}\"",

package/crates/tish_eval/src/natives.rs

@@ -56,26 +56,14 @@ fn get_log_level() -> u8 {
 
 pub fn parse_int(args: &[Value]) -> Result<Value, String> {
     let s = args.first().map(|v| v.to_string()).unwrap_or_default();
-    let s = s.trim();
-    let radix = args
-        .get(1)
-        .and_then(|v| match v {
-            Value::Number(n) => Some(*n as i32),
-            _ => None,
-        })
-        .unwrap_or(10);
-    let n = if (2..=36).contains(&radix) {
-        let prefix: String = s
-            .chars()
-            .take_while(|c| *c == '-' || *c == '+' || c.is_digit(radix as u32))
-            .collect();
-        i64::from_str_radix(&prefix, radix as u32)
-            .ok()
-            .map(|n| n as f64)
-    } else {
-        None
-    };
-    Ok(Value::Number(n.unwrap_or(f64::NAN)))
+    let radix = args.get(1).and_then(|v| match v {
+        Value::Number(n) => Some(*n as i32),
+        _ => None,
+    });
+    // Shared semantics (0x stripping, sign, auto-radix) — see js_parse_int (#247).
+    Ok(Value::Number(tishlang_builtins::globals::js_parse_int(
+        &s, radix,
+    )))
 }
 
 pub fn parse_float(args: &[Value]) -> Result<Value, String> {
@@ -168,32 +156,44 @@ pub fn math_sqrt(args: &[Value]) -> Result<Value, String> {
     ))
 }
 
+// The JS-specific min/max/round semantics live in the shared `tishlang_builtins::math` f64 helpers
+// (#247) — the interpreter uses a different `Value` type, so it extracts its own args and calls those
+// helpers, keeping interp/vm/native bit-identical without duplicating the rules.
 pub fn math_min(args: &[Value]) -> Result<Value, String> {
-    let nums: Vec<f64> = args
-        .iter()
-        .filter_map(|v| match v {
-            Value::Number(n) => Some(*n),
-            _ => None,
-        })
-        .collect();
-    let n = nums.into_iter().fold(f64::INFINITY, f64::min);
-    Ok(Value::Number(if n == f64::INFINITY { f64::NAN } else { n }))
+    let nums: Vec<f64> = args.iter().map(get_num).collect();
+    Ok(Value::Number(tishlang_builtins::math::min_f64(&nums)))
 }
 
 pub fn math_max(args: &[Value]) -> Result<Value, String> {
-    let nums: Vec<f64> = args
-        .iter()
-        .filter_map(|v| match v {
-            Value::Number(n) => Some(*n),
-            _ => None,
-        })
-        .collect();
-    let n = nums.into_iter().fold(f64::NEG_INFINITY, f64::max);
-    Ok(Value::Number(if n == f64::NEG_INFINITY {
-        f64::NAN
-    } else {
-        n
-    }))
+    let nums: Vec<f64> = args.iter().map(get_num).collect();
+    Ok(Value::Number(tishlang_builtins::math::max_f64(&nums)))
+}
+
+// hypot/asin/acos/atan/atan2 existed on the vm's Math but not the interpreter's — a direct interp≠vm
+// gap (#247). These are 1:1 with Rust f64 methods (same as the builtins), so compute directly; hypot
+// defaults missing args to 0.0 to match `tishlang_builtins::math::hypot`.
+pub fn math_hypot(args: &[Value]) -> Result<Value, String> {
+    let x = args.first().map(get_num).unwrap_or(0.0);
+    let y = args.get(1).map(get_num).unwrap_or(0.0);
+    Ok(Value::Number(x.hypot(y)))
+}
+
+pub fn math_asin(args: &[Value]) -> Result<Value, String> {
+    Ok(Value::Number(get_num(args.first().unwrap_or(&Value::Null)).asin()))
+}
+
+pub fn math_acos(args: &[Value]) -> Result<Value, String> {
+    Ok(Value::Number(get_num(args.first().unwrap_or(&Value::Null)).acos()))
+}
+
+pub fn math_atan(args: &[Value]) -> Result<Value, String> {
+    Ok(Value::Number(get_num(args.first().unwrap_or(&Value::Null)).atan()))
+}
+
+pub fn math_atan2(args: &[Value]) -> Result<Value, String> {
+    let y = get_num(args.first().unwrap_or(&Value::Null));
+    let x = get_num(args.get(1).unwrap_or(&Value::Null));
+    Ok(Value::Number(y.atan2(x)))
 }
 
 pub fn math_floor(args: &[Value]) -> Result<Value, String> {
@@ -209,9 +209,9 @@ pub fn math_ceil(args: &[Value]) -> Result<Value, String> {
 }
 
 pub fn math_round(args: &[Value]) -> Result<Value, String> {
-    Ok(Value::Number(
-        get_num(args.first().unwrap_or(&Value::Null)).round(),
-    ))
+    Ok(Value::Number(tishlang_builtins::math::round_f64(get_num(
+        args.first().unwrap_or(&Value::Null),
+    ))))
 }
 
 pub fn math_random(_args: &[Value]) -> Result<Value, String> {