@tishlang/tish 2.2.7 → 2.8.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.8.0"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }

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)]

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
@@ -652,14 +658,23 @@ fn build_file(
         return compile_to_js(&input_path, output_path, optimize, source_map);
     }
 
-    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 +687,7 @@ fn build_file(
             project_root,
             Path::new(output_path),
             optimize,
+            wasm_gpu,
         )
         .map_err(|e| e.to_string());
     }
@@ -714,7 +730,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 +830,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_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.

package/crates/tish_builtins/src/string.rs

@@ -215,15 +215,39 @@ pub fn substr(s: &Value, start: &Value, length: &Value) -> Value {
 }
 
 pub fn split(s: &Value, sep: &Value) -> Value {
+    split_limit(s, sep, None)
+}
+
+/// `String.prototype.split(sep, limit)` for a string separator. JS semantics: the string is split
+/// completely on `sep`, then the result is truncated to `limit` elements (it does NOT keep the
+/// unsplit remainder in the last slot, which is what Rust's `splitn` would do). `limit == 0` yields
+/// an empty array. This is the single source of truth shared by the VM and rust/cranelift/wasi
+/// backends; the interpreter mirrors it in `tish_eval::regex::string_split`.
+pub fn split_limit(s: &Value, sep: &Value, limit: Option<usize>) -> Value {
     if let Value::String(s) = s {
         let separator = match sep {
             Value::String(ss) => ss.as_str(),
             _ => return Value::Array(VmRef::new(vec![Value::String(s.clone())])),
         };
-        let parts: Vec<Value> = s
-            .split(separator)
-            .map(|p| Value::String(p.into()))
-            .collect();
+        if limit == Some(0) {
+            return Value::Array(VmRef::new(Vec::new()));
+        }
+        // JS `split("")` is special: it yields the string's characters with NO surrounding empties
+        // (`"xyz".split("")` → `["x","y","z"]`, `"".split("")` → `[]`), unlike Rust's `str::split("")`
+        // which emits leading/trailing `""`. (tish splits on `char`s; lone-surrogate behavior for
+        // astral code points is out of scope.) #247
+        if separator.is_empty() {
+            let mut parts: Vec<Value> =
+                s.chars().map(|c| Value::String(c.to_string().into())).collect();
+            if let Some(max) = limit {
+                parts.truncate(max);
+            }
+            return Value::Array(VmRef::new(parts));
+        }
+        let mut parts: Vec<Value> = s.split(separator).map(|p| Value::String(p.into())).collect();
+        if let Some(max) = limit {
+            parts.truncate(max);
+        }
         Value::Array(VmRef::new(parts))
     } else {
         Value::Null
@@ -364,6 +388,24 @@ pub fn char_at(s: &Value, idx: &Value) -> Value {
     }
 }
 
+/// `String.prototype.at(index)` — like `charAt` but negative `index` counts from the end and an
+/// out-of-range index yields `null` (JS `undefined`), not `""`. #247
+pub fn at(s: &Value, index: &Value) -> Value {
+    if let Value::String(s) = s {
+        let i = match index {
+            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 Value::String(chars[idx as usize].to_string().into());
+        }
+    }
+    Value::Null
+}
+
 pub fn char_code_at(s: &Value, idx: &Value) -> Value {
     if let Value::String(s) = s {
         let idx = match idx {
@@ -541,6 +583,28 @@ mod tests {
         assert_same!(trim(&n(1.0)), Value::Null);
     }
 
+    #[test]
+    fn split_limit_js_semantics() {
+        let parts = |v: &Value| -> Vec<String> {
+            let Value::Array(a) = v else { panic!("not array") };
+            a.borrow()
+                .iter()
+                .map(|x| match x {
+                    Value::String(s) => s.to_string(),
+                    _ => panic!("not string"),
+                })
+                .collect()
+        };
+        // limit truncates to the first N pieces (does NOT keep the remainder, unlike `splitn`)
+        assert_eq!(parts(&split_limit(&s("a,b,c,d"), &s(","), Some(2))), ["a", "b"]);
+        // limit 0 -> empty; limit beyond piece count -> full split; no limit -> full split
+        assert_eq!(parts(&split_limit(&s("a,b,c,d"), &s(","), Some(0))).len(), 0);
+        assert_eq!(parts(&split_limit(&s("a,b,c,d"), &s(","), Some(10))), ["a", "b", "c", "d"]);
+        assert_eq!(parts(&split_limit(&s("a,b,c,d"), &s(","), None)), ["a", "b", "c", "d"]);
+        // split() delegates with no limit
+        assert_eq!(parts(&split(&s("one two"), &s(" "))), ["one", "two"]);
+    }
+
     #[test]
     fn case_and_prefix_suffix() {
         assert_same!(to_upper_case(&s("aB")), s("AB"));

package/crates/tish_builtins/src/typedarrays.rs

@@ -136,7 +136,14 @@ fn construct(kind: Kind, args: &[Value]) -> Value {
 /// construction-only-coercion gap for this one view). Any op without a packed fast path materialises
 /// it back to a boxed array, so every array method keeps working.
 pub fn float64_array_packed(args: &[Value]) -> Value {
-    if !Value::packed_arrays_enabled() {
+    float64_array_with(Value::packed_arrays_enabled(), args)
+}
+
+/// `float64_array_packed` with the packed/boxed choice made explicit, so tests exercise both paths
+/// without toggling the now-cached process env flag (#166). `packed = false` is byte-identical to
+/// the generic boxed `Value::Array` constructor.
+fn float64_array_with(packed: bool, args: &[Value]) -> Value {
+    if !packed {
         // Byte-identical fallback to the generic boxed `Value::Array` backing.
         return construct(Kind::F64, args);
     }
@@ -261,25 +268,26 @@ mod tests {
         assert_eq!(nums(&v), vec![0.0, 1.0]);
     }
 
-    // `float64_array_packed` toggles on a process-global env var. No other test in this crate reads
-    // `packed_arrays_enabled`, so the set/remove here can't perturb a concurrent test; we restore the
-    // default (off) on exit regardless.
+    // The packed/boxed selection is passed explicitly via `float64_array_with`, so this exercises
+    // both paths without touching the now-cached process env flag (#166) — no env mutation, no
+    // mid-test toggle race, parallel-safe.
     #[test]
     fn float64_packed_respects_flag() {
-        // Flag off (default): byte-identical boxed `Value::Array` fallback, no packed value produced.
-        std::env::remove_var("TISH_PACKED_ARRAYS");
-        let boxed = float64_array_packed(&[Value::Number(3.0)]);
+        // Packed off (the default): byte-identical boxed `Value::Array` fallback.
+        let boxed = float64_array_with(false, &[Value::Number(3.0)]);
         assert!(matches!(boxed, Value::Array(_)), "packed-off must return boxed Array");
         assert_eq!(nums(&boxed), vec![0.0, 0.0, 0.0]);
 
-        // Flag on: packed `Value::NumberArray`. F64 needs no coercion (exact), non-numeric → NaN
+        // Packed on: `Value::NumberArray`. F64 needs no coercion (exact), non-numeric → NaN
         // (matching the boxed `from_values(F64, …)`), and the length form zero-fills.
-        std::env::set_var("TISH_PACKED_ARRAYS", "1");
-        let packed = float64_array_packed(&[Value::Array(VmRef::new(vec![
-            Value::Number(1.1),
-            Value::Number(2.2),
-            Value::Null,
-        ]))]);
+        let packed = float64_array_with(
+            true,
+            &[Value::Array(VmRef::new(vec![
+                Value::Number(1.1),
+                Value::Number(2.2),
+                Value::Null,
+            ]))],
+        );
         match &packed {
             Value::NumberArray(a) => {
                 let v = a.borrow();
@@ -290,9 +298,8 @@ mod tests {
             _ => panic!("packed-on must return NumberArray"),
         }
         assert!(matches!(
-            float64_array_packed(&[Value::Number(2.0)]),
+            float64_array_with(true, &[Value::Number(2.0)]),
             Value::NumberArray(_)
         ));
-        std::env::remove_var("TISH_PACKED_ARRAYS");
     }
 }