@tishlang/tish 1.7.0 → 1.8.0

package/crates/tish_builtins/src/construct.rs

@@ -2,6 +2,7 @@
 //! Browser-exact behavior remains on `tish build --target js`.
 
 use std::cell::RefCell;
+use tishlang_core::VmRef;
 use std::rc::Rc;
 use std::sync::Arc;
 
@@ -16,7 +17,7 @@ pub fn construct(callee: &Value, args: &[Value]) -> Value {
         Value::Object(o) => {
             let b = o.borrow();
             if let Some(Value::Function(ctor)) = b.get(&Arc::from(CONSTRUCT)) {
-                let c = Rc::clone(ctor);
+                let c = ctor.clone();
                 drop(b);
                 return c(args);
             }
@@ -29,11 +30,11 @@ pub fn construct(callee: &Value, args: &[Value]) -> Value {
 fn param(initial: f64) -> Value {
     let mut m = ObjectMap::default();
     m.insert(Arc::from("value"), Value::Number(initial));
-    Value::Object(Rc::new(RefCell::new(m)))
+    Value::Object(VmRef::new(m))
 }
 
 fn connect_fn() -> Value {
-    Value::Function(Rc::new(|_| Value::Null))
+    Value::native(|_| Value::Null)
 }
 
 /// Shared audio-node shape: connect, gain, optional filter fields.
@@ -44,33 +45,33 @@ fn audio_node_stub() -> Value {
     m.insert(Arc::from("frequency"), param(440.0));
     m.insert(Arc::from("Q"), param(1.0));
     m.insert(Arc::from("type"), Value::String("peaking".into()));
-    Value::Object(Rc::new(RefCell::new(m)))
+    Value::Object(VmRef::new(m))
 }
 
 fn analyser_stub() -> Value {
     let mut m = ObjectMap::default();
     m.insert(Arc::from("connect"), connect_fn());
     m.insert(Arc::from("fftSize"), Value::Number(2048.0));
-    Value::Object(Rc::new(RefCell::new(m)))
+    Value::Object(VmRef::new(m))
 }
 
 fn stereo_panner_stub() -> Value {
     let mut m = ObjectMap::default();
     m.insert(Arc::from("connect"), connect_fn());
     m.insert(Arc::from("pan"), param(0.0));
-    Value::Object(Rc::new(RefCell::new(m)))
+    Value::Object(VmRef::new(m))
 }
 
 fn audio_buffer_stub(len: usize) -> Value {
     let n = len.max(1);
-    let data = Rc::new(RefCell::new(vec![Value::Number(0.0); n]));
-    let data2 = Rc::clone(&data);
+    let data = VmRef::new(vec![Value::Number(0.0); n]);
+    let data2 = data.clone();
     let mut m = ObjectMap::default();
     m.insert(
         Arc::from("getChannelData"),
-        Value::Function(Rc::new(move |_args| Value::Array(Rc::clone(&data2)))),
+        Value::native(move |_args| Value::Array(data2.clone())),
     );
-    Value::Object(Rc::new(RefCell::new(m)))
+    Value::Object(VmRef::new(m))
 }
 
 fn buffer_source_stub() -> Value {
@@ -80,10 +81,10 @@ fn buffer_source_stub() -> Value {
     m.insert(Arc::from("connect"), connect_fn());
     m.insert(
         Arc::from("start"),
-        Value::Function(Rc::new(|_| Value::Null)),
+        Value::native(|_| Value::Null),
     );
-    m.insert(Arc::from("stop"), Value::Function(Rc::new(|_| Value::Null)));
-    Value::Object(Rc::new(RefCell::new(m)))
+    m.insert(Arc::from("stop"), Value::native(|_| Value::Null));
+    Value::Object(VmRef::new(m))
 }
 
 fn oscillator_stub() -> Value {
@@ -93,10 +94,10 @@ fn oscillator_stub() -> Value {
     m.insert(Arc::from("connect"), connect_fn());
     m.insert(
         Arc::from("start"),
-        Value::Function(Rc::new(|_| Value::Null)),
+        Value::native(|_| Value::Null),
     );
-    m.insert(Arc::from("stop"), Value::Function(Rc::new(|_| Value::Null)));
-    Value::Object(Rc::new(RefCell::new(m)))
+    m.insert(Arc::from("stop"), Value::native(|_| Value::Null));
+    Value::Object(VmRef::new(m))
 }
 
 fn audio_context_instance() -> Value {
@@ -106,66 +107,66 @@ fn audio_context_instance() -> Value {
 
     ctx.insert(
         Arc::from("createGain"),
-        Value::Function(Rc::new(|_| audio_node_stub())),
+        Value::native(|_| audio_node_stub()),
     );
     ctx.insert(
         Arc::from("createBiquadFilter"),
-        Value::Function(Rc::new(|_| audio_node_stub())),
+        Value::native(|_| audio_node_stub()),
     );
     ctx.insert(
         Arc::from("createStereoPanner"),
-        Value::Function(Rc::new(|_| stereo_panner_stub())),
+        Value::native(|_| stereo_panner_stub()),
     );
     ctx.insert(
         Arc::from("createAnalyser"),
-        Value::Function(Rc::new(|_| analyser_stub())),
+        Value::native(|_| analyser_stub()),
     );
     ctx.insert(
         Arc::from("createBuffer"),
-        Value::Function(Rc::new(|args: &[Value]| {
+        Value::native(|args: &[Value]| {
             let len = args
                 .get(1)
                 .and_then(Value::as_number)
                 .unwrap_or(0.0)
                 .clamp(0.0, 1_000_000_000.0) as usize;
             audio_buffer_stub(len)
-        })),
+        }),
     );
     ctx.insert(
         Arc::from("createBufferSource"),
-        Value::Function(Rc::new(|_| buffer_source_stub())),
+        Value::native(|_| buffer_source_stub()),
     );
     ctx.insert(
         Arc::from("createOscillator"),
-        Value::Function(Rc::new(|_| oscillator_stub())),
+        Value::native(|_| oscillator_stub()),
     );
     ctx.insert(
         Arc::from("decodeAudioData"),
-        Value::Function(Rc::new(|_| Value::Null)),
+        Value::native(|_| Value::Null),
     );
 
-    Value::Object(Rc::new(RefCell::new(ctx)))
+    Value::Object(VmRef::new(ctx))
 }
 
 /// Global `Uint8Array` for native/VM: `new Uint8Array(n)` → numeric array of zeros (not real bytes).
 pub fn uint8_array_constructor_value() -> Value {
-    let ctor = Rc::new(|args: &[Value]| {
+    let ctor = Value::native(|args: &[Value]| {
         let len = args
             .first()
             .and_then(Value::as_number)
             .unwrap_or(0.0)
             .clamp(0.0, 1_000_000_000.0) as usize;
-        Value::Array(Rc::new(RefCell::new(vec![Value::Number(0.0); len])))
+        Value::Array(VmRef::new(vec![Value::Number(0.0); len]))
     });
     let mut m = ObjectMap::default();
-    m.insert(Arc::from(CONSTRUCT), Value::Function(ctor));
-    Value::Object(Rc::new(RefCell::new(m)))
+    m.insert(Arc::from(CONSTRUCT), ctor);
+    Value::Object(VmRef::new(m))
 }
 
 /// Global `AudioContext` for native/VM: stub graph (no real audio).
 pub fn audio_context_constructor_value() -> Value {
-    let ctor = Rc::new(|_args: &[Value]| audio_context_instance());
+    let ctor = Value::native(|_args: &[Value]| audio_context_instance());
     let mut m = ObjectMap::default();
-    m.insert(Arc::from(CONSTRUCT), Value::Function(ctor));
-    Value::Object(Rc::new(RefCell::new(m)))
+    m.insert(Arc::from(CONSTRUCT), ctor);
+    Value::Object(VmRef::new(m))
 }

package/crates/tish_builtins/src/globals.rs

@@ -4,6 +4,7 @@
 //! independent of tishlang_runtime.
 
 use std::cell::RefCell;
+use tishlang_core::VmRef;
 use std::rc::Rc;
 use std::sync::Arc;
 use tishlang_core::{percent_decode, percent_encode, ObjectMap, Value};
@@ -78,9 +79,9 @@ pub fn object_keys(args: &[Value]) -> Value {
             .keys()
             .map(|k| Value::String(Arc::clone(k)))
             .collect();
-        Value::Array(Rc::new(RefCell::new(keys)))
+        Value::Array(VmRef::new(keys))
     } else {
-        Value::Array(Rc::new(RefCell::new(Vec::new())))
+        Value::Array(VmRef::new(Vec::new()))
     }
 }
 
@@ -89,9 +90,9 @@ pub fn object_values(args: &[Value]) -> Value {
     if let Some(Value::Object(obj)) = args.first() {
         let obj_borrow = obj.borrow();
         let values: Vec<Value> = obj_borrow.values().cloned().collect();
-        Value::Array(Rc::new(RefCell::new(values)))
+        Value::Array(VmRef::new(values))
     } else {
-        Value::Array(Rc::new(RefCell::new(Vec::new())))
+        Value::Array(VmRef::new(Vec::new()))
     }
 }
 
@@ -102,15 +103,15 @@ pub fn object_entries(args: &[Value]) -> Value {
         let entries: Vec<Value> = obj_borrow
             .iter()
             .map(|(k, v)| {
-                Value::Array(Rc::new(RefCell::new(vec![
+                Value::Array(VmRef::new(vec![
                     Value::String(Arc::clone(k)),
                     v.clone(),
-                ])))
+                ]))
             })
             .collect();
-        Value::Array(Rc::new(RefCell::new(entries)))
+        Value::Array(VmRef::new(entries))
     } else {
-        Value::Array(Rc::new(RefCell::new(Vec::new())))
+        Value::Array(VmRef::new(Vec::new()))
     }
 }
 
@@ -145,7 +146,7 @@ pub fn object_assign(args: &[Value]) -> Value {
         }
     }
     drop(target_mut);
-    Value::Object(Rc::clone(target))
+    Value::Object(target.clone())
 }
 
 /// parseInt(string, radix?)
@@ -203,8 +204,8 @@ pub fn object_from_entries(args: &[Value]) -> Value {
             }
         }
 
-        Value::Object(Rc::new(RefCell::new(obj)))
+        Value::Object(VmRef::new(obj))
     } else {
-        Value::Object(Rc::new(RefCell::new(ObjectMap::default())))
+        Value::Object(VmRef::new(ObjectMap::default()))
     }
 }

package/crates/tish_builtins/src/helpers.rs

@@ -1,6 +1,7 @@
 //! Common helper functions used across builtin implementations.
 
 use std::cell::RefCell;
+use tishlang_core::VmRef;
 use std::rc::Rc;
 use std::sync::Arc;
 use tishlang_core::{ObjectMap, Value};
@@ -25,7 +26,7 @@ pub fn normalize_index(idx: &Value, len: i64, default: usize) -> usize {
 pub fn make_error_value(e: impl std::fmt::Display) -> Value {
     let mut obj = ObjectMap::with_capacity(1);
     obj.insert(Arc::from("error"), Value::String(e.to_string().into()));
-    Value::Object(Rc::new(RefCell::new(obj)))
+    Value::Object(VmRef::new(obj))
 }
 
 /// Extract a number from a Value, returning None for non-numbers.

package/crates/tish_builtins/src/object.rs

@@ -4,18 +4,19 @@
 //! Functions will be migrated here from tishlang_runtime and tishlang_eval.
 
 use std::cell::RefCell;
+use tishlang_core::VmRef;
 use std::rc::Rc;
 use std::sync::Arc;
 use tishlang_core::{ObjectMap, Value};
 
 /// Create a new empty object Value.
 pub fn new() -> Value {
-    Value::Object(Rc::new(RefCell::new(ObjectMap::default())))
+    Value::Object(VmRef::new(ObjectMap::default()))
 }
 
 /// Create a new object Value with a given capacity.
 pub fn with_capacity(capacity: usize) -> Value {
-    Value::Object(Rc::new(RefCell::new(ObjectMap::with_capacity(capacity))))
+    Value::Object(VmRef::new(ObjectMap::with_capacity(capacity)))
 }
 
 /// Get the keys of an object.

package/crates/tish_builtins/src/string.rs

@@ -4,6 +4,7 @@
 //! JavaScript, matching .length and .charAt(). Byte offsets are never exposed.
 
 use crate::helpers::normalize_index;
+use tishlang_core::VmRef;
 use std::cell::RefCell;
 use std::rc::Rc;
 use std::sync::Arc;
@@ -194,13 +195,13 @@ pub fn split(s: &Value, sep: &Value) -> Value {
     if let Value::String(s) = s {
         let separator = match sep {
             Value::String(ss) => ss.as_ref(),
-            _ => return Value::Array(Rc::new(RefCell::new(vec![Value::String(Arc::clone(s))]))),
+            _ => return Value::Array(VmRef::new(vec![Value::String(Arc::clone(s))])),
         };
         let parts: Vec<Value> = s
             .split(separator)
             .map(|p| Value::String(p.into()))
             .collect();
-        Value::Array(Rc::new(RefCell::new(parts)))
+        Value::Array(VmRef::new(parts))
     } else {
         Value::Null
     }
@@ -275,6 +276,53 @@ pub fn replace_all(s: &Value, search: &Value, replacement: &Value) -> Value {
     replace_impl(s, search, replacement, true)
 }
 
+/// HTML entity escape for the five canonical characters (`& < > " '`).
+/// Single linear pass over the input; takes a zero-copy fast path when no
+/// character needs escaping. Matches TFB's fortunes verifier byte-for-byte.
+pub fn escape_html(s: &Value) -> Value {
+    let input = match s {
+        Value::String(s) => s.as_ref(),
+        Value::Null => return Value::String(Arc::from("")),
+        _ => return Value::Null,
+    };
+    let bytes = input.as_bytes();
+    let mut extra = 0usize;
+    for b in bytes {
+        match b {
+            b'&' => extra += 4,
+            b'<' | b'>' => extra += 3,
+            b'"' => extra += 5,
+            b'\'' => extra += 4,
+            _ => {}
+        }
+    }
+    if extra == 0 {
+        return Value::String(Arc::clone(match s {
+            Value::String(s) => s,
+            _ => unreachable!(),
+        }));
+    }
+    let mut out = String::with_capacity(input.len() + extra);
+    let mut last = 0usize;
+    for (i, b) in bytes.iter().enumerate() {
+        let repl: Option<&'static str> = match b {
+            b'&' => Some("&amp;"),
+            b'<' => Some("&lt;"),
+            b'>' => Some("&gt;"),
+            b'"' => Some("&quot;"),
+            b'\'' => Some("&#39;"),
+            _ => None,
+        };
+        if let Some(r) = repl {
+            out.push_str(&input[last..i]);
+            out.push_str(r);
+            last = i + 1;
+        }
+    }
+    out.push_str(&input[last..]);
+    Value::String(Arc::from(out))
+}
+
 fn char_at_idx(s: &str, idx: usize) -> Option<char> {
     s.chars().nth(idx)
 }
@@ -463,7 +511,7 @@ mod tests {
         assert_eq!(a.borrow().len(), 2);
         assert_same!(
             split(&s("x"), &n(1.0)),
-            Value::Array(Rc::new(RefCell::new(vec![s("x")])))
+            Value::Array(VmRef::new(vec![s("x")]))
         );
         assert_same!(split(&n(1.0), &s(",")), Value::Null);
         assert_same!(trim(&s("  x  ")), s("x"));
@@ -550,4 +598,26 @@ mod tests {
     fn last_index_of_non_string() {
         assert_same!(last_index_of(&n(1.0), &s("a"), &n(0.0)), n(-1.0));
     }
+
+    #[test]
+    fn escape_html_basic() {
+        assert_same!(escape_html(&s("plain text")), s("plain text"));
+        assert_same!(
+            escape_html(&s("<script>alert(\"xss\")</script>")),
+            s("&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;")
+        );
+        assert_same!(escape_html(&s("tom & jerry")), s("tom &amp; jerry"));
+        assert_same!(escape_html(&s("it's")), s("it&#39;s"));
+        assert_same!(
+            escape_html(&s("<script>alert('x' & \"y\");</script>")),
+            s("&lt;script&gt;alert(&#39;x&#39; &amp; &quot;y&quot;);&lt;/script&gt;")
+        );
+    }
+
+    #[test]
+    fn escape_html_unicode_preserved() {
+        // Astral symbols / non-ASCII must round-trip unchanged.
+        assert_same!(escape_html(&s("フレーム")), s("フレーム"));
+        assert_same!(escape_html(&s("🎉 & 💥")), s("🎉 &amp; 💥"));
+    }
 }

package/crates/tish_bytecode/src/compiler.rs

@@ -275,12 +275,12 @@ impl<'a> Compiler<'a> {
                 if let (
                     Expr::Member {
                         object: lo,
-                        prop: MemberProp::Name(p),
+                        prop: MemberProp::Name { name: p, .. },
                         ..
                     },
                     Expr::Member {
                         object: ro,
-                        prop: MemberProp::Name(pr),
+                        prop: MemberProp::Name { name: pr, .. },
                         ..
                     },
                 ) = (left.as_ref(), right.as_ref())
@@ -982,6 +982,9 @@ impl<'a> Compiler<'a> {
                     });
                 }
             },
+            Statement::TypeAlias { .. }
+            | Statement::DeclareVar { .. }
+            | Statement::DeclareFun { .. } => {}
         }
         Ok(())
     }
