@tishlang/tish-format 2.16.13 → 2.35.0

package/crates/tish_eval/src/eval.rs

@@ -238,6 +238,9 @@ impl Evaluator {
             );
             s.set("decodeURI".into(), Value::Native(natives::decode_uri), true);
             s.set("encodeURI".into(), Value::Native(natives::encode_uri), true);
+            s.set("encodeURIComponent".into(), Value::Native(natives::encode_uri_component), true);
+            s.set("decodeURIComponent".into(), Value::Native(natives::decode_uri_component), true);
+            s.set("structuredClone".into(), Value::Native(natives::structured_clone), true);
             s.set(
                 "htmlEscape".into(),
                 Value::Native(natives::html_escape),
@@ -262,6 +265,7 @@ 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("imul".into(), Value::Native(natives::math_imul));
             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));
@@ -281,6 +285,10 @@ impl Evaluator {
             math.insert("acosh".into(), Value::Native(natives::math_acosh));
             math.insert("atanh".into(), Value::Native(natives::math_atanh));
             math.insert("cbrt".into(), Value::Native(natives::math_cbrt));
+            math.insert("expm1".into(), Value::Native(natives::math_expm1));
+            math.insert("log1p".into(), Value::Native(natives::math_log1p));
+            math.insert("clz32".into(), Value::Native(natives::math_clz32));
+            math.insert("fround".into(), Value::Native(natives::math_fround));
             math.insert("log2".into(), Value::Native(natives::math_log2));
             math.insert("log10".into(), Value::Native(natives::math_log10));
             math.insert("PI".into(), Value::Number(std::f64::consts::PI));
@@ -329,6 +337,10 @@ impl Evaluator {
             object.insert("values".into(), Value::Native(Self::object_values));
             object.insert("entries".into(), Value::Native(Self::object_entries));
             object.insert("assign".into(), Value::Native(Self::object_assign));
+            object.insert("is".into(), Value::Native(natives::object_is));
+            object.insert("hasOwn".into(), Value::Native(natives::object_has_own));
+            // getOwnPropertyNames ≈ keys for tish's plain objects (own string keys, insertion order).
+            object.insert("getOwnPropertyNames".into(), Value::Native(Self::object_keys));
             object.insert(
                 "fromEntries".into(),
                 Value::Native(Self::object_from_entries),
@@ -341,6 +353,7 @@ impl Evaluator {
 
             let mut array_obj = PropMap::with_capacity(3);
             array_obj.insert("isArray".into(), Value::Native(natives::array_is_array));
+            array_obj.insert("of".into(), Value::Native(natives::array_of));
             // `Array(n)` and `new Array(n)` constructor (issue #72).
             array_obj.insert("__call".into(), Value::Native(natives::array_construct));
             array_obj.insert("__construct".into(), Value::Native(natives::array_construct));
@@ -376,9 +389,23 @@ impl Evaluator {
                 true,
             );
 
-            // `Number(value)` coercion as a callable global (issue #36).
-            let mut number_obj = PropMap::with_capacity(1);
+            // `Number(value)` coercion as a callable global (issue #36) + the `Number.*` statics.
+            let mut number_obj = PropMap::with_capacity(15);
             number_obj.insert("__call".into(), Value::Native(natives::number_convert));
+            number_obj.insert("isInteger".into(), Value::Native(natives::number_is_integer));
+            number_obj.insert("isSafeInteger".into(), Value::Native(natives::number_is_safe_integer));
+            number_obj.insert("isNaN".into(), Value::Native(natives::number_is_nan));
+            number_obj.insert("isFinite".into(), Value::Native(natives::number_is_finite));
+            number_obj.insert("parseInt".into(), Value::Native(natives::parse_int));
+            number_obj.insert("parseFloat".into(), Value::Native(natives::parse_float));
+            number_obj.insert("MAX_SAFE_INTEGER".into(), Value::Number(9_007_199_254_740_991.0));
+            number_obj.insert("MIN_SAFE_INTEGER".into(), Value::Number(-9_007_199_254_740_991.0));
+            number_obj.insert("EPSILON".into(), Value::Number(f64::EPSILON));
+            number_obj.insert("MAX_VALUE".into(), Value::Number(f64::MAX));
+            number_obj.insert("MIN_VALUE".into(), Value::Number(5e-324));
+            number_obj.insert("POSITIVE_INFINITY".into(), Value::Number(f64::INFINITY));
+            number_obj.insert("NEGATIVE_INFINITY".into(), Value::Number(f64::NEG_INFINITY));
+            number_obj.insert("NaN".into(), Value::Number(f64::NAN));
             s.set("Number".into(), Value::object(number_obj), true);
 
             s.set(
@@ -660,6 +687,51 @@ impl Evaluator {
                 self.scope = outer;
                 ret
             }
+            Statement::ForIn {
+                name,
+                object,
+                body,
+                ..
+            } => {
+                let obj_val = self.eval_expr(object)?;
+                // for-in enumerates OWN ENUMERABLE KEYS as strings (JS semantics): objects yield keys
+                // in insertion order, arrays yield index strings "0".."len-1", and a non-object
+                // (incl. null) yields nothing — a no-op, matching JS `for (k in null)`.
+                let keys: Vec<crate::value::Value> = match &obj_val {
+                    crate::value::Value::Object(obj) => obj
+                        .borrow()
+                        .strings
+                        .keys()
+                        .map(|k| crate::value::Value::String(Arc::clone(k)))
+                        .collect(),
+                    crate::value::Value::Array(arr) => {
+                        let len = arr.borrow().len();
+                        (0..len)
+                            .map(|i| crate::value::Value::String(Arc::from(i.to_string())))
+                            .collect()
+                    }
+                    _ => Vec::new(),
+                };
+                // Fresh per-iteration binding (ES6 `for (let k in …)`), like the for-of arm above.
+                let outer = Rc::clone(&self.scope);
+                let mut ret = Ok(Value::Null);
+                for key in keys {
+                    let iter_env = Scope::child(Rc::clone(&outer));
+                    iter_env.borrow_mut().set(Arc::clone(name), key, true);
+                    self.scope = Rc::clone(&iter_env);
+                    match self.eval_statement(body) {
+                        Ok(_) => {}
+                        Err(EvalError::Break) => break,
+                        Err(EvalError::Continue) => continue,
+                        Err(e) => {
+                            ret = Err(e);
+                            break;
+                        }
+                    }
+                }
+                self.scope = outer;
+                ret
+            }
             Statement::For {
                 init,
                 cond,
@@ -948,7 +1020,7 @@ impl Evaluator {
                     ExportDeclaration::ReExport {
                         specifiers,
                         all,
-                        from,
+                        from: Some(from),
                         ..
                     } => {
                         let dep_val = self.load_module(from.as_ref())?;
@@ -971,6 +1043,11 @@ impl Evaluator {
                             }
                         }
                     }
+                    // #415 local named export (`export { a, b as c }`, no `from`): a no-op in the
+                    // running (entry) program — the bindings already exist, and an export alias is
+                    // visible only to importers, never as a local variable (JS semantics). The module
+                    // export table is populated by the module-evaluation path, not here.
+                    ExportDeclaration::ReExport { from: None, .. } => {}
                 }
                 Ok(Value::Null)
             }
@@ -1041,7 +1118,7 @@ impl Evaluator {
                     ExportDeclaration::ReExport {
                         specifiers,
                         all,
-                        from,
+                        from: Some(from),
                         ..
                     } => {
                         let dep_val = self.load_module(from.as_ref())?;
@@ -1066,6 +1143,24 @@ impl Evaluator {
                             }
                         }
                     }
+                    // #415 local named export (`export { a, b as c }`, no `from`): the bindings are
+                    // already declared in this module's scope; expose each under its export name.
+                    ExportDeclaration::ReExport {
+                        specifiers,
+                        from: None,
+                        ..
+                    } => {
+                        for spec in specifiers {
+                            if let ImportSpecifier::Named { name, alias, .. } = spec {
+                                let v = self.scope.borrow().get(name.as_ref()).ok_or_else(|| {
+                                    EvalError::Error(format!("Export '{}' is not defined", name))
+                                })?;
+                                let bind = alias.as_deref().unwrap_or(name.as_ref());
+                                self.scope.borrow_mut().set(Arc::from(bind), v.clone(), false);
+                                export_names.push(bind.to_string());
+                            }
+                        }
+                    }
                 }
             } else {
                 let _ = self.eval_statement(stmt);
@@ -1132,6 +1227,44 @@ impl Evaluator {
                         Value::Native(natives::read_file_bytes),
                     );
                     exports.insert("mkdir".into(), Value::Native(natives::mkdir));
+                    // Node-compatible names + new methods (sync) — issue #122
+                    use natives::fsx;
+                    exports.insert("readFileSync".into(), Value::Native(fsx::read_file));
+                    exports.insert("readFileBytesSync".into(), Value::Native(fsx::read_file_bytes));
+                    exports.insert("writeFileSync".into(), Value::Native(fsx::write_file));
+                    exports.insert("appendFile".into(), Value::Native(fsx::append_file));
+                    exports.insert("appendFileSync".into(), Value::Native(fsx::append_file));
+                    exports.insert("existsSync".into(), Value::Native(fsx::exists));
+                    exports.insert("mkdirSync".into(), Value::Native(fsx::mkdir));
+                    exports.insert("readdir".into(), Value::Native(fsx::readdir));
+                    exports.insert("readdirSync".into(), Value::Native(fsx::readdir));
+                    exports.insert("stat".into(), Value::Native(fsx::stat));
+                    exports.insert("statSync".into(), Value::Native(fsx::stat));
+                    exports.insert("lstat".into(), Value::Native(fsx::lstat));
+                    exports.insert("lstatSync".into(), Value::Native(fsx::lstat));
+                    exports.insert("rm".into(), Value::Native(fsx::rm));
+                    exports.insert("rmSync".into(), Value::Native(fsx::rm));
+                    exports.insert("rmdir".into(), Value::Native(fsx::rmdir));
+                    exports.insert("rmdirSync".into(), Value::Native(fsx::rmdir));
+                    exports.insert("unlink".into(), Value::Native(fsx::unlink));
+                    exports.insert("unlinkSync".into(), Value::Native(fsx::unlink));
+                    exports.insert("rename".into(), Value::Native(fsx::rename));
+                    exports.insert("renameSync".into(), Value::Native(fsx::rename));
+                    exports.insert("copyFile".into(), Value::Native(fsx::copy_file));
+                    exports.insert("copyFileSync".into(), Value::Native(fsx::copy_file));
+                    exports.insert("realpath".into(), Value::Native(fsx::realpath));
+                    exports.insert("realpathSync".into(), Value::Native(fsx::realpath));
+                    exports.insert("readlink".into(), Value::Native(fsx::readlink));
+                    exports.insert("readlinkSync".into(), Value::Native(fsx::readlink));
+                    exports.insert("truncate".into(), Value::Native(fsx::truncate));
+                    exports.insert("truncateSync".into(), Value::Native(fsx::truncate));
+                    exports.insert("mkdtemp".into(), Value::Native(fsx::mkdtemp));
+                    exports.insert("mkdtempSync".into(), Value::Native(fsx::mkdtemp));
+                    exports.insert("cp".into(), Value::Native(fsx::cp));
+                    exports.insert("cpSync".into(), Value::Native(fsx::cp));
+                    exports.insert("access".into(), Value::Native(fsx::access));
+                    exports.insert("accessSync".into(), Value::Native(fsx::access));
+                    exports.insert("constants".into(), fsx::constants());
                     Ok(Value::object(exports))
                 }
                 #[cfg(not(feature = "fs"))]
@@ -1141,6 +1274,41 @@ impl Evaluator {
                     ));
                 }
             }
