@tishlang/tish 1.13.2 → 2.0.1

package/crates/tish_runtime/src/lib.rs

@@ -12,16 +12,47 @@ use tishlang_builtins::helpers::make_error_value;
 pub use tishlang_builtins::symbol::symbol_object;
 pub use tishlang_core::ObjectMap;
 pub use tishlang_core::Value;
+pub use tishlang_core::ArcStr;
 /// Used by native codegen for `f()` / `obj()` dispatch (`Value::Function` or `__call` on objects).
 pub use tishlang_core::value_call;
+/// JS ToInt32/ToUint32 for the emitted bitwise/shift code (modulo 2³², NaN/±Infinity → 0).
+pub use tishlang_core::{to_int32, to_uint32};
 // Re-export the shared-mutable wrapper so the Rust code emitted by
 // `tishlang_compile::codegen` can write `VmRef::new(...)` without needing
 // a direct dependency on `tishlang_core` from the generated crate.
 pub use tishlang_core::{VmReadGuard, VmRef, VmWriteGuard};
 
+/// `for…of` iterable normalization for the native backend: a JS iterator object (one with a
+/// callable `next()` returning `{ value, done }`, e.g. a `Map`/`Set` `.values()` result) is
+/// drained into a `Value::Array`; arrays, strings, and everything else pass through unchanged.
+pub fn normalize_for_of(v: Value) -> Value {
+    match tishlang_core::drain_iterator(&v) {
+        Some(items) => Value::Array(VmRef::new(items)),
+        None => v,
+    }
+}
+
+pub use tishlang_builtins::construct::array_construct;
+pub use tishlang_builtins::construct::error_constructor_value as tish_error_constructor;
 pub use tishlang_builtins::construct::{
     audio_context_constructor_value as tish_audio_context_constructor, construct as tish_construct,
+};
+pub use tishlang_builtins::typedarrays::{
+    float32_array_constructor_value as tish_float32_array_constructor,
+    float64_array_constructor_value as tish_float64_array_constructor,
+    float64_array_packed,
+    int16_array_constructor_value as tish_int16_array_constructor,
+    int32_array_constructor_value as tish_int32_array_constructor,
+    int8_array_constructor_value as tish_int8_array_constructor,
+    uint16_array_constructor_value as tish_uint16_array_constructor,
+    uint32_array_constructor_value as tish_uint32_array_constructor,
     uint8_array_constructor_value as tish_uint8_array_constructor,
+    uint8_clamped_array_constructor_value as tish_uint8_clamped_array_constructor,
+};
+pub use tishlang_builtins::date::date_constructor_value as tish_date_constructor;
+pub use tishlang_builtins::collections::{
+    collection_size, map_constructor_value as tish_map_constructor,
+    set_constructor_value as tish_set_constructor,
 };
 
 // Re-export array methods from tishlang_builtins
