@tishlang/tish 2.2.5 → 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.5"
+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

@@ -2,7 +2,7 @@
 
 use std::sync::Arc;
 
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
 pub struct Span {
     pub start: (usize, usize), // line, col
     pub end: (usize, usize),
@@ -11,8 +11,11 @@ pub struct Span {
 /// Type annotation for variables, parameters, and return types.
 #[derive(Debug, Clone, PartialEq)]
 pub enum TypeAnnotation {
-    /// Primitive types: number, string, boolean, null
-    Simple(Arc<str>),
+    /// Primitive types and type-name references: `number`, `string`, `MyAlias`. The span locates
+    /// the name token in source so type-alias rename / find-references can edit every `: T` use
+    /// (synthesized types — monomorphized generics, builtins, postfix `?` null — use a zero span
+    /// and never match a user alias). Per AST convention, spans participate in PartialEq.
+    Simple(Arc<str>, Span),
     /// Array type: T[]
     Array(Box<TypeAnnotation>),
     /// Object type: { key: Type, ... }
@@ -538,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_build_utils/src/lib.rs

@@ -490,9 +490,46 @@ pub fn copy_binary_to_output(binary: &Path, output_path: &Path) -> Result<(), St
     }
     fs::copy(binary, output_path)
         .map_err(|e| format!("Cannot copy to {}: {}", output_path.display(), e))?;
+    resign_macos_adhoc(output_path);
     Ok(())
 }
 
+/// Replace the linker-produced ad-hoc signature with a plain ad-hoc one on macOS.
+///
+/// On Apple Silicon, AMFI SIGKILLs a freshly linked binary whose ad-hoc signature carries the
+/// `linker-signed` flag (instant exit 137, no output — looks like a crash/hang), even though
+/// `codesign -v` reports it valid (#219). A standard `codesign --sign - --force` replaces it with a
+/// kernel-acceptable signature. Best-effort: static archives are skipped, and a failure (codesign
+/// absent, or a non-Mach-O output) is non-fatal — the binary is then no worse off than before.
+#[cfg(target_os = "macos")]
+fn resign_macos_adhoc(output_path: &Path) {
+    // Static archives (`.a`) are not code-signed.
+    if output_path.extension().is_some_and(|e| e == "a") {
+        return;
+    }
+    match Command::new("codesign")
+        .args(["--sign", "-", "--force"])
+        .arg(output_path)
+        .output()
+    {
+        Ok(out) if out.status.success() => {}
+        Ok(out) => eprintln!(
+            "warning: codesign --sign - failed for {} ({}); the binary may be SIGKILLed at launch on Apple Silicon — re-sign with `codesign -s - -f {}`",
+            output_path.display(),
+            String::from_utf8_lossy(&out.stderr).trim(),
+            output_path.display()
+        ),
+        Err(e) => eprintln!(
+            "warning: could not run codesign for {} ({e}); if the binary is killed at launch, re-sign with `codesign -s - -f {}`",
+            output_path.display(),
+            output_path.display()
+        ),
+    }
+}
+
+#[cfg(not(target_os = "macos"))]
+fn resign_macos_adhoc(_output_path: &Path) {}
+
 #[cfg(test)]
 mod tests {
     use super::*;

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"));