+            "tish:fs/promises" => {
+                #[cfg(feature = "fs")]
+                {
+                    use natives::fsx;
+                    let mut exports: PropMap = PropMap::default();
+                    exports.insert("readFile".into(), Value::Native(fsx::read_file_p));
+                    exports.insert("readFileBytes".into(), Value::Native(fsx::read_file_bytes_p));
+                    exports.insert("writeFile".into(), Value::Native(fsx::write_file_p));
+                    exports.insert("appendFile".into(), Value::Native(fsx::append_file_p));
+                    exports.insert("exists".into(), Value::Native(fsx::exists_p));
+                    exports.insert("mkdir".into(), Value::Native(fsx::mkdir_p));
+                    exports.insert("readdir".into(), Value::Native(fsx::readdir_p));
+                    exports.insert("stat".into(), Value::Native(fsx::stat_p));
+                    exports.insert("lstat".into(), Value::Native(fsx::lstat_p));
+                    exports.insert("rm".into(), Value::Native(fsx::rm_p));
+                    exports.insert("rmdir".into(), Value::Native(fsx::rmdir_p));
+                    exports.insert("unlink".into(), Value::Native(fsx::unlink_p));
+                    exports.insert("rename".into(), Value::Native(fsx::rename_p));
+                    exports.insert("copyFile".into(), Value::Native(fsx::copy_file_p));
+                    exports.insert("realpath".into(), Value::Native(fsx::realpath_p));
+                    exports.insert("readlink".into(), Value::Native(fsx::readlink_p));
+                    exports.insert("truncate".into(), Value::Native(fsx::truncate_p));
+                    exports.insert("mkdtemp".into(), Value::Native(fsx::mkdtemp_p));
+                    exports.insert("cp".into(), Value::Native(fsx::cp_p));
+                    exports.insert("access".into(), Value::Native(fsx::access_p));
+                    exports.insert("constants".into(), fsx::constants());
+                    Ok(Value::object(exports))
+                }
+                #[cfg(not(feature = "fs"))]
+                {
+                    return Err(EvalError::Error(
+                        "tish:fs/promises requires the fs feature. Rebuild with: cargo build -p tishlang --features fs".into(),
+                    ));
+                }
+            }
             "tish:http" => {
                 #[cfg(feature = "http")]
                 {
@@ -1538,7 +1706,58 @@ impl Evaluator {
                 {
                     let obj = self.eval_expr(object)?;
                     let arg_vals = self.eval_call_args(args)?;
-                    
+
+                    // `Array.from(source, mapFn?)` — handled inline so the mapFn callback runs with the
+                    // interpreter context (a plain native has no `self`). Covers array / string / Set /
+                    // Map / iterator (via `__drain__`) and array-like `{ length }`. (#440)
+                    if let Expr::Ident { name, .. } = object.as_ref() {
+                        if name.as_ref() == "Array" && method_name.as_ref() == "from" {
+                            let source = arg_vals.first().cloned().unwrap_or(Value::Null);
+                            let items: Vec<Value> = match &source {
+                                Value::Array(a) => a.borrow().clone(),
+                                Value::String(s) => s
+                                    .chars()
+                                    .map(|c| Value::String(std::sync::Arc::from(c.to_string())))
+                                    .collect(),
+                                _ => {
+                                    if let Some(d) = self.drain_eval_iterator(&source) {
+                                        d
+                                    } else if matches!(&source, Value::Object(_)) {
+                                        let len = self
+                                            .get_prop(&source, "length")
+                                            .ok()
+                                            .and_then(|v| match v {
+                                                Value::Number(n) if n.is_finite() && n >= 0.0 => {
+                                                    Some(n as usize)
+                                                }
+                                                _ => None,
+                                            })
+                                            .unwrap_or(0);
+                                        (0..len)
+                                            .map(|i| {
+                                                self.get_prop(&source, &i.to_string())
+                                                    .unwrap_or(Value::Null)
+                                            })
+                                            .collect()
+                                    } else {
+                                        Vec::new()
+                                    }
+                                }
+                            };
+                            let out = match arg_vals.get(1) {
+                                Some(f) if !matches!(f, Value::Null) => {
+                                    let mut o = Vec::with_capacity(items.len());
+                                    for (i, item) in items.into_iter().enumerate() {
+                                        o.push(self.call_func(f, &[item, Value::Number(i as f64)])?);
+                                    }
+                                    o
+                                }
+                                _ => items,
+                            };
+                            return Ok(Value::array(out));
+                        }
+                    }
+
                     // Array methods
                     if let Value::Array(arr) = &obj {
                         match method_name.as_ref() {
@@ -1569,13 +1788,66 @@ impl Evaluator {
                             "indexOf" => {
                                 let search = arg_vals.first().cloned().unwrap_or(Value::Null);
                                 let arr_borrow = arr.borrow();
-                                for (i, v) in arr_borrow.iter().enumerate() {
+                                // fromIndex: positive clamps to [0, len]; negative counts from the end.
+                                let len = arr_borrow.len() as i64;
+                                let start = match arg_vals.get(1) {
+                                    Some(Value::Number(n)) if *n >= 0.0 => (*n as i64).min(len).max(0) as usize,
+                                    Some(Value::Number(n)) if *n < 0.0 => ((len + *n as i64).max(0)) as usize,
+                                    _ => 0,
+                                };
+                                for (i, v) in arr_borrow.iter().enumerate().skip(start) {
                                     if v.strict_eq(&search) {
                                         return Ok(Value::Number(i as f64));
                                     }
                                 }
                                 return Ok(Value::Number(-1.0));
                             }
+                            "lastIndexOf" => {
+                                let search = arg_vals.first().cloned().unwrap_or(Value::Null);
+                                let arr_borrow = arr.borrow();
+                                let len = arr_borrow.len() as i64;
+                                let start = match arg_vals.get(1) {
+                                    Some(Value::Number(n)) if *n >= 0.0 => (*n as i64).min(len - 1),
+                                    Some(Value::Number(n)) => len + *n as i64,
+                                    _ => len - 1,
+                                };
+                                let mut i = start;
+                                while i >= 0 {
+                                    if let Some(v) = arr_borrow.get(i as usize) {
+                                        if v.strict_eq(&search) {
+                                            return Ok(Value::Number(i as f64));
+                                        }
+                                    }
+                                    i -= 1;
+                                }
+                                return Ok(Value::Number(-1.0));
+                            }
+                            "copyWithin" => {
+                                let mut v = arr.borrow_mut();
+                                let len = v.len() as i64;
+                                let norm = |x: Option<&Value>, dflt: i64| -> usize {
+                                    match x {
+                                        Some(Value::Number(n)) => {
+                                            let n = *n as i64;
+                                            (if n < 0 { len + n } else { n }).clamp(0, len) as usize
+                                        }
+                                        _ => dflt.clamp(0, len) as usize,
+                                    }
+                                };
+                                let t = norm(arg_vals.first(), 0);
+                                let s = norm(arg_vals.get(1), 0);
+                                let e = norm(arg_vals.get(2), len);
+                                let lu = len as usize;
+                                if s < e && t < lu {
+                                    let count = (e - s).min(lu - t);
+                                    let block: Vec<Value> = v[s..s + count].to_vec();
+                                    for (k, val) in block.into_iter().enumerate() {
+                                        v[t + k] = val;
+                                    }
+                                }
+                                drop(v);
+                                return Ok(Value::Array(arr.clone()));
+                            }
                             "includes" => {
                                 let search = arg_vals.first().cloned().unwrap_or(Value::Null);
                                 let arr_borrow = arr.borrow();
@@ -1617,6 +1889,91 @@ impl Evaluator {
                                 arr.borrow_mut().reverse();
                                 return Ok(obj.clone());
                             }
+                            "toReversed" => {
+                                // ES2023: a reversed COPY; the receiver is untouched.
+                                let mut v = arr.borrow().clone();
+                                v.reverse();
+                                return Ok(Value::Array(Rc::new(RefCell::new(v))));
+                            }
+                            "toSorted" => {
+                                // ES2023: a sorted COPY. Uses the general comparator/default path (the
+                                // numeric fast-paths in `sort` are speed-only and give identical order).
+                                let comparator = arg_vals.into_iter().next();
+                                let arr_values: Vec<Value> = arr.borrow().clone();
+                                let len = arr_values.len();
+                                let mut indices: Vec<usize> = (0..len).collect();
+                                if let Some(cmp_fn) = comparator {
+                                    let mut pending: Option<EvalError> = None;
+                                    indices.sort_by(|&i, &j| {
+                                        if pending.is_some() {
+                                            return std::cmp::Ordering::Equal;
+                                        }
+                                        match self.call_func(&cmp_fn, &[arr_values[i].clone(), arr_values[j].clone()]) {
+                                            Ok(Value::Number(n)) if n < 0.0 => std::cmp::Ordering::Less,
+                                            Ok(Value::Number(n)) if n > 0.0 => std::cmp::Ordering::Greater,
+                                            Ok(_) => std::cmp::Ordering::Equal,
+                                            Err(e) => { pending = Some(e); std::cmp::Ordering::Equal }
+                                        }
+                                    });
+                                    if let Some(e) = pending {
+                                        return Err(e);
+                                    }
+                                } else {
+                                    indices.sort_by(|&i, &j| {
+                                        arr_values[i].to_string().cmp(&arr_values[j].to_string())
+                                    });
+                                }
+                                let sorted: Vec<Value> =
+                                    indices.into_iter().map(|i| arr_values[i].clone()).collect();
+                                return Ok(Value::Array(Rc::new(RefCell::new(sorted))));
+                            }
+                            "with" => {
+                                // ES2023: a COPY with one index replaced; negative index counts from the
+                                // end; out-of-range throws a catchable RangeError (matches vm/native/node).
+                                let index = arg_vals.first().cloned().unwrap_or(Value::Null);
+                                let value = arg_vals.get(1).cloned().unwrap_or(Value::Null);
+                                let mut v = arr.borrow().clone();
+                                let len = v.len() as i64;
+                                let rel = match index {
+                                    Value::Number(n) if n.is_finite() => n as i64,
+                                    _ => 0,
+                                };
+                                let actual = if rel >= 0 { rel } else { len + rel };
+                                if actual < 0 || actual >= len {
+                                    let err = crate::natives::range_error_construct(&[Value::String(
+                                        format!("Invalid index : {}", rel).into(),
+                                    )])
+                                    .unwrap_or(Value::Null);
+                                    return Err(EvalError::Throw(err));
+                                }
+                                v[actual as usize] = value;
+                                return Ok(Value::Array(Rc::new(RefCell::new(v))));
+                            }
+                            "toSpliced" => {
+                                // ES2023: a COPY with the splice applied; returns the resulting array
+                                // (splice returns the removed elements). Same normalization as `splice`.
+                                let mut result = arr.borrow().clone();
+                                let len = result.len() as i64;
+                                let start = match arg_vals.first() {
+                                    Some(Value::Number(n)) => {
+                                        let n = *n as i64;
+                                        if n < 0 { (len + n).max(0) as usize } else { n.min(len) as usize }
+                                    }
+                                    _ => 0,
+                                };
+                                let delete_count = match arg_vals.get(1) {
+                                    Some(Value::Number(n)) => (*n as i64).max(0) as usize,
+                                    _ => (len as usize).saturating_sub(start),
+                                };
+                                let actual_delete = delete_count.min(result.len().saturating_sub(start));
+                                result.drain(start..start + actual_delete);
+                                if arg_vals.len() > 2 {
+                                    for (i, item) in arg_vals[2..].iter().cloned().enumerate() {
+                                        result.insert(start + i, item);
+                                    }
+                                }
+                                return Ok(Value::Array(Rc::new(RefCell::new(result))));
+                            }
                             "fill" => {
                                 // Array.prototype.fill(value, start?, end?) — in place (issue #76).
                                 let value = arg_vals.first().cloned().unwrap_or(Value::Null);
@@ -1912,6 +2269,62 @@ impl Evaluator {
                                 }
                                 return Ok(acc);
                             }
+                            "reduceRight" => {
+                                let callback = arg_vals.first().cloned().unwrap_or(Value::Null);
+                                let arr_borrow = arr.borrow().clone();
+                                let arr_value = Value::Array(arr.clone());
+                                let len = arr_borrow.len();
+                                // With an initial value, fold indices len-1..0; without, seed from the
+                                // last element and fold len-2..0. Empty + no init → TypeError.
+                                let (mut acc, start) = if arg_vals.len() > 1 {
+                                    (arg_vals[1].clone(), len)
+                                } else if len > 0 {
+                                    (arr_borrow[len - 1].clone(), len - 1)
+                                } else {
+                                    return Err(EvalError::Error("Reduce of empty array with no initial value".to_string()));
+                                };
+                                let mut i = start;
+                                while i > 0 {
+                                    i -= 1;
+                                    acc = self.call_func(&callback, &[acc, arr_borrow[i].clone(), Value::Number(i as f64), arr_value.clone()])?;
+                                }
+                                return Ok(acc);
+                            }
+                            "keys" => {
+                                let len = arr.borrow().len();
+                                let it = tishlang_builtins::iterator::array_iterator(
+                                    (0..len).map(|i| tishlang_core::Value::Number(i as f64)).collect(),
+                                );
+                                return Ok(crate::value_convert::core_to_eval(it));
+                            }
+                            "values" => {
+                                let items: Vec<tishlang_core::Value> = arr
+                                    .borrow()
+                                    .iter()
+                                    .map(|v| {
+                                        crate::value_convert::eval_to_core(v)
+                                            .unwrap_or(tishlang_core::Value::Null)
+                                    })
+                                    .collect();
+                                let it = tishlang_builtins::iterator::array_iterator(items);
+                                return Ok(crate::value_convert::core_to_eval(it));
+                            }
+                            "entries" => {
+                                let items: Vec<tishlang_core::Value> = arr
+                                    .borrow()
+                                    .iter()
+                                    .enumerate()
+                                    .map(|(i, v)| {
+                                        tishlang_core::Value::Array(tishlang_core::VmRef::new(vec![
+                                            tishlang_core::Value::Number(i as f64),
+                                            crate::value_convert::eval_to_core(v)
+                                                .unwrap_or(tishlang_core::Value::Null),
+                                        ]))
+                                    })
+                                    .collect();
+                                let it = tishlang_builtins::iterator::array_iterator(items);
+                                return Ok(crate::value_convert::core_to_eval(it));
+                            }
                             "find" => {
                                 let callback = arg_vals.first().cloned().unwrap_or(Value::Null);
                                 let arr_borrow = arr.borrow().clone(); // snapshot; drop borrow before callbacks
@@ -2227,6 +2640,32 @@ impl Evaluator {
                             "trim" => {
                                 return Ok(Value::String(s.trim().into()));
                             }
+                            "trimStart" => {
+                                return Ok(Value::String(s.trim_start().into()));
+                            }
+                            "trimEnd" => {
+                                return Ok(Value::String(s.trim_end().into()));
+                            }
+                            "normalize" => {
+                                let form = match arg_vals.first() {
+                                    None | Some(Value::Null) => "NFC".to_string(),
+                                    Some(Value::String(f)) => f.to_string(),
+                                    Some(v) => v.to_string(),
+                                };
+                                match tishlang_builtins::string::normalize_form(s, &form) {
+                                    Some(out) => return Ok(Value::String(out.into())),
+                                    None => {
+                                        let err = crate::natives::range_error_construct(&[
+                                            Value::String(
+                                                "The normalization form should be one of NFC, NFD, NFKC, NFKD."
+                                                    .into(),
+                                            ),
+                                        ])
+                                        .unwrap_or(Value::Null);
+                                        return Err(EvalError::Throw(err));
+                                    }
+                                }
+                            }
                             "toUpperCase" => {
                                 return Ok(Value::String(s.to_uppercase().into()));
                             }
@@ -2238,14 +2677,28 @@ impl Evaluator {
                                     Some(Value::String(ss)) => ss.as_ref(),
                                     _ => return Ok(Value::Bool(false)),
                                 };
-                                return Ok(Value::Bool(s.starts_with(search)));
+                                // position: test as if the string began at char `position`.
+                                let pos = match arg_vals.get(1) {
+                                    Some(Value::Number(n)) if *n > 0.0 => *n as usize,
+                                    _ => 0,
+                                };
+                                let byte_start = s.char_indices().nth(pos).map(|(b, _)| b).unwrap_or(s.len());
+                                return Ok(Value::Bool(s[byte_start..].starts_with(search)));
                             }
                             "endsWith" => {
                                 let search = match arg_vals.first() {
                                     Some(Value::String(ss)) => ss.as_ref(),
                                     _ => return Ok(Value::Bool(false)),
                                 };
-                                return Ok(Value::Bool(s.ends_with(search)));
+                                // endPosition: test as if the string ended at char `endPosition`.
+                                let char_count = s.chars().count();
+                                let end = match arg_vals.get(1) {
+                                    Some(Value::Number(n)) if *n >= 0.0 => (*n as usize).min(char_count),
+                                    Some(Value::Number(_)) => 0,
+                                    _ => char_count,
+                                };
+                                let byte_end = s.char_indices().nth(end).map(|(b, _)| b).unwrap_or(s.len());
+                                return Ok(Value::Bool(s[..byte_end].ends_with(search)));
                             }
                             "replace" => {
                                 #[cfg(feature = "regex")]
@@ -2285,6 +2738,17 @@ impl Evaluator {
                                         Some(Value::String(ss)) => ss.to_string(),
                                         _ => String::new(),
                                     };
+                                    if replacement.contains('$') && !search.is_empty() {
+                                        let sref = s.as_ref();
+                                        if let Some(m) = sref.find(&search) {
+                                            let mut out = String::with_capacity(sref.len());
+                                            out.push_str(&sref[..m]);
+                                            out.push_str(&tishlang_builtins::string::expand_replacement(
+                                                &replacement, &search, &sref[..m], &sref[m + search.len()..]));
+                                            out.push_str(&sref[m + search.len()..]);
+                                            return Ok(Value::String(out.into()));
+                                        }
+                                    }
                                     return Ok(Value::String(s.replacen(&search, &replacement, 1).into()));
                                 }
                                 #[cfg(feature = "regex")]
@@ -2299,6 +2763,21 @@ impl Evaluator {
                                     Some(Value::String(ss)) => ss.to_string(),
                                     _ => String::new(),
                                 };
+                                if replacement.contains('$') && !search.is_empty() {
+                                    let sref = s.as_ref();
+                                    let mut out = String::with_capacity(sref.len());
+                                    let (mut last, mut start) = (0usize, 0usize);
+                                    while let Some(pos) = sref[start..].find(&search) {
+                                        let m = start + pos;
+                                        out.push_str(&sref[last..m]);
+                                        out.push_str(&tishlang_builtins::string::expand_replacement(
+                                            &replacement, &search, &sref[..m], &sref[m + search.len()..]));
+                                        last = m + search.len();
+                                        start = last;
+                                    }
+                                    out.push_str(&sref[last..]);
+                                    return Ok(Value::String(out.into()));
+                                }
                                 return Ok(Value::String(s.replace(&search, &replacement).into()));
                             }
                             "charAt" => {
@@ -2334,6 +2813,35 @@ impl Evaluator {
                                     .map(|c| Value::Number(c as u32 as f64))
                                     .unwrap_or(Value::Number(f64::NAN)));
                             }
+                            "codePointAt" => {
+                                let idx = match arg_vals.first() {
+                                    Some(Value::Number(n)) if *n >= 0.0 => *n as usize,
+                                    _ => return Ok(Value::Null),
+                                };
+                                return Ok(nth_char_cached(s, idx)
+                                    .map(|c| Value::Number(c as u32 as f64))
+                                    .unwrap_or(Value::Null));
+                            }
+                            "substr" => {
+                                // (interp lacked substr; vm/native had it — this closes the gap.)
+                                let chars: Vec<char> = s.chars().collect();
+                                let len = chars.len() as i64;
+                                let mut start = match arg_vals.first() {
+                                    Some(Value::Number(n)) => *n as i64,
+                                    _ => 0,
+                                };
+                                if start < 0 {
+                                    start = (len + start).max(0);
+                                }
+                                let start = (start as usize).min(chars.len());
+                                let count = match arg_vals.get(1) {
+                                    Some(Value::Number(n)) => (*n as i64).max(0) as usize,
+                                    _ => chars.len() - start,
+                                };
+                                let out: String =
+                                    chars[start..(start + count).min(chars.len())].iter().collect();
+                                return Ok(Value::String(out.into()));
+                            }
                             "repeat" => {
                                 let count = match arg_vals.first() {
                                     Some(Value::Number(n)) if *n >= 0.0 => *n as usize,
@@ -2383,6 +2891,35 @@ impl Evaluator {
                                 return Ok(Value::Null);
                             }
                             #[cfg(feature = "regex")]
+                            "matchAll" => {
+                                let regexp = arg_vals.first().cloned().unwrap_or(Value::Null);
+                                match crate::regex::string_match_all(s, &regexp) {
+                                    Ok(matches) => {
+                                        let core_matches: Vec<tishlang_core::Value> = matches
+                                            .iter()
+                                            .map(|m| {
+                                                crate::value_convert::eval_to_core(m)
+                                                    .unwrap_or(tishlang_core::Value::Null)
+                                            })
+                                            .collect();
+                                        let it = tishlang_builtins::iterator::array_iterator(
+                                            core_matches,
+                                        );
+                                        return Ok(crate::value_convert::core_to_eval(it));
+                                    }
+                                    Err(()) => {
+                                        let err = crate::natives::type_error_construct(&[
+                                            Value::String(
+                                                "String.prototype.matchAll called with a non-global RegExp argument"
+                                                    .into(),
+                                            ),
+                                        ])
+                                        .unwrap_or(Value::Null);
+                                        return Err(EvalError::Throw(err));
+                                    }
+                                }
+                            }
+                            #[cfg(feature = "regex")]
                             "search" => {
                                 if let Some(regexp) = arg_vals.first() {
                                     return Ok(crate::regex::string_search(s, regexp));
@@ -2408,6 +2945,40 @@ impl Evaluator {
                             let formatted = tishlang_builtins::number::to_fixed_str(*n, digits as usize);
                             return Ok(Value::String(formatted.into()));
                         }
+                        if method_name.as_ref() == "toExponential" {
+                            let digits = arg_vals.first().and_then(|v| match v {
+                                Value::Number(d) => Some((*d as i32).clamp(0, 100) as usize),
+                                _ => None,
+                            });
+                            return Ok(Value::String(
+                                tishlang_builtins::number::to_exponential_str(*n, digits).into(),
+                            ));
+                        }
+                        if method_name.as_ref() == "toPrecision" {
+                            match arg_vals.first() {
+                                Some(Value::Number(p)) => {
+                                    let pi = *p as i32;
+                                    if !(1..=100).contains(&pi) && n.is_finite() {
+                                        let err = crate::natives::range_error_construct(&[
+                                            Value::String(
+                                                "toPrecision() argument must be between 1 and 100"
+                                                    .into(),
+                                            ),
+                                        ])
+                                        .unwrap_or(Value::Null);
+                                        return Err(EvalError::Throw(err));
+                                    }
+                                    return Ok(Value::String(
+                                        tishlang_builtins::number::to_precision_str(*n, pi).into(),
+                                    ));
+                                }
+                                _ => {
+                                    return Ok(Value::String(
+                                        tishlang_core::js_number_to_string(*n).into(),
+                                    ))
+                                }
+                            }
+                        }
                         if method_name.as_ref() == "toString" {
                             // Shares the VM/native formatting via the backend-agnostic helper
                             // (issue #59). Radix defaults to 10; 2–36 supported, else RangeError.
@@ -2821,6 +3392,12 @@ impl Evaluator {
                     Value::Array(arr) => {
                         let idx = match &idx_val {
                             Value::Number(n) => *n as usize,
+                            // Canonical integer string key → index (#432); a non-index string key
+                            // can't live in a Vec-backed array, so the write is a no-op.
+                            Value::String(s) => match tishlang_core::str_to_array_index(s) {
+                                Some(i) => i,
+                                None => return Ok(val),
+                            },
                             _ => return Err(EvalError::Error(format!(
                                 "Array index must be a number, got {:?}",
                                 idx_val
@@ -3331,7 +3908,31 @@ impl Evaluator {
                 }
                 Err(EvalError::Error("Not a function".to_string()))
             }
-            Value::Native(native_fn) => native_fn(args).map_err(EvalError::Error),
+            Value::Native(native_fn) => {
+                // #122: Node fs callback form — `readFile(path, (err, data) => …)`. The self-less
+                // `Value::Native` bridge can't invoke an eval callback (a core `Callable` can't
+                // re-enter the interpreter), so handle it here where `&self` is available: run the
+                // op's core on the non-callback args, split its Result into `(err, data)`, and call
+                // the callback. Matches the VM/native backends (fs_ext runs the callback in-core).
+                #[cfg(feature = "fs")]
+                if let Some(cb @ Value::Function { .. }) = args.last() {
+                    if let Some(core_op) = natives::fsx::callback_core(*native_fn) {
+                        let cb = cb.clone();
+                        let core_args = args[..args.len() - 1]
+                            .iter()
+                            .map(crate::value_convert::eval_to_core)
+                            .collect::<Result<Vec<_>, String>>()
+                            .map_err(EvalError::Error)?;
+                        let (err, data) = match core_op(&core_args) {
+                            Ok(v) => (Value::Null, crate::value_convert::core_to_eval(v)),
+                            Err(e) => (crate::value_convert::core_to_eval(e), Value::Null),
+                        };
+                        self.call_func(&cb, &[err, data])?;
+                        return Ok(Value::Null);
+                    }
+                }
+                native_fn(args).map_err(EvalError::Error)
+            }
             #[cfg(feature = "http")]
             Value::PromiseResolver(r) => {
                 let value = args.first().cloned().unwrap_or(Value::Null);
@@ -3959,6 +4560,15 @@ impl Evaluator {
     /// `.entries()` — into a `Vec` by calling `next()` until `done`. Returns `None` when `v`
     /// is not such an object. Shared by `for…of` and spread so both treat iterators like JS.
     fn drain_eval_iterator(&self, v: &Value) -> Option<Vec<Value>> {
+        // A string spreads as its characters (`[...s]`, `f(...s)`); for-of over a string is handled
+        // separately at the loop site, but spread routes through here. (#440)
+        if let Value::String(s) = v {
+            return Some(
+                s.chars()
+                    .map(|c| Value::String(std::sync::Arc::from(c.to_string())))
+                    .collect(),
+            );
+        }
         if !matches!(v, Value::Object(_)) {
             return None;
         }
@@ -4085,6 +4695,12 @@ impl Evaluator {
             Value::Array(arr) => {
                 let idx = match index {
                     Value::Number(n) => *n as usize,
+                    // A canonical integer string key ("0","1",…) indexes the array (#432), so
+                    // `arr["0"] === arr[0]`; any other key reads Null.
+                    Value::String(s) => match tishlang_core::str_to_array_index(s) {
+                        Some(i) => i,
+                        None => return Ok(Value::Null),
+                    },
                     _ => return Ok(Value::Null),
                 };
                 Ok(arr.borrow().get(idx).cloned().unwrap_or(Value::Null))
@@ -4148,14 +4764,16 @@ impl Evaluator {
                 tishlang_core::write_json_number(&mut s, *n);
                 s
             }
-            Value::String(s) => format!(
-                "\"{}\"",
-                s.replace('\\', "\\\\")
-                    .replace('"', "\\\"")
-                    .replace('\n', "\\n")
-                    .replace('\r', "\\r")
-                    .replace('\t', "\\t")
-            ),
+            Value::String(s) => {
+                // Use the shared core escaper so control chars (`\b`, `\f`, `\u00xx`) are escaped
+                // exactly like the vm/native path — the old hand-rolled `.replace()` chain missed
+                // them and produced invalid JSON (raw control bytes). #437
+                let mut out = String::with_capacity(s.len() + 2);
+                out.push('"');
+                tishlang_core::escape_json_string_into(&mut out, s);
+                out.push('"');
+                out
+            }
             Value::Array(arr) => {
                 let ptr = Rc::as_ptr(arr) as *const ();
                 if ancestors.contains(&ptr) {
@@ -4229,16 +4847,26 @@ impl Evaluator {
     }
 
     fn object_keys(args: &[Value]) -> Result<Value, String> {
-        if let Some(Value::Object(obj)) = args.first() {
-            let keys: Vec<Value> = obj
-                .borrow()
-                .strings
-                .keys()
-                .map(|k| Value::String(Arc::clone(k)))
-                .collect();
-            Ok(Value::Array(Rc::new(RefCell::new(keys))))
-        } else {
-            Ok(Value::Array(Rc::new(RefCell::new(Vec::new()))))
+        match args.first() {
+            Some(Value::Object(obj)) => {
+                let keys: Vec<Value> = obj
+                    .borrow()
+                    .strings
+                    .keys()
+                    .map(|k| Value::String(Arc::clone(k)))
+                    .collect();
+                Ok(Value::Array(Rc::new(RefCell::new(keys))))
+            }
+            // `Object.keys(array)` → index strings "0".."len-1" (own enumerable keys are the indices),
+            // matching node and the shared builtin.
+            Some(Value::Array(arr)) => {
+                let len = arr.borrow().len();
+                let keys: Vec<Value> = (0..len)
+                    .map(|i| Value::String(Arc::from(i.to_string())))
+                    .collect();
+                Ok(Value::Array(Rc::new(RefCell::new(keys))))
+            }
+            _ => Ok(Value::Array(Rc::new(RefCell::new(Vec::new())))),
         }
     }