@@ -30,7 +61,7 @@ pub use tishlang_builtins::array::{
     find_index as array_find_index, flat as array_flat_impl, flat_map as array_flat_map,
     for_each as array_for_each, includes as array_includes_impl, index_of as array_index_of_impl,
     join as array_join_impl, map as array_map, pop as array_pop, push as array_push_impl,
-    reduce as array_reduce, reverse as array_reverse, shift as array_shift,
+    fill as array_fill, reduce as array_reduce, reverse as array_reverse, shift as array_shift,
     shuffle as array_shuffle, slice as array_slice_impl, some as array_some,
     sort_default as array_sort_default, sort_numeric_asc as array_sort_numeric_asc,
     sort_numeric_desc as array_sort_numeric_desc,
@@ -110,6 +141,12 @@ pub fn string_substr(s: &Value, start: &Value, length: &Value) -> Value {
     string_substr_impl(s, start, length)
 }
 pub fn string_split(s: &Value, sep: &Value) -> Value {
+    // A RegExp separator routes to the regex splitter (matches string_replace's regex handling
+    // and the interpreter/VM), so `"a1b2c".split(RegExp("\\d",""))` works on the rust backend.
+    #[cfg(feature = "regex")]
+    if matches!(sep, Value::RegExp(_)) {
+        return string_split_regex(s, sep, None);
+    }
     string_split_impl(s, sep)
 }
 pub fn string_starts_with(s: &Value, search: &Value) -> Value {
@@ -148,16 +185,23 @@ pub fn string_last_index_of(s: &Value, search: &Value, position: &Value) -> Valu
 }
 
 /// Number.prototype.toFixed(digits) - format number with fixed decimal places (0-20)
+///
+/// Delegates to the single source of truth in `tishlang_builtins::number` so the rust
+/// backend, the bytecode VM, and the interpreter stay byte-identical. See
+/// `tish/docs/full-backend-parity-plan.md` (Workstream A).
 pub fn number_to_fixed(n: &Value, digits: &Value) -> Value {
-    let num = match n {
-        Value::Number(x) => *x,
-        _ => f64::NAN,
-    };
-    let d = match digits {
-        Value::Number(x) => (*x as i32).clamp(0, 20),
-        _ => 0,
-    };
-    Value::String(format!("{:.*}", d as usize, num).into())
+    tishlang_builtins::number::to_fixed(n, digits)
+}
+
+/// `.toString([radix])` for the compiled backend (issue #59). A number receiver uses the
+/// shared radix formatter so it stays byte-identical with the VM / interpreter; any other
+/// receiver falls back to its normal JS string, so `[1,2].toString()` / `obj.toString()`
+/// keep working.
+pub fn number_to_string(n: &Value, radix: &Value) -> Value {
+    match n {
+        Value::Number(_) => tishlang_builtins::number::to_string(n, radix),
+        other => Value::String(other.to_js_string().into()),
+    }
 }
 
 /// Operators module for compound assignment operations
@@ -175,20 +219,26 @@ pub mod ops {
                 Ok(Value::String(s.into()))
             }
             (Value::String(a), b) => {
-                let b_str = b.to_display_string();
+                let b_str = b.to_js_string();
                 let mut s = String::with_capacity(a.len() + b_str.len());
                 s.push_str(a);
                 s.push_str(&b_str);
                 Ok(Value::String(s.into()))
             }
             (a, Value::String(b)) => {
-                let a_str = a.to_display_string();
+                let a_str = a.to_js_string();
                 let mut s = String::with_capacity(a_str.len() + b.len());
                 s.push_str(&a_str);
                 s.push_str(b);
                 Ok(Value::String(s.into()))
             }
-            _ => Err(format!("Cannot add {:?} and {:?}", left, right).into()),
+            // Neither operand is a string here ⇒ numeric coercion, matching the VM's `eval_binop`
+            // (`as_number().unwrap_or(NaN)`): a null/bool/object operand (e.g. an out-of-bounds array
+            // read) coerces to NaN, so `number + null` is NaN — NOT an error that the codegen's
+            // `.unwrap_or(Value::Null)` would silently turn into `null` (the old rust-AOT divergence).
+            (a, b) => Ok(Value::Number(
+                a.as_number().unwrap_or(f64::NAN) + b.as_number().unwrap_or(f64::NAN),
+            )),
         }
     }
 