@@ -1001,7 +1004,7 @@ impl<'a> Compiler<'a> {
             DestructPattern::Array(elements) => {
                 for (i, elem) in elements.iter().enumerate() {
                     match elem {
-                        Some(DestructElement::Ident(name)) => {
+                        Some(DestructElement::Ident(name, _)) => {
                             self.emit(Opcode::Dup);
                             let idx = self.constant_idx(Constant::Number(i as f64));
                             self.emit(Opcode::LoadConst);
@@ -1031,7 +1034,7 @@ impl<'a> Compiler<'a> {
                     self.chunk.write_u16(key_idx);
                     self.emit(Opcode::GetIndex); // GetIndex pops obj, index and uses get_member
                     match &prop.value {
-                        DestructElement::Ident(name) => {
+                        DestructElement::Ident(name, _) => {
                             let idx = self.name_idx(name);
                             self.emit_u16(decl_op, idx);
                             if mutable {
@@ -1118,7 +1121,7 @@ impl<'a> Compiler<'a> {
                     if let (
                         Expr::Member {
                             object,
-                            prop: MemberProp::Name(key),
+                            prop: MemberProp::Name { name: key, .. },
                             optional: false,
                             ..
                         },
@@ -1231,7 +1234,7 @@ impl<'a> Compiler<'a> {
                     let jump_end = self.emit_jump(Opcode::Jump);
                     self.patch_jump(jump_to_get, self.chunk.code.len());
                     match prop {
-                        MemberProp::Name(key) => {
+                        MemberProp::Name { name: key, .. } => {
                             let idx = self.name_idx(key);
                             self.emit_u16(Opcode::GetMemberOptional, idx);
                         }
@@ -1243,7 +1246,7 @@ impl<'a> Compiler<'a> {
                     self.patch_jump(jump_end, self.chunk.code.len());
                 } else {
                     match prop {
-                        MemberProp::Name(key) => {
+                        MemberProp::Name { name: key, .. } => {
                             let idx = self.name_idx(key);
                             self.emit_u16(Opcode::GetMember, idx);
                         }
@@ -1511,14 +1514,9 @@ impl<'a> Compiler<'a> {
                 self.compile_jsx_fragment(children)?;
             }
             Expr::Await { operand, .. } => {
-                // await expr => LoadNativeExport("tish:http","await"), compile(operand), Call(1)
-                let spec_idx = self.constant_idx(Constant::String(Arc::from("tish:http")));
-                let await_idx = self.constant_idx(Constant::String(Arc::from("await")));
-                self.emit(Opcode::LoadNativeExport);
-                self.chunk.write_u16(spec_idx);
-                self.chunk.write_u16(await_idx);
+                // await expr => evaluate operand, then VM Opcode::AwaitPromise (throw on reject).
                 self.compile_expr(operand)?;
-                self.emit_u16(Opcode::Call, 1);
+                self.emit(Opcode::AwaitPromise);
             }
             Expr::LogicalAssign {
                 name, op, value, ..

package/crates/tish_bytecode/src/opcode.rs

@@ -93,13 +93,16 @@ pub enum Opcode {
     ExitBlock = 41,
     /// Like [`DeclareVar`] but does not record block-scope undo (for `for`/`for-of` header bindings).
     DeclareVarPlain = 42,
+    /// Pop the `await` operand value; if it is a `Promise`, block until settled, push the result,
+    /// or unwind to `catch` like `Throw` on rejection.
+    AwaitPromise = 43,
 }
 
 impl Opcode {
-    /// Decode byte to opcode. Safe for b in 0..=42 (matches #[repr(u8)] discriminants).
+    /// Decode byte to opcode. Safe for b in 0..=43 (matches #[repr(u8)] discriminants).
     #[inline]
     pub fn from_u8(b: u8) -> Option<Opcode> {
-        if b <= 42 {
+        if b <= 43 {
             Some(unsafe { std::mem::transmute(b) })
         } else {
             None
@@ -114,11 +117,17 @@ impl Opcode {
             | Opcode::Dup
             | Opcode::Return
             | Opcode::ExitTry
+            | Opcode::ConcatArray
+            | Opcode::MergeObject
+            | Opcode::GetIndex
+            | Opcode::SetIndex
+            | Opcode::Throw
             | Opcode::ArrayMapIdentity
             | Opcode::CallSpread
             | Opcode::ConstructSpread
             | Opcode::EnterBlock
-            | Opcode::ExitBlock => 1,
+            | Opcode::ExitBlock
+            | Opcode::AwaitPromise => 1,
             Opcode::ArraySortByProperty
             | Opcode::ArrayMapBinOp
             | Opcode::ArrayFilterBinOp

package/crates/tish_compile/Cargo.toml

@@ -9,6 +9,7 @@ repository = { workspace = true }
 [features]
 default = []
 http = []
+timers = []
 fs = []
 process = []
 regex = []