@tishlang/tish 1.13.2 → 2.0.0

package/crates/tish_eval/src/http.rs

@@ -103,10 +103,13 @@ pub fn value_to_response(value: &Value) -> (u16, Vec<(String, String)>, String)
     (status, headers, body)
 }
 
+/// `(status, headers, file path)` extracted from a response object's `file` key.
+type FileResponse = (u16, Vec<(String, String)>, String);
+
 /// If the response value has a `file` key, stream that path (binary-safe). Matches `tishlang_runtime` HTTP behavior.
 pub(crate) fn extract_file_from_response(
     value: &Value,
-) -> Option<(u16, Vec<(String, String)>, String)> {
+) -> Option<FileResponse> {
     let Value::Object(obj) = value else {
         return None;
     };

package/crates/tish_eval/src/natives.rs

@@ -80,8 +80,8 @@ pub fn parse_int(args: &[Value]) -> Result<Value, String> {
 
 pub fn parse_float(args: &[Value]) -> Result<Value, String> {
     let s = args.first().map(|v| v.to_string()).unwrap_or_default();
-    let n: f64 = s.trim().parse().unwrap_or(f64::NAN);
-    Ok(Value::Number(n))
+    // JS parseFloat parses the longest leading numeric prefix (issue #36); shared with VM/native.
+    Ok(Value::Number(tishlang_builtins::globals::js_parse_float(&s)))
 }
 
 pub fn is_finite(args: &[Value]) -> Result<Value, String> {
@@ -215,10 +215,9 @@ pub fn math_round(args: &[Value]) -> Result<Value, String> {
 }
 
 pub fn math_random(_args: &[Value]) -> Result<Value, String> {
-    use std::collections::hash_map::RandomState;
-    use std::hash::{BuildHasher, Hasher};
-    let random = RandomState::new().build_hasher().finish() as f64 / u64::MAX as f64;
-    Ok(Value::Number(random))
+    // Match the VM / builtins (`rand::random::<f64>()`) — uniform [0,1). The old
+    // RandomState-hash was non-uniform and diverged from every other backend.
+    Ok(Value::Number(rand::random::<f64>()))
 }
 
 pub fn math_pow(args: &[Value]) -> Result<Value, String> {
@@ -277,19 +276,94 @@ pub fn math_trunc(args: &[Value]) -> Result<Value, String> {
     ))
 }
 
-pub fn date_now(_args: &[Value]) -> Result<Value, String> {
-    use std::time::{SystemTime, UNIX_EPOCH};
-    let ms = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|d| d.as_millis() as f64)
-        .unwrap_or(0.0);
-    Ok(Value::Number(ms))
+// Hyperbolic / inverse-hyperbolic / cbrt / base-2/10 logs — these were missing from the
+// interpreter's `Math`, so they returned "Not a function" (issue #61, and an interp↔VM
+// divergence under #67). One macro per unary `f64` method keeps them in lockstep with the VM.
+macro_rules! math_unary {
+    ($name:ident, $method:ident) => {
+        pub fn $name(args: &[Value]) -> Result<Value, String> {
+            Ok(Value::Number(
+                get_num(args.first().unwrap_or(&Value::Null)).$method(),
+            ))
+        }
+    };
 }
+math_unary!(math_sinh, sinh);
+math_unary!(math_cosh, cosh);
+math_unary!(math_tanh, tanh);
+math_unary!(math_asinh, asinh);
+math_unary!(math_acosh, acosh);
+math_unary!(math_atanh, atanh);
+math_unary!(math_cbrt, cbrt);
+math_unary!(math_log2, log2);
+math_unary!(math_log10, log10);
 
 pub fn array_is_array(args: &[Value]) -> Result<Value, String> {
     Ok(Value::Bool(matches!(args.first(), Some(Value::Array(_)))))
 }
 
+/// Build a JS-style error object `{ name, message }` for the interpreter (issue #60).
+fn make_error_obj(name: &str, args: &[Value]) -> Value {
+    let message = args.first().map(|v| v.to_string()).unwrap_or_default();
+    let mut m = crate::value::PropMap::with_capacity(2);
+    m.insert("name".into(), Value::String(name.into()));
+    m.insert("message".into(), Value::String(message.into()));
+    Value::object(m)
+}
+
+pub fn error_construct(args: &[Value]) -> Result<Value, String> {
+    Ok(make_error_obj("Error", args))
+}
+pub fn type_error_construct(args: &[Value]) -> Result<Value, String> {
+    Ok(make_error_obj("TypeError", args))
+}
+pub fn range_error_construct(args: &[Value]) -> Result<Value, String> {
+    Ok(make_error_obj("RangeError", args))
+}
+pub fn syntax_error_construct(args: &[Value]) -> Result<Value, String> {
+    Ok(make_error_obj("SyntaxError", args))
+}
+
+/// `Array(...)` / `new Array(...)` (issue #72) — mirrors `tishlang_builtins::construct::
+/// array_construct` for the interpreter's `Value`. A single non-negative integer is a length
+/// (null holes); other args become the array's elements.
+pub fn array_construct(args: &[Value]) -> Result<Value, String> {
+    if let [Value::Number(n)] = args {
+        let n = *n;
+        if n >= 0.0 && n.fract() == 0.0 && n <= 4_294_967_295.0 {
+            return Ok(Value::array(vec![Value::Null; n as usize]));
+        }
+    }
+    Ok(Value::array(args.to_vec()))
+}
+
+/// `String(value)` as a function: JS `ToString` coercion (arrays comma-join recursively,
+/// objects → "[object Object]", null → "null"), matching the VM/native `string_convert`.
+pub fn string_convert(args: &[Value]) -> Result<Value, String> {
+    let v = args.first().unwrap_or(&Value::Null);
+    Ok(Value::String(v.to_js_string().into()))
+}
+
+/// `Number(value)` coercion (issue #36) — shares the string parser with the VM/native
+/// backend so the result is byte-identical.
+pub fn number_convert(args: &[Value]) -> Result<Value, String> {
+    let v = args.first().unwrap_or(&Value::Null);
+    let n = match v {
+        Value::Number(n) => *n,
+        Value::Bool(b) => {
+            if *b {
+                1.0
+            } else {
+                0.0
+            }
+        }
+        Value::Null => 0.0,
+        Value::String(s) => tishlang_builtins::globals::parse_numeric_string(s),
+        other => tishlang_builtins::globals::parse_numeric_string(&other.to_js_string()),
+    };
+    Ok(Value::Number(n))
+}
+
 pub fn string_from_char_code(args: &[Value]) -> Result<Value, String> {
     let s: String = args
         .iter()
@@ -397,3 +471,81 @@ pub fn mkdir(args: &[Value]) -> Result<Value, String> {
     };
     Ok(Value::Bool(result.is_ok()))
 }
+
+// ── Interactive terminal I/O (issue #101), behind the `tty` feature ──────────────────────
+// Build the interpreter's `Value` from the shared, Value-agnostic core in
+// `tishlang_runtime::tty`, so the interpreter, VM, and native backends behave identically.
+
+#[cfg(feature = "tty")]
+fn tty_obj(pairs: Vec<(&str, Value)>) -> Value {
+    let mut m = crate::value::PropMap::with_capacity(pairs.len());
+    for (k, v) in pairs {
+        m.insert(k.into(), v);
+    }
+    Value::object(m)
+}
+
+#[cfg(feature = "tty")]
+pub fn tty_size(_args: &[Value]) -> Result<Value, String> {
+    Ok(match tishlang_runtime::tty::size() {
+        Some((cols, rows)) => tty_obj(vec![
+            ("cols", Value::Number(cols as f64)),
+            ("rows", Value::Number(rows as f64)),
+        ]),
+        None => Value::Null,
+    })
+}
+
+#[cfg(feature = "tty")]
+pub fn tty_is_tty(_args: &[Value]) -> Result<Value, String> {
+    Ok(Value::Bool(tishlang_runtime::tty::is_tty()))
+}
+
+#[cfg(feature = "tty")]
+pub fn tty_set_raw_mode(args: &[Value]) -> Result<Value, String> {
+    let on = args.first().map(|v| v.is_truthy()).unwrap_or(false);
+    Ok(Value::Bool(tishlang_runtime::tty::set_raw_mode(on)))
+}
+
+#[cfg(feature = "tty")]
+pub fn tty_enter_alt_screen(_args: &[Value]) -> Result<Value, String> {
+    Ok(Value::Bool(tishlang_runtime::tty::enter_alt_screen()))
+}
+
+#[cfg(feature = "tty")]
+pub fn tty_leave_alt_screen(_args: &[Value]) -> Result<Value, String> {
+    Ok(Value::Bool(tishlang_runtime::tty::leave_alt_screen()))
+}
+
+#[cfg(feature = "tty")]
+pub fn tty_read_line(_args: &[Value]) -> Result<Value, String> {
+    Ok(match tishlang_runtime::tty::read_line() {
+        Some(s) => Value::String(s.into()),
+        None => Value::Null,
+    })
+}
+
+#[cfg(feature = "tty")]
+pub fn tty_read(args: &[Value]) -> Result<Value, String> {
+    use tishlang_runtime::tty::TtyEvent;
+    let timeout = match args.first() {
+        Some(Value::Number(ms)) => Some(ms.max(0.0) as u64),
+        _ => None,
+    };
+    Ok(match tishlang_runtime::tty::read_event(timeout) {
+        Some(TtyEvent::Key { key, ctrl, alt, shift }) => tty_obj(vec![
+            ("type", Value::String("key".into())),
+            ("key", Value::String(key.into())),
+            ("ctrl", Value::Bool(ctrl)),
+            ("alt", Value::Bool(alt)),
+            ("shift", Value::Bool(shift)),
+        ]),
+        Some(TtyEvent::Resize { cols, rows }) => tty_obj(vec![
+            ("type", Value::String("resize".into())),
+            ("cols", Value::Number(cols as f64)),
+            ("rows", Value::Number(rows as f64)),
+        ]),
+        Some(TtyEvent::Other) => tty_obj(vec![("type", Value::String("other".into()))]),
+        None => Value::Null,
+    })
+}

package/crates/tish_eval/src/value.rs

@@ -15,7 +15,9 @@ use tishlang_core::NativeFn as CoreNativeFn;
 use tishlang_core::TishSymbol;
 
 /// Property map for interpreter object string keys (uses `eval::Value`, not `tishlang_core::Value`).
-pub type PropMap = AHashMap<Arc<str>, Value>;
+/// `IndexMap` preserves insertion order so `Object.keys` / `JSON.stringify` match JS/Node
+/// (and the VM/rust backends, which use `tishlang_core`'s insertion-ordered `PropMap`).
+pub type PropMap = indexmap::IndexMap<Arc<str>, Value>;
 
 /// Interpreter object: string keys plus optional symbol-keyed properties.
 #[derive(Clone, Debug, Default)]
@@ -110,11 +112,14 @@ pub enum Value {
     Array(Rc<RefCell<Vec<Value>>>),
     Object(Rc<RefCell<EvalObjectData>>),
     Symbol(Arc<TishSymbol>),
-    /// User-defined function with AST body
+    /// User-defined function with AST body. `env` is the lexical scope captured at definition
+    /// time, so the body resolves free variables against where it was DEFINED (a real closure),
+    /// not where it is called.
     Function {
         formals: Arc<[FunParam]>,
         rest_param: Option<Arc<str>>,
         body: Arc<Statement>,
+        env: crate::eval::ScopeRef,
     },
     /// Native/builtin function
     Native(NativeFn),
@@ -192,17 +197,9 @@ impl std::fmt::Debug for Value {
 impl std::fmt::Display for Value {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Value::Number(n) => {
-                if n.is_nan() {
-                    write!(f, "NaN")
-                } else if *n == f64::INFINITY {
-                    write!(f, "Infinity")
-                } else if *n == f64::NEG_INFINITY {
-                    write!(f, "-Infinity")
-                } else {
-                    write!(f, "{}", n)
-                }
-            }
+            // Match JS `Number.prototype.toString` (exponential past digit 21 / before −6),
+            // shared with the VM/native path via `tishlang_core`.
+            Value::Number(n) => write!(f, "{}", tishlang_core::js_number_to_string(*n)),
             Value::String(s) => write!(f, "{}", s),
             Value::Bool(b) => write!(f, "{}", b),
             Value::Null => write!(f, "null"),
@@ -265,6 +262,27 @@ impl Value {
         }
     }
 
+    /// JavaScript `ToString` coercion (as used by `Array.prototype.join`), distinct from the
+    /// `Display`/inspect form: a nested **array** stringifies to its own comma-joined `toString`
+    /// (recursively, always `,`), an **object** becomes `"[object Object]"`, and `null`/`undefined`
+    /// elements elide to `""`. Mirrors `tishlang_core::Value::to_js_string` so interp output matches
+    /// the VM/rust/cranelift/wasi backends (and Node) for join/coercion.
+    pub fn to_js_string(&self) -> String {
+        match self {
+            Value::Array(arr) => arr
+                .borrow()
+                .iter()
+                .map(|v| match v {
+                    Value::Null => String::new(),
+                    other => other.to_js_string(),
+                })
+                .collect::<Vec<_>>()
+                .join(","),
+            Value::Object(_) => "[object Object]".to_string(),
+            _ => self.to_string(),
+        }
+    }
+
     pub fn strict_eq(&self, other: &Value) -> bool {
         match (self, other) {
             (Value::Number(a), Value::Number(b)) => {

package/crates/tish_eval/src/value_convert.rs

@@ -7,7 +7,7 @@ use std::sync::Arc;
 #[cfg(feature = "regex")]
 use tishlang_core::TishRegExp;
 use ahash::AHashMap;
-use tishlang_core::{ObjectData, ObjectMap, Value as CoreValue, VmRef};
+use tishlang_core::{ObjectData, Value as CoreValue, VmRef};
 
 use crate::value::{EvalObjectData, PropMap, Value};
 
@@ -15,7 +15,7 @@ use crate::value::{EvalObjectData, PropMap, Value};
 pub fn eval_to_core(v: &Value) -> Result<CoreValue, String> {
     match v {
         Value::Number(n) => Ok(CoreValue::Number(*n)),
-        Value::String(s) => Ok(CoreValue::String(Arc::clone(s))),
+        Value::String(s) => Ok(CoreValue::String(tishlang_core::ArcStr::from(s.as_ref()))),
         Value::Bool(b) => Ok(CoreValue::Bool(*b)),
         Value::Null => Ok(CoreValue::Null),
         Value::Array(arr) => {
@@ -27,7 +27,7 @@ pub fn eval_to_core(v: &Value) -> Result<CoreValue, String> {
         }
         Value::Object(map) => {
             let b = map.borrow();
-            let mut strings = ObjectMap::default();
+            let mut strings = tishlang_core::PropMap::default();
             for (k, v) in b.strings.iter() {
                 strings.insert(Arc::clone(k), eval_to_core(v)?);
             }
@@ -55,7 +55,7 @@ pub fn eval_to_core(v: &Value) -> Result<CoreValue, String> {
 pub fn core_to_eval(v: CoreValue) -> Value {
     match v {
         CoreValue::Number(n) => Value::Number(n),
-        CoreValue::String(s) => Value::String(s),
+        CoreValue::String(s) => Value::String(Arc::from(s.as_str())),
         CoreValue::Bool(b) => Value::Bool(b),
         CoreValue::Null => Value::Null,
         CoreValue::Array(arr) => {
@@ -87,6 +87,12 @@ pub fn core_to_eval(v: CoreValue) -> Value {
         CoreValue::Promise(p) => Value::CorePromise(Arc::clone(&p)),
         #[cfg(not(feature = "http"))]
         CoreValue::Promise(_) => Value::Null,
+        // NumberArray: materialize to boxed Array for the interpreter (it has no packed path).
+        CoreValue::NumberArray(arr) => {
+            let nums = arr.borrow();
+            let out: Vec<Value> = nums.iter().map(|&n| Value::Number(n)).collect();
+            Value::Array(Rc::new(RefCell::new(out)))
+        }
         // `CoreNativeFn` is feature-gated (Rc vs Arc), so use Clone::clone
         // which works for either.
         CoreValue::Function(f) => Value::CoreFn(f.clone()),

package/crates/tish_ffi/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "tishlang_ffi"
+version = "0.1.0"
+edition = "2021"
+description = "Stable C ABI for tish native extensions — opaque value handles + extern \"C\" accessors so a cdylib (native) or wasm host-import module can interoperate with any tish backend without sharing tish_core's Rust types. Workstream B (full-backend-parity-plan.md)."
+
+license-file = { workspace = true }
+repository = { workspace = true }
+
+[features]
+default = []
+# An extension that LINKS tishlang_core must match the host's value representation/layout exactly.
+# `send-values` flips arrays/objects to Arc<Mutex<…>>; `regex` adds the `Value::RegExp` variant
+# (which changes the enum's niche/discriminant layout). The shipped `tish` (default="full") enables
+# both, so a linked extension targeting it must too. (The decoupled, host-exported-accessor model
+# avoids all of this — there is then a single tish_core.)
+send-values = ["tishlang_core/send-values"]
+regex = ["tishlang_core/regex"]
+
+[dependencies]
+tishlang_core = { path = "../tish_core", version = ">=0.1" }
+
+# Native cdylib loading (B2). Not for wasm — there is no dlopen in wasm; wasi resolves the SAME
+# handle+accessor contract via host imports (B4), so the loader is gated to non-wasm targets.
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+libloading = "0.8"