@@ -196,7 +246,10 @@ pub mod ops {
     pub fn sub(left: &Value, right: &Value) -> Result<Value, Box<dyn std::error::Error>> {
         match (left, right) {
             (Value::Number(a), Value::Number(b)) => Ok(Value::Number(a - b)),
-            _ => Err(format!("Cannot subtract {:?} from {:?}", right, left).into()),
+            // VM-parity numeric coercion (null/non-number → NaN), see `add`.
+            (a, b) => Ok(Value::Number(
+                a.as_number().unwrap_or(f64::NAN) - b.as_number().unwrap_or(f64::NAN),
+            )),
         }
     }
 
@@ -204,7 +257,10 @@ pub mod ops {
     pub fn mul(left: &Value, right: &Value) -> Result<Value, Box<dyn std::error::Error>> {
         match (left, right) {
             (Value::Number(a), Value::Number(b)) => Ok(Value::Number(a * b)),
-            _ => Err(format!("Cannot multiply {:?} and {:?}", left, right).into()),
+            // VM-parity numeric coercion (null/non-number → NaN), see `add`.
+            (a, b) => Ok(Value::Number(
+                a.as_number().unwrap_or(f64::NAN) * b.as_number().unwrap_or(f64::NAN),
+            )),
         }
     }
 
@@ -212,7 +268,10 @@ pub mod ops {
     pub fn div(left: &Value, right: &Value) -> Result<Value, Box<dyn std::error::Error>> {
         match (left, right) {
             (Value::Number(a), Value::Number(b)) => Ok(Value::Number(a / b)),
-            _ => Err(format!("Cannot divide {:?} by {:?}", left, right).into()),
+            // VM-parity numeric coercion (null/non-number → NaN), see `add`.
+            (a, b) => Ok(Value::Number(
+                a.as_number().unwrap_or(f64::NAN) / b.as_number().unwrap_or(f64::NAN),
+            )),
         }
     }
 
@@ -221,7 +280,7 @@ pub mod ops {
     pub fn lt(left: &Value, right: &Value) -> Value {
         let b = match (left, right) {
             (Value::Number(a), Value::Number(b)) => a < b,
-            (Value::String(a), Value::String(b)) => a.as_ref() < b.as_ref(),
+            (Value::String(a), Value::String(b)) => a.as_str() < b.as_str(),
             _ => false,
         };
         Value::Bool(b)
@@ -231,7 +290,7 @@ pub mod ops {
     pub fn le(left: &Value, right: &Value) -> Value {
         let b = match (left, right) {
             (Value::Number(a), Value::Number(b)) => a <= b,
-            (Value::String(a), Value::String(b)) => a.as_ref() <= b.as_ref(),
+            (Value::String(a), Value::String(b)) => a.as_str() <= b.as_str(),
             _ => false,
         };
         Value::Bool(b)
@@ -241,7 +300,7 @@ pub mod ops {
     pub fn gt(left: &Value, right: &Value) -> Value {
         let b = match (left, right) {
             (Value::Number(a), Value::Number(b)) => a > b,
-            (Value::String(a), Value::String(b)) => a.as_ref() > b.as_ref(),
+            (Value::String(a), Value::String(b)) => a.as_str() > b.as_str(),
             _ => false,
         };
         Value::Bool(b)
@@ -251,7 +310,7 @@ pub mod ops {
     pub fn ge(left: &Value, right: &Value) -> Value {
         let b = match (left, right) {
             (Value::Number(a), Value::Number(b)) => a >= b,
-            (Value::String(a), Value::String(b)) => a.as_ref() >= b.as_ref(),
+            (Value::String(a), Value::String(b)) => a.as_str() >= b.as_str(),
             _ => false,
         };
         Value::Bool(b)
@@ -261,7 +320,10 @@ pub mod ops {
     pub fn modulo(left: &Value, right: &Value) -> Result<Value, Box<dyn std::error::Error>> {
         match (left, right) {
             (Value::Number(a), Value::Number(b)) => Ok(Value::Number(a % b)),
-            _ => Err(format!("Cannot modulo {:?} by {:?}", left, right).into()),
+            // VM-parity numeric coercion (null/non-number → NaN), see `add`.
+            (a, b) => Ok(Value::Number(
+                a.as_number().unwrap_or(f64::NAN) % b.as_number().unwrap_or(f64::NAN),
+            )),
         }
     }
 }
@@ -273,6 +335,8 @@ use tishlang_builtins::globals::{
     object_assign as builtins_object_assign, object_entries as builtins_object_entries,
     object_from_entries as builtins_object_from_entries, object_keys as builtins_object_keys,
     object_values as builtins_object_values,
+    number_convert as builtins_number_convert,
+    string_convert as builtins_string_convert,
     string_from_char_code as builtins_string_from_char_code,
 };
 use tishlang_core::{json_parse as core_json_parse, json_stringify as core_json_stringify};
@@ -321,22 +385,41 @@ pub mod json {
     }
 }
 
-/// Error type for Tish throw/catch.
+/// Error type for Tish throw/catch + non-local control flow (used to model `return`/`throw`
+/// escaping `try`/`finally` in the Rust backend, which has no native exceptions).
 #[derive(Debug, Clone)]
 pub enum TishError {
+    /// A JS `throw` — catchable by `catch`.
     Throw(Value),
+    /// A JS `return value` that must escape an enclosing `try`/`finally` and unwind to the
+    /// function boundary (running each `finally` on the way out). Never caught by `catch`.
+    Return(Value),
 }
 
 impl fmt::Display for TishError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             TishError::Throw(v) => write!(f, "{}", v.to_display_string()),
+            TishError::Return(v) => write!(f, "return {}", v.to_display_string()),
         }
     }
 }
 
 impl std::error::Error for TishError {}
 
+/// Function-boundary unwind: convert a completion that escaped a function body's `Result`-closure
+/// back into the function's `Value`. A `return v` yields `v`; an uncaught `throw` panics (matching
+/// the behavior of a throw with no enclosing `try`); any other error panics.
+pub fn fn_unwind(e: Box<dyn std::error::Error>) -> Value {
+    match e.downcast::<TishError>() {
+        Ok(te) => match *te {
+            TishError::Return(v) => v,
+            TishError::Throw(v) => panic!("uncaught throw: {}", v.to_display_string()),
+        },
+        Err(orig) => panic!("error in native Tish: {:?}", orig),
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 enum LogLevel {
     Debug = 0,
@@ -483,6 +566,26 @@ pub fn math_log(args: &[Value]) -> Value {
     Value::Number(n.ln())
 }
 
+// Hyperbolic / inverse-hyperbolic / cbrt / base-2/10 logs (issue #61). Compiled backends
+// (native/cranelift/wasi) share this runtime, so wiring them here resolves all of them.
+macro_rules! runtime_math_unary {
+    ($name:ident, $method:ident) => {
+        pub fn $name(args: &[Value]) -> Value {
+            let n = extract_num(args.first()).unwrap_or(f64::NAN);
+            Value::Number(n.$method())
+        }
+    };
+}
+runtime_math_unary!(math_sinh, sinh);
+runtime_math_unary!(math_cosh, cosh);
+runtime_math_unary!(math_tanh, tanh);
+runtime_math_unary!(math_asinh, asinh);
+runtime_math_unary!(math_acosh, acosh);
+runtime_math_unary!(math_atanh, atanh);
+runtime_math_unary!(math_cbrt, cbrt);
+runtime_math_unary!(math_log2, log2);
+runtime_math_unary!(math_log10, log10);
+
 pub fn json_stringify(args: &[Value]) -> Value {
     let v = args.first().cloned().unwrap_or(Value::Null);
     Value::String(core_json_stringify(&v).into())
@@ -496,14 +599,6 @@ pub fn json_parse(args: &[Value]) -> Value {
     core_json_parse(&s).unwrap_or(Value::Null)
 }
 
-pub fn date_now(_args: &[Value]) -> Value {
-    use std::time::{SystemTime, UNIX_EPOCH};
-    let now = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|d| d.as_millis() as f64)
-        .unwrap_or(0.0);
-    Value::Number(now)
-}
 
 pub fn array_is_array(args: &[Value]) -> Value {
     builtins_array_is_array(args)
@@ -513,6 +608,16 @@ pub fn string_from_char_code(args: &[Value]) -> Value {
     builtins_string_from_char_code(args)
 }
 
+/// `String(value)` as a function (JS `ToString`). Wired into the codegen `String`
+/// global as `__call` so compiled `String(x)` matches the VM/interp.
+pub fn string_convert(args: &[Value]) -> Value {
+    builtins_string_convert(args)
+}
+
+pub fn number_convert(args: &[Value]) -> Value {
+    builtins_number_convert(args)
+}
+
 #[cfg(feature = "process")]
 pub fn process_exit(args: &[Value]) -> Value {
     let code = args
@@ -632,6 +737,13 @@ pub fn get_prop(obj: &Value, key: impl AsRef<str>) -> Value {
     let key = key.as_ref();
     match obj {
         Value::Object(map) => {
+            // `Set`/`Map` instances expose a computed `.size` (the backing store has no real
+            // `size` key); `collection_size` returns `None` for any other object.
+            if key == "size" {
+                if let Some(n) = collection_size(obj) {
+                    return Value::Number(n);
+                }
+            }
             // The map's key type is `Arc<str>`, which implements
             // `Borrow<str>` — so we can look up with a borrowed `&str`
             // directly. Previously we allocated a fresh `Arc<str>` on
@@ -648,6 +760,17 @@ pub fn get_prop(obj: &Value, key: impl AsRef<str>) -> Value {
                 Value::Null
             }
         }
+        // Packed `Float64Array` (`TISH_PACKED_ARRAYS`): `.length` and numeric-key reads, mirroring
+        // the boxed `Array` arm. Methods (`reduce`/`map`/…) materialise via `as_boxed_array`.
+        Value::NumberArray(arr) => {
+            if key == "length" {
+                Value::Number(arr.borrow().len() as f64)
+            } else if let Ok(idx) = key.parse::<usize>() {
+                arr.borrow().get(idx).copied().map(Value::Number).unwrap_or(Value::Null)
+            } else {
+                Value::Null
+            }
+        }
         Value::String(s) => {
             if key == "length" {
                 Value::Number(s.chars().count() as f64)
@@ -656,26 +779,53 @@ pub fn get_prop(obj: &Value, key: impl AsRef<str>) -> Value {
             }
         }
         #[cfg(feature = "regex")]
-        Value::RegExp(re) => {
-            let re = re.clone();
-            if key == "exec" {
+        Value::RegExp(re) => match key {
+            "exec" => {
+                let rc = re.clone();
                 Value::native(move |args: &[Value]| {
                     let input = args.first().unwrap_or(&Value::Null);
-                    regexp_exec(&Value::RegExp(re.clone()), input)
+                    regexp_exec(&Value::RegExp(rc.clone()), input)
                 })
-            } else if key == "test" {
+            }
+            "test" => {
+                let rc = re.clone();
                 Value::native(move |args: &[Value]| {
                     let input = args.first().unwrap_or(&Value::Null);
-                    regexp_test(&Value::RegExp(re.clone()), input)
+                    regexp_test(&Value::RegExp(rc.clone()), input)
                 })
-            } else {
-                Value::Null
             }
-        }
+            // Properties — mirror the interpreter + bytecode VM so all backends agree.
+            "source" => Value::String(re.borrow().source.clone().into()),
+            "flags" => Value::String(re.borrow().flags_string().into()),
+            "lastIndex" => Value::Number(re.borrow().last_index as f64),
+            "global" => Value::Bool(re.borrow().flags.global),
+            "ignoreCase" => Value::Bool(re.borrow().flags.ignore_case),
+            "multiline" => Value::Bool(re.borrow().flags.multiline),
+            "dotAll" => Value::Bool(re.borrow().flags.dot_all),
+            "unicode" => Value::Bool(re.borrow().flags.unicode),
+            "sticky" => Value::Bool(re.borrow().flags.sticky),
+            _ => Value::Null,
+        },
         Value::Opaque(o) => o
             .get_method(key)
             .map(Value::Function)
             .unwrap_or(Value::Null),
+        // Promise instance methods (`.then`/`.catch`), bound to this promise. Returning a
+        // callable here makes the rust backend match the VM family (interp/vm/cranelift/wasi),
+        // which expose these via `GetMember`. Both `p.then(cb)` (member) and `p["catch"](cb)`
+        // (index, used because `catch` is reserved) route through here / `get_index`.
+        #[cfg(any(feature = "http", feature = "promise"))]
+        Value::Promise(p) => match key {
+            "then" => {
+                let pc = p.clone();
+                Value::native(move |args: &[Value]| promise_instance_then(&pc, args))
+            }
+            "catch" => {
+                let pc = p.clone();
+                Value::native(move |args: &[Value]| promise_instance_catch(&pc, args))
+            }
+            _ => Value::Null,
+        },
         _ => Value::Null,
     }
 }
@@ -690,11 +840,65 @@ pub fn get_index(obj: &Value, index: &Value) -> Value {
             };
             arr.borrow().get(idx).cloned().unwrap_or(Value::Null)
         }
+        // Packed `Float64Array` indexing (`TISH_PACKED_ARRAYS`); mirrors the boxed `Array` arm.
+        Value::NumberArray(arr) => {
+            let idx = match index {
+                Value::Number(n) => *n as usize,
+                _ => return Value::Null,
+            };
+            arr.borrow().get(idx).copied().map(Value::Number).unwrap_or(Value::Null)
+        }
+        // `str[i]` returns the character at index `i` (issue #17) — matches the VM /
+        // interpreter; out-of-bounds / negative / non-integer indices yield null.
+        Value::String(s) => match index {
+            Value::Number(n) if *n >= 0.0 && n.fract() == 0.0 => s
+                .chars()
+                .nth(*n as usize)
+                .map(|c| Value::String(c.to_string().into()))
+                .unwrap_or(Value::Null),
+            _ => Value::Null,
+        },
         Value::Object(_) => tishlang_core::object_get(obj, index).unwrap_or(Value::Null),
+        // `promise["then"|"catch"]` — string-keyed access mirrors `get_prop` (bracket form
+        // is required for `catch`, a reserved word). Keeps the rust backend on par with the VM.
+        #[cfg(any(feature = "http", feature = "promise"))]
+        Value::Promise(_) => match index {
+            Value::String(k) => get_prop(obj, k.as_str()),
+            _ => Value::Null,
+        },
         _ => Value::Null,
     }
 }
 
+/// `delete obj[key]` / `delete obj.prop` (issue #40). Objects drop the string key; arrays
+/// clear a numeric index to a `null` hole (length preserved). Always evaluates to `true`.
+#[inline]
+pub fn delete_property(obj: &Value, key: &Value) -> Value {
+    match obj {
+        Value::Object(m) => {
+            let key_s = match key {
+                Value::String(s) => s.to_string(),
+                other => other.to_js_string(),
+            };
+            m.borrow_mut().strings.remove(key_s.as_str());
+        }
+        Value::Array(arr) => {
+            if let Value::Number(n) = key {
+                let n = *n;
+                if n >= 0.0 && n.fract() == 0.0 {
+                    let i = n as usize;
+                    let mut a = arr.borrow_mut();
+                    if i < a.len() {
+                        a[i] = Value::Null;
+                    }
+                }
+            }
+        }
+        _ => {}
+    }
+    Value::Bool(true)
+}
+
 #[inline]
 pub fn set_prop(obj: &Value, key: &str, val: Value) -> Value {
     match obj {
@@ -710,6 +914,16 @@ pub fn set_prop(obj: &Value, key: &str, val: Value) -> Value {
             }
             val
         }
+        // `arr.length = k` truncates / grows the array (holes read back as Null), matching
+        // JS and the VM/interpreter (issue #62).
+        Value::Array(arr) if key == "length" => {
+            let n = extract_num(Some(&val)).unwrap_or(f64::NAN);
+            if n.is_nan() || n < 0.0 || n.fract() != 0.0 || n > 4_294_967_295.0 {
+                panic!("Invalid array length");
+            }
+            arr.borrow_mut().resize(n as usize, Value::Null);
+            val
+        }
         _ => panic!("Cannot assign property on non-object"),
     }
 }
@@ -729,6 +943,22 @@ pub fn set_index(obj: &Value, idx: &Value, val: Value) -> Value {
             arr_mut[index] = val.clone();
             val
         }
+        // Packed `Float64Array` write (`TISH_PACKED_ARRAYS`). On the native path a `NumberArray` is
+        // always a `Float64Array`, so storing the f64 (non-numeric → `NaN`) is the correct view
+        // semantics — and unlike the boxed v1 backing, it actually coerces the write to the element
+        // type. Out-of-range index zero-fills, matching the boxed grow-with-Null behaviour.
+        Value::NumberArray(arr) => {
+            let index = match idx {
+                Value::Number(n) => *n as usize,
+                _ => panic!("Array index must be number"),
+            };
+            let mut arr_mut = arr.borrow_mut();
+            while arr_mut.len() <= index {
+                arr_mut.push(0.0);
+            }
+            arr_mut[index] = val.as_number().unwrap_or(f64::NAN);
+            val
+        }
         Value::Object(_) => {
             tishlang_core::object_set(obj, idx, val.clone()).expect("object set");
             val
@@ -742,7 +972,22 @@ pub fn in_operator(key: &Value, obj: &Value) -> Value {
         Value::Object(_) => Value::Bool(tishlang_core::object_has(obj, key)),
         Value::Array(arr) => {
             let key_str: Arc<str> = match key {
-                Value::String(s) => Arc::clone(s),
+                Value::String(s) => Arc::from(s.as_str()),
+                Value::Number(n) => n.to_string().into(),
+                _ => return Value::Bool(false),
+            };
+            let result = key_str.as_ref() == "length"
+                || key_str
+                    .parse::<usize>()
+                    .ok()
+                    .map(|i| i < arr.borrow().len())
+                    .unwrap_or(false);
+            Value::Bool(result)
+        }
+        // Packed `Float64Array` (`TISH_PACKED_ARRAYS`); same key set as the boxed `Array` arm.
+        Value::NumberArray(arr) => {
+            let key_str: Arc<str> = match key {
+                Value::String(s) => Arc::from(s.as_str()),
                 Value::Number(n) => n.to_string().into(),
                 _ => return Value::Bool(false),
             };
@@ -809,6 +1054,13 @@ mod native_promise;
 #[cfg(feature = "ws")]
 mod ws;
 
+#[cfg(feature = "tty")]
+pub mod tty;
+#[cfg(feature = "tty")]
+pub use tty::{
+    tty_enter_alt_screen, tty_is_tty, tty_leave_alt_screen, tty_read, tty_read_line, tty_set_raw_mode, tty_size,
+};
+
 #[cfg(feature = "ws")]
 pub use ws::{
     web_socket_client, web_socket_server_accept, web_socket_server_construct,
@@ -868,7 +1120,7 @@ pub fn http_serve_per_worker(
     };
     let factory: tishlang_core::NativeFn = factory;
     http::serve_per_worker(args, move |worker_id| {
-        let handler_val = factory(&[Value::Number(worker_id as f64)]);
+        let handler_val = factory.call(&[Value::Number(worker_id as f64)]);
         match handler_val {
             Value::Function(f) => f,
             _ => panic!(
@@ -885,7 +1137,10 @@ pub use timers::{
 };
 
 #[cfg(any(feature = "http", feature = "promise"))]
-pub use promise::{await_promise, promise_instance_catch, promise_instance_then, promise_object};
+pub use promise::{
+    await_promise, await_promise_throw, promise_instance_catch, promise_instance_then,
+    promise_object, promise_spawn as promise_spawn_value,
+};
 
 #[cfg(feature = "http")]
 pub use native_promise::{fetch_all_promise, fetch_async_promise, fetch_promise};
@@ -1040,7 +1295,7 @@ pub fn string_split_regex(s: &Value, separator: &Value, limit: Option<usize>) ->
         }
         Value::String(sep) => {
             let parts: Vec<Value> = input
-                .splitn(max, sep.as_ref())
+                .splitn(max, sep.as_str())
                 .map(|s| Value::String(s.into()))
                 .collect();
             Value::Array(VmRef::new(parts))
@@ -1134,7 +1389,7 @@ fn string_replace_regex_or_callback(s: &Value, search: &Value, replacement: &Val
             args.push(Value::Number(char_index as f64));
             args.push(Value::String(input.into()));
 
-            let repl_val = cb(&args);
+            let repl_val = cb.call(&args);
             let repl_str = repl_val.to_display_string();
             result.push_str(&input[last_end..byte_start]);
             result.push_str(&repl_str);