@tishlang/tish 2.2.5 → 2.8.0

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> {

package/crates/tish_eval/src/regex.rs

@@ -254,46 +254,54 @@ pub fn string_split(input: &str, separator: &Value, limit: Option<usize>) -> Val
         return Value::Array(Rc::new(RefCell::new(Vec::new())));
     }
 
-    match separator {
+    // JS semantics in every branch: split the string fully, then truncate the result to `limit`.
+    // (Rust's `splitn` keeps the unsplit remainder in the last slot — that's Python-style maxsplit,
+    // not JS — so we must split fully and `truncate`. `truncate(usize::MAX)` is a no-op for the
+    // no-limit case.) This mirrors `tish_builtins::string::split_limit` /
+    // `tishlang_runtime::string_split_regex` so interp, vm, and the native backends agree.
+    let mut result: Vec<Value> = match separator {
         Value::RegExp(re) => {
             let re = re.borrow();
-            let mut result = Vec::new();
+            let mut parts = Vec::new();
             let mut last_end = 0;
-
             for mat in re.regex.find_iter(input) {
                 match mat {
                     Ok(m) => {
-                        if result.len() >= max - 1 {
-                            break;
-                        }
-                        result.push(Value::String(input[last_end..m.start()].into()));
+                        parts.push(Value::String(input[last_end..m.start()].into()));
                         last_end = m.end();
                     }
                     Err(_) => break,
                 }
             }
-
-            if result.len() < max {
-                result.push(Value::String(input[last_end..].into()));
-            }
-
-            Value::Array(Rc::new(RefCell::new(result)))
-        }
-        Value::String(sep) => {
-            let parts: Vec<Value> = input
-                .splitn(max, sep.as_ref())
-                .map(|s| Value::String(s.into()))
-                .collect();
-            Value::Array(Rc::new(RefCell::new(parts)))
+            parts.push(Value::String(input[last_end..].into()));
+            parts
         }
-        Value::Null => Value::Array(Rc::new(RefCell::new(vec![Value::String(input.into())]))),
+        // JS `split("")` → the string's chars with no surrounding empties (`"".split("")` → `[]`),
+        // unlike Rust's `str::split("")`. Mirrors `tish_builtins::string::split_limit`. #247
+        Value::String(sep) if sep.is_empty() => input
+            .chars()
+            .map(|c| Value::String(c.to_string().into()))
+            .collect(),
+        Value::String(sep) => input
+            .split(sep.as_ref())
+            .map(|s| Value::String(s.into()))
+            .collect(),
+        Value::Null => vec![Value::String(input.into())],
         _ => {
             let sep_str = separator.to_string();
-            let parts: Vec<Value> = input
-                .splitn(max, &sep_str)
-                .map(|s| Value::String(s.into()))
-                .collect();
-            Value::Array(Rc::new(RefCell::new(parts)))
+            if sep_str.is_empty() {
+                input
+                    .chars()
+                    .map(|c| Value::String(c.to_string().into()))
+                    .collect()
+            } else {
+                input
+                    .split(&sep_str)
+                    .map(|s| Value::String(s.into()))
+                    .collect()
+            }
         }
-    }
+    };
+    result.truncate(max);
+    Value::Array(Rc::new(RefCell::new(result)))
 }

package/crates/tish_eval/src/value.rs

@@ -197,6 +197,10 @@ impl std::fmt::Debug for Value {
 impl std::fmt::Display for Value {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            // Inspect form (`console.log`): keeps the sign of negative zero, unlike the ECMAScript
+            // ToString used by `to_js_string`. Matches Node's console output (`console.log(-0)` →
+            // `-0`). `to_js_string` has an explicit `Number` arm so ToString still drops it. (#247)
+            Value::Number(n) if *n == 0.0 && n.is_sign_negative() => write!(f, "-0"),
             // Match JS `Number.prototype.toString` (exponential past digit 21 / before −6),
             // shared with the VM/native path via `tishlang_core`.
             Value::Number(n) => write!(f, "{}", tishlang_core::js_number_to_string(*n)),
@@ -279,6 +283,10 @@ impl Value {
                 .collect::<Vec<_>>()
                 .join(","),
             Value::Object(_) => "[object Object]".to_string(),
+            // ECMAScript ToString of a number drops `-0`'s sign (`String(-0) === "0"`), distinct
+            // from the inspect `Display` above which keeps it. Explicit arm so the `_` fallback to
+            // `to_string()` (inspect) is not used for numbers. (#247)
+            Value::Number(n) => tishlang_core::js_number_to_string(*n),
             _ => self.to_string(),
         }
     }