@tishlang/tish 2.2.7 → 2.9.0

package/crates/js_to_tish/src/transform/expr.rs

@@ -350,7 +350,11 @@ fn convert_object_prop(
                 }
             });
             let value = convert_expr(&prop.value, ctx)?;
-            Ok(ObjectProp::KeyValue(Arc::from(key.as_str()), value))
+            Ok(ObjectProp::KeyValue(
+                Arc::from(key.as_str()),
+                value,
+                tishlang_ast::Span::default(),
+            ))
         }
     }
 }

package/crates/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang"
-version = "2.2.7"
+version = "2.9.0"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }
@@ -64,3 +64,4 @@ mimalloc = { version = "0.1", optional = true }
 
 [dev-dependencies]
 rayon = "1.11"
+tempfile = "3"

package/crates/tish/src/cli_help.rs

@@ -406,6 +406,9 @@ pub fn build_after_help() -> String {
           JavaScript bundle
   {t}wasm{r}
           WebAssembly (.tish project; .js source supported on some paths)
+  {t}wasm-gpu{r}
+          WebAssembly + the WebGPU reflection bridge — emits a start(chunk, host) loader that
+          bootstraps WebGPU (device/queue/context/canvas) into the `host` global your program reads
   {t}wasi{r}
           WASI WebAssembly
   {t}bytecode{r}
@@ -479,6 +482,15 @@ pub(crate) struct RunArgs {
     /// Disable AST and bytecode optimizations (for debugging).
     #[arg(long, help_heading = "Options")]
     pub no_optimize: bool,
+    /// Arguments passed through to the script as `process.argv` (after the file). Like
+    /// `node main.js a b`, options for `tish` itself must come BEFORE the file. #88
+    #[arg(
+        trailing_var_arg = true,
+        allow_hyphen_values = true,
+        value_name = "ARGS",
+        help_heading = "Arguments"
+    )]
+    pub script_args: Vec<String>,
 }
 
 #[derive(Parser)]
@@ -548,6 +560,9 @@ pub(crate) struct BuildArgs {
     /// For `--target js` project builds: emit `OUTPUT.js.map` and `//# sourceMappingURL=…` so JS/TS tools can jump to original `.tish` (implies `--no-optimize` for that build).
     #[arg(long, help_heading = "Options")]
     pub source_map: bool,
+    /// For `--target js`: `bundle` (default) merges all modules into one file; `esm` emits one `.js` per `.tish` module with real `import`/`export` (so `-o` is a directory) for Vite/Rollup tree-shaking.
+    #[arg(long, default_value = "bundle", value_name = "FORMAT", help_heading = "Options")]
+    pub format: String,
     /// Run the gradual type checker: `warn` prints `line:col` type diagnostics; `error` also fails the build on them. (Equivalent to setting `TISH_CHECK`.)
     #[arg(long, value_name = "MODE", help_heading = "Options")]
     pub check: Option<String>,

package/crates/tish/src/main.rs

@@ -107,12 +107,18 @@ fn main() {
     let matches = cli_help::build_command().get_matches_from(&argv);
     let cli = Cli::from_arg_matches(&matches).unwrap_or_else(|e| e.exit());
     let result = match cli.command {
-        Some(Commands::Run(a)) => run_file(
-            &a.file,
-            &a.backend,
-            &a.features,
-            a.no_optimize || no_opt_env,
-        ),
+        Some(Commands::Run(a)) => {
+            // Expose a node-shaped `process.argv` to the script: `[tish-exe, <file>, args...]`,
+            // so `tish run main.tish a b` gives the script `["…/tish", "main.tish", "a", "b"]`
+            // (not the `run` subcommand). Interp/VM read this via `tishlang_core::process_argv`. #88
+            let exe = std::env::args().next().unwrap_or_else(|| "tish".to_string());
+            let mut argv = Vec::with_capacity(a.script_args.len() + 2);
+            argv.push(exe);
+            argv.push(a.file.clone());
+            argv.extend(a.script_args.iter().cloned());
+            tishlang_core::set_process_argv(argv);
+            run_file(&a.file, &a.backend, &a.features, a.no_optimize || no_opt_env)
+        }
         Some(Commands::Repl(a)) => run_repl(&a.backend, a.no_optimize || no_opt_env, &a.features),
         Some(Commands::Build(a)) => {
             // `--check warn|error` drives the gradual type checker via the same channel as the
@@ -130,6 +136,7 @@ fn main() {
                 a.source_map,
                 a.ios_triple.as_deref(),
                 &a.crate_type,
+                &a.format,
             )
         }
         Some(Commands::DumpAst {
@@ -535,7 +542,14 @@ fn compile_to_js(
     output_path: &str,
     optimize: bool,
     source_map: bool,
+    format: &str,
 ) -> Result<(), String> {
+    if format != "bundle" && format != "esm" {
+        return Err(format!(
+            "Unknown --format '{}' for --target js. Use 'bundle' (single merged file) or 'esm' (one file per module).",
+            format
+        ));
+    }
     if source_map && optimize {
         return Err(
             "tish build --target js --source-map requires --no-optimize (mappings follow unmerged statement order)."
@@ -558,6 +572,9 @@ fn compile_to_js(
             Some(p)
         }
     });
+    if format == "esm" {
+        return compile_to_js_esm(input_path, output_path, optimize, source_map, project_root);
+    }
     let out_path = Path::new(output_path);
     let out_path = if out_path.extension().is_none()
         || out_path.extension() == Some(std::ffi::OsStr::new(""))
@@ -629,6 +646,63 @@ fn compile_to_js(
     Ok(())
 }
 
+/// `--target js --format esm`: emit one `.js` per `.tish` module under the output directory,
+/// preserving the source tree layout, with real ES `import`/`export` so a bundler (Vite/Rollup)
+/// can tree-shake and code-split. `-o` is treated as a directory.
+fn compile_to_js_esm(
+    input_path: &Path,
+    output_path: &str,
+    optimize: bool,
+    source_map: bool,
+    project_root: Option<&Path>,
+) -> Result<(), String> {
+    if source_map {
+        return Err(
+            "tish build --target js --format esm does not yet support --source-map; use --format bundle for source maps."
+                .into(),
+        );
+    }
+    if input_path.extension().map(|e| e == "jsx") == Some(true)
+        || input_path.extension().map(|e| e == "js") == Some(true)
+    {
+        return Err(
+            "tish build --target js --format esm is only supported for .tish entry files; use --format bundle for .jsx / .js inputs."
+                .into(),
+        );
+    }
+    let modules = tishlang_compile_js::compile_project_esm(input_path, project_root, optimize)
+        .map_err(|e| format!("{}", e))?;
+    let out_dir = Path::new(output_path);
+    fs::create_dir_all(out_dir)
+        .map_err(|e| format!("Cannot create output directory {}: {}", out_dir.display(), e))?;
+    for module in &modules {
+        let out = out_dir.join(&module.relative_path);
+        if let Some(parent) = out.parent() {
+            fs::create_dir_all(parent)
+                .map_err(|e| format!("Cannot create output directory {}: {}", parent.display(), e))?;
+        }
+        fs::write(&out, &module.js)
+            .map_err(|e| format!("Cannot write {}: {}", out.display(), e))?;
+    }
+    println!("Built {} module(s) to {}", modules.len(), out_dir.display());
+    // The entry may sit in a subtree (the output is rooted at the directory common to every module,
+    // which can be an ancestor of the entry when deps live in sibling packages / node_modules), so
+    // point the user at the actual entry `.js` they should hand to a bundler.
+    let entry_js = input_path
+        .canonicalize()
+        .unwrap_or_else(|_| input_path.to_path_buf())
+        .with_extension("js");
+    if let Some(entry_rel) = modules
+        .iter()
+        .filter(|m| entry_js.ends_with(&m.relative_path))
+        .max_by_key(|m| m.relative_path.components().count())
+        .map(|m| m.relative_path.clone())
+    {
+        println!("Entry: {}", out_dir.join(entry_rel).display());
+    }
+    Ok(())
+}
+
 #[allow(clippy::vec_init_then_push, clippy::too_many_arguments)] // build_file maps CLI build flags 1:1
 fn build_file(
     input_path: &str,
@@ -640,6 +714,7 @@ fn build_file(
     source_map: bool,
     ios_triple: Option<&str>,
     crate_type: &str,
+    format: &str,
 ) -> Result<(), String> {
     let optimize = !no_optimize;
     let input_path = Path::new(input_path)
@@ -649,17 +724,26 @@ fn build_file(
     let is_js = input_path.extension().map(|e| e == "js") == Some(true);
 
     if target == "js" {
-        return compile_to_js(&input_path, output_path, optimize, source_map);
+        return compile_to_js(&input_path, output_path, optimize, source_map, format);
     }
 
-    if target == "wasm" && is_js {
+    // `wasm-gpu` (#277): same pipeline as `wasm` but builds the `--features gpu` WebGPU runtime and
+    // emits a `start(chunk, host)` loader that bootstraps WebGPU into the `host` global.
+    let wasm_gpu = target == "wasm-gpu";
+
+    if (target == "wasm" || wasm_gpu) && is_js {
         let source = fs::read_to_string(&input_path).map_err(|e| format!("{}", e))?;
         let program = tishlang_js_to_tish::convert(&source).map_err(|e| format!("{}", e))?;
-        return tishlang_wasm::compile_program_to_wasm(&program, Path::new(output_path), optimize)
-            .map_err(|e| format!("{}", e));
+        return tishlang_wasm::compile_program_to_wasm(
+            &program,
+            Path::new(output_path),
+            optimize,
+            wasm_gpu,
+        )
+        .map_err(|e| format!("{}", e));
     }
 
-    if target == "wasm" {
+    if target == "wasm" || wasm_gpu {
         let project_root = input_path.parent().and_then(|p| {
             if p.file_name().and_then(|n| n.to_str()) == Some("src") {
                 p.parent()
@@ -672,6 +756,7 @@ fn build_file(
             project_root,
             Path::new(output_path),
             optimize,
+            wasm_gpu,
         )
         .map_err(|e| e.to_string());
     }
@@ -714,7 +799,7 @@ fn build_file(
 
     if target != "native" {
         return Err(format!(
-            "Unknown target: {}. Use 'native', 'js', 'wasm', 'wasi', or 'bytecode'.",
+            "Unknown target: {}. Use 'native', 'js', 'wasm', 'wasm-gpu', 'wasi', or 'bytecode'.",
             target
         ));
     }
@@ -814,6 +899,48 @@ mod cli_tests {
         }
     }
 
+    #[test]
+    fn run_collects_trailing_script_args() {
+        // `tish run main.tish a --flag` → file=main.tish, script_args=[a, --flag] (#88).
+        let cli = Cli::try_parse_from(vec![
+            "tish".to_string(),
+            "run".to_string(),
+            "main.tish".to_string(),
+            "a".to_string(),
+            "--flag".to_string(),
+        ])
+        .unwrap();
+        match cli.command {
+            Some(Commands::Run(a)) => {
+                assert_eq!(a.file, "main.tish");
+                assert_eq!(a.script_args, vec!["a".to_string(), "--flag".to_string()]);
+            }
+            _ => panic!("expected Run"),
+        }
+    }
+
+    #[test]
+    fn run_options_before_file_still_parse() {
+        // tish options come BEFORE the file; everything after the file is the script's. (#88)
+        let cli = Cli::try_parse_from(vec![
+            "tish".to_string(),
+            "run".to_string(),
+            "--backend".to_string(),
+            "interp".to_string(),
+            "main.tish".to_string(),
+            "x".to_string(),
+        ])
+        .unwrap();
+        match cli.command {
+            Some(Commands::Run(a)) => {
+                assert_eq!(a.backend, "interp");
+                assert_eq!(a.file, "main.tish");
+                assert_eq!(a.script_args, vec!["x".to_string()]);
+            }
+            _ => panic!("expected Run"),
+        }
+    }
+
     #[test]
     fn explicit_subcommand_not_treated_as_file() {
         let argv = argv_with_implicit_run(vec!["tish".to_string(), "repl".to_string()]);

package/crates/tish/tests/integration_test.rs

@@ -673,6 +673,71 @@ fn test_module_private_binding_isolation() {
     }
 }
 
+/// #282: `--target js --format esm` emits one ES module per `.tish` file with real
+/// `import`/`export`, so two modules exporting the same name (`export fn activate`) keep separate
+/// scopes instead of colliding. The merge-based pipeline (interp/VM/native and `--format bundle`)
+/// still flattens both into one scope — a separately-tracked collision — so this test pins the ESM
+/// JS target, which is the path that isolates them. Builds the module tree and runs it under Node.
+#[test]
+fn test_js_esm_export_collision() {
+    let bin = tish_bin();
+    if !bin.exists() {
+        return;
+    }
+    let main = workspace_root()
+        .join("tests")
+        .join("modules")
+        .join("esm")
+        .join("export_collision")
+        .join("main.tish");
+    if !main.exists() {
+        return;
+    }
+    let expected = "ab\n";
+
+    // JS ESM target: build the module tree, then load + run the entry under Node.
+    let node_available = Command::new("node")
+        .arg("--version")
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false);
+    if node_available {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let out_dir = tmp.path().join("esm_out");
+        let build = Command::new(&bin)
+            .args(["build"])
+            .arg(&main)
+            .args(["-o"])
+            .arg(&out_dir)
+            .args(["--target", "js", "--format", "esm"])
+            .current_dir(workspace_root())
+            .output()
+            .expect("build esm");
+        assert!(
+            build.status.success(),
+            "esm build failed: stderr={}",
+            String::from_utf8_lossy(&build.stderr)
+        );
+        let entry = out_dir.join("main.js");
+        assert!(entry.exists(), "esm entry {} not emitted", entry.display());
+        let out = Command::new("node")
+            .arg(&entry)
+            .current_dir(workspace_root())
+            .output()
+            .expect("run node");
+        assert!(
+            out.status.success(),
+            "esm JS run failed (collision not isolated?): stderr={}",
+            String::from_utf8_lossy(&out.stderr)
+        );
+        assert_eq!(
+            String::from_utf8_lossy(&out.stdout),
+            expected,
+            "esm export_collision mismatch on JS ESM target"
+        );
+    }
+}
+
 /// Ignored: tishlang_eval::run() does not run the event loop.
 #[test]
 #[cfg(feature = "http")]

package/crates/tish_ast/src/ast.rs

@@ -541,10 +541,14 @@ pub enum ArrayElement {
     Spread(Expr),
 }
 
-/// Object property: either a regular key-value pair or spread
+/// Object property: either a regular key-value pair or spread.
+///
+/// The `Span` on `KeyValue` is the key token's source span, so diagnostics (e.g. duplicate-key)
+/// can point at the key rather than the enclosing `{` (#143). Synthesized object literals use a
+/// zero span. Per AST convention the span participates in PartialEq.
 #[derive(Debug, Clone, PartialEq)]
 pub enum ObjectProp {
-    KeyValue(Arc<str>, Expr),
+    KeyValue(Arc<str>, Expr, Span),
     Spread(Expr),
 }
 

package/crates/tish_builtins/src/array.rs

@@ -135,7 +135,11 @@ pub fn includes(arr: &Value, search: &Value, from: Option<&Value>) -> Value {
             _ => 0,
         };
         for v in arr_borrow.iter().skip(start) {
-            if v.strict_eq(search) {
+            // SameValueZero: like `===` but NaN matches NaN (JS `Array.prototype.includes`, unlike
+            // `indexOf` which stays strict). #247
+            if v.strict_eq(search)
+                || matches!((v, search), (Value::Number(a), Value::Number(b)) if a.is_nan() && b.is_nan())
+            {
                 return Value::Bool(true);
             }
         }
@@ -462,6 +466,83 @@ pub fn find_index(arr: &Value, callback: &Value) -> Value {
     Value::Number(-1.0)
 }
 
+/// `Array.prototype.findLast` — like [`find`] but iterates from the end; the callback still receives
+/// the original index. Returns `null` (JS `undefined`) when nothing matches. #247
+pub fn find_last(arr: &Value, callback: &Value) -> Value {
+    if let Some((data, cb)) = packed_snapshot(arr, callback) {
+        for i in (0..data.len()).rev() {
+            if cb
+                .call(&[Value::Number(data[i]), Value::Number(i as f64)])
+                .is_truthy()
+            {
+                return Value::Number(data[i]);
+            }
+        }
+        return Value::Null;
+    }
+    let arr = as_boxed_array(arr);
+    let arr = &*arr;
+    if let (Value::Array(arr), Value::Function(cb)) = (arr, callback) {
+        let arr_borrow = arr.borrow();
+        for i in (0..arr_borrow.len()).rev() {
+            let v = &arr_borrow[i];
+            if cb.call(&[v.clone(), Value::Number(i as f64)]).is_truthy() {
+                return v.clone();
+            }
+        }
+    }
+    Value::Null
+}
+
+/// `Array.prototype.findLastIndex` — like [`find_index`] but from the end; `-1` if no match. #247
+pub fn find_last_index(arr: &Value, callback: &Value) -> Value {
+    if let Some((data, cb)) = packed_snapshot(arr, callback) {
+        for i in (0..data.len()).rev() {
+            if cb
+                .call(&[Value::Number(data[i]), Value::Number(i as f64)])
+                .is_truthy()
+            {
+                return Value::Number(i as f64);
+            }
+        }
+        return Value::Number(-1.0);
+    }
+    let arr = as_boxed_array(arr);
+    let arr = &*arr;
+    if let (Value::Array(arr), Value::Function(cb)) = (arr, callback) {
+        let arr_borrow = arr.borrow();
+        for i in (0..arr_borrow.len()).rev() {
+            if cb
+                .call(&[arr_borrow[i].clone(), Value::Number(i as f64)])
+                .is_truthy()
+            {
+                return Value::Number(i as f64);
+            }
+        }
+    }
+    Value::Number(-1.0)
+}
+
+/// `Array.prototype.at(index)` — negative `index` counts from the end; out of range → `null`
+/// (JS `undefined`). A non-numeric index is `ToInteger`'d to 0, like JS. #247
+pub fn at(arr: &Value, index: &Value) -> Value {
+    let i = match index {
+        Value::Number(n) => *n as i64,
+        _ => 0,
+    };
+    let arr = as_boxed_array(arr);
+    let arr = &*arr;
+    if let Value::Array(arr) = arr {
+        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 arr_borrow[idx as usize].clone();
+        }
+    }
+    Value::Null
+}
+
 pub fn some(arr: &Value, callback: &Value) -> Value {
     if let Some((data, cb)) = packed_snapshot(arr, callback) {
         for (i, &n) in data.iter().enumerate() {

package/crates/tish_builtins/src/globals.rs

@@ -206,25 +206,59 @@ pub fn parse_int(args: &[Value]) -> Value {
         .first()
         .map(Value::to_display_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 radix = args.get(1).and_then(|v| match v {
+        Value::Number(n) => Some(*n as i32),
+        _ => None,
+    });
+    Value::Number(js_parse_int(&s, radix))
+}
 
-    if (2..=36).contains(&radix) {
-        let prefix: String = s
-            .chars()
-            .take_while(|c| *c == '-' || *c == '+' || c.is_digit(radix as u32))
-            .collect();
-        if let Ok(n) = i64::from_str_radix(&prefix, radix as u32) {
-            return Value::Number(n as f64);
+/// JS `parseInt(string, radix)` semantics — shared so the tree-walk interpreter (distinct `Value`)
+/// matches the vm/native exactly (#247). Skips leading whitespace + an optional sign, then strips a
+/// leading `0x`/`0X` when radix is 16 (or omitted and the string is hex-prefixed); an omitted radix
+/// otherwise defaults to 10. Reads the longest valid digit prefix (`parseInt("12px") === 12`),
+/// accumulating in f64 to avoid the old i64-overflow `NaN`. `parseInt("0x1F", 16) === 31`.
+pub fn js_parse_int(input: &str, radix_arg: Option<i32>) -> f64 {
+    let s = input.trim_start();
+    let (neg, rest) = if let Some(r) = s.strip_prefix('-') {
+        (true, r)
+    } else if let Some(r) = s.strip_prefix('+') {
+        (false, r)
+    } else {
+        (false, s)
+    };
+    let mut radix = radix_arg.unwrap_or(0);
+    let mut digits = rest;
+    if radix == 16 || radix == 0 {
+        if let Some(r) = rest.strip_prefix("0x").or_else(|| rest.strip_prefix("0X")) {
+            radix = 16;
+            digits = r;
         }
     }
-    Value::Number(f64::NAN)
+    if radix == 0 {
+        radix = 10;
+    }
+    if !(2..=36).contains(&radix) {
+        return f64::NAN;
+    }
+    let mut acc = 0.0_f64;
+    let mut any = false;
+    for c in digits.chars() {
+        match c.to_digit(radix as u32) {
+            Some(d) => {
+                acc = acc * radix as f64 + d as f64;
+                any = true;
+            }
+            None => break,
+        }
+    }
+    if !any {
+        f64::NAN
+    } else if neg {
+        -acc
+    } else {
+        acc
+    }
 }
 
 /// parseFloat(string)

package/crates/tish_builtins/src/math.rs

@@ -16,7 +16,6 @@ math_unary!(abs, abs);
 math_unary!(sqrt, sqrt);
 math_unary!(floor, floor);
 math_unary!(ceil, ceil);
-math_unary!(round, round);
 math_unary!(sin, sin);
 math_unary!(cos, cos);
 math_unary!(tan, tan);
@@ -30,20 +29,75 @@ math_unary!(exp, exp);
 math_unary!(trunc, trunc);
 math_unary!(cbrt, cbrt);
 
+// --- f64-domain semantics (single source of truth) -------------------------------------------------
+// These hold the JS-specific Math rules so every backend agrees: the vm/native paths call the
+// `&[Value]` wrappers below, and the interpreter (which uses a different `Value` type) calls these f64
+// helpers directly after extracting its own args. Keeping the rules here means they can't drift. #247
+
+/// JS `Math.round`: ties round toward +∞ (not Rust's `.round()`, which rounds half away from zero),
+/// and values in `[-0.5, 0)` return `-0`. `floor(n + 0.5)` gives the +∞-tie behavior; the guards keep
+/// NaN/±∞ and the sign-of-zero edges correct (`Math.round(-2.5) === -2`, `Math.round(-0.5) === -0`).
+pub fn round_f64(n: f64) -> f64 {
+    if n.is_nan() || n.is_infinite() || n == 0.0 {
+        n
+    } else if (-0.5..0.5).contains(&n) {
+        if n < 0.0 {
+            -0.0
+        } else {
+            0.0
+        }
+    } else {
+        (n + 0.5).floor()
+    }
+}
+
+/// JS `Math.min` over already-extracted f64s: empty → `+∞`, any `NaN` → `NaN` (unlike `f64::min`,
+/// which ignores NaN), and `-0` is preferred over `+0`.
+pub fn min_f64(nums: &[f64]) -> f64 {
+    let mut acc = f64::INFINITY;
+    for &n in nums {
+        if n.is_nan() {
+            return f64::NAN;
+        }
+        if n < acc || (n == 0.0 && acc == 0.0 && n.is_sign_negative()) {
+            acc = n;
+        }
+    }
+    acc
+}
+
+/// JS `Math.max` over already-extracted f64s: empty → `-∞`, any `NaN` → `NaN`, `+0` preferred over `-0`.
+pub fn max_f64(nums: &[f64]) -> f64 {
+    let mut acc = f64::NEG_INFINITY;
+    for &n in nums {
+        if n.is_nan() {
+            return f64::NAN;
+        }
+        if n > acc || (n == 0.0 && acc == 0.0 && n.is_sign_positive()) {
+            acc = n;
+        }
+    }
+    acc
+}
+
+pub fn round(args: &[Value]) -> Value {
+    Value::Number(round_f64(extract_num(args.first()).unwrap_or(f64::NAN)))
+}
+
 pub fn min(args: &[Value]) -> Value {
-    let n = args
+    let nums: Vec<f64> = args
         .iter()
-        .filter_map(|v| extract_num(Some(v)))
-        .fold(f64::INFINITY, f64::min);
-    Value::Number(if n == f64::INFINITY { f64::NAN } else { n })
+        .map(|v| extract_num(Some(v)).unwrap_or(f64::NAN))
+        .collect();
+    Value::Number(min_f64(&nums))
 }
 
 pub fn max(args: &[Value]) -> Value {
-    let n = args
+    let nums: Vec<f64> = args
         .iter()
-        .filter_map(|v| extract_num(Some(v)))
-        .fold(f64::NEG_INFINITY, f64::max);
-    Value::Number(if n == f64::NEG_INFINITY { f64::NAN } else { n })
+        .map(|v| extract_num(Some(v)).unwrap_or(f64::NAN))
+        .collect();
+    Value::Number(max_f64(&nums))
 }
 
 pub fn pow(args: &[Value]) -> Value {

package/crates/tish_builtins/src/number.rs

@@ -21,7 +21,26 @@ pub fn to_fixed(n: &Value, digits: &Value) -> Value {
         Value::Number(x) => (*x as i32).clamp(0, 20),
         _ => 0,
     } as usize;
-    Value::String(format!("{:.*}", d, num).into())
+    Value::String(to_fixed_str(num, d).into())
+}
+
+/// 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
+pub fn to_fixed_str(num: f64, digits: usize) -> String {
+    if num.is_nan() {
+        return "NaN".to_string();
+    }
+    if num.is_infinite() {
+        return if num < 0.0 { "-Infinity" } else { "Infinity" }.to_string();
+    }
+    // JS switches to exponential form for |num| >= 1e21; defer to default formatting there.
+    if num.abs() >= 1e21 {
+        return format!("{}", num);
+    }
+    let factor = 10f64.powi(digits as i32);
+    let rounded = (num * factor).round() / factor;
+    format!("{:.*}", digits, rounded)
 }
 
 /// `Number.prototype.toString([radix])` — ECMA-262 §21.1.3.6.