@tishlang/tish 1.4.2 → 1.5.0

package/crates/tish_eval/src/eval.rs

@@ -515,6 +515,10 @@ impl Evaluator {
         if from.starts_with("tish:") {
             return self.load_builtin_module(from);
         }
+        // Scoped native modules (e.g. `@tishlang/waterui`) registered via `TishNativeModule::virtual_builtin_modules`.
+        if self.virtual_builtins.borrow().get(from).is_some() {
+            return self.load_builtin_module(from);
+        }
         let dir = self.current_dir.borrow().clone().ok_or_else(|| {
             EvalError::Error("Cannot resolve imports: no current file directory (use run_file)".to_string())
         })?;
@@ -1203,6 +1207,9 @@ impl Evaluator {
                                 });
                                 return Ok(Value::Number(found.unwrap_or(-1.0)));
                             }
+                            "lastIndexOf" => {
+                                return Ok(Self::string_last_index_of_eval(&arg_vals, s));
+                            }
                             "includes" => {
                                 let search = match arg_vals.first() {
                                     Some(Value::String(ss)) => ss.as_ref(),
@@ -1474,7 +1481,13 @@ impl Evaluator {
                         }
                     }
                     
-                    // Fall through to normal function call
+                    // Fall through to normal function call. `get_prop` only implements `length` on
+                    // strings, so method calls would otherwise become `call_func(Null)` → Not a function.
+                    if let Value::String(s) = &obj {
+                        if method_name.as_ref() == "lastIndexOf" {
+                            return Ok(Self::string_last_index_of_eval(&arg_vals, s));
+                        }
+                    }
                     let f = self.get_prop(&obj, method_name).map_err(EvalError::Error)?;
                     return self.call_func(&f, &arg_vals);
                 }
@@ -2638,6 +2651,31 @@ impl Evaluator {
         Self::bind_destruct_pattern_scoped(&self.scope, pattern, value, mutable)
     }
 
+    /// `String.prototype.lastIndexOf` (interpreter). Kept as a helper so dispatch cannot fall
+    /// through to [`Self::get_prop`] + [`Self::call_func`] for string receivers.
+    fn string_last_index_of_eval(arg_vals: &[Value], receiver: &Arc<str>) -> Value {
+        let search = match arg_vals.first() {
+            Some(Value::String(ss)) => ss.as_ref(),
+            _ => return Value::Number(-1.0),
+        };
+        let position_core: tishlang_core::Value = match arg_vals.get(1) {
+            None => tishlang_core::Value::Number(f64::INFINITY),
+            Some(Value::Null) => tishlang_core::Value::Null,
+            Some(Value::Number(n)) => tishlang_core::Value::Number(*n),
+            Some(Value::Bool(b)) => tishlang_core::Value::Bool(*b),
+            Some(_) => tishlang_core::Value::Number(0.0),
+        };
+        let out = tishlang_builtins::string::last_index_of_str(
+            receiver.as_ref(),
+            search,
+            &position_core,
+        );
+        match out {
+            tishlang_core::Value::Number(n) => Value::Number(n),
+            _ => Value::Number(-1.0),
+        }
+    }
+
     fn get_prop(&self, obj: &Value, key: &str) -> Result<Value, String> {
         match obj {
             Value::Object(map) => Ok(map.borrow().get(key).cloned().unwrap_or(Value::Null)),

package/crates/tish_eval/src/lib.rs

@@ -3,7 +3,7 @@
 mod eval;
 #[cfg(feature = "http")]
 mod http;
-mod value_convert;
+pub mod value_convert;
 #[cfg(feature = "http")]
 mod promise;
 #[cfg(feature = "http")]

package/crates/tish_native/src/build.rs

@@ -5,6 +5,29 @@ use std::path::Path;
 
 use tishlang_compile::ResolvedNativeModule;
 
+/// `tishlang_runtime` Cargo feature names (subset of CLI / compile feature names).
+const RUNTIME_CARGO_FEATURES: &[&str] = &["http", "fs", "process", "regex", "ws"];
+
+/// Map CLI/compile features to flags passed to `tishlang_runtime` in the temp crate's Cargo.toml.
+/// `full` enables every optional runtime capability (matches `tish build --feature full` / LANGUAGE.md).
+fn runtime_features_for_cargo(features: &[String]) -> Vec<String> {
+    let mut out = Vec::new();
+    for f in features {
+        if f == "full" {
+            for name in RUNTIME_CARGO_FEATURES {
+                if !out.iter().any(|x: &String| x == *name) {
+                    out.push((*name).to_string());
+                }
+            }
+            continue;
+        }
+        if RUNTIME_CARGO_FEATURES.contains(&f.as_str()) && !out.contains(f) {
+            out.push(f.clone());
+        }
+    }
+    out
+}
+
 pub fn build_via_cargo(
     rust_code: &str,
     native_modules: Vec<ResolvedNativeModule>,
@@ -19,15 +42,12 @@ pub fn build_via_cargo(
 
     let runtime_path = tishlang_build_utils::find_runtime_path()?;
 
-    let runtime_features: Vec<&str> = features
-        .iter()
-        .filter(|f| ["http", "fs", "process", "regex", "ws"].contains(&f.as_str()))
-        .map(String::as_str)
-        .collect();
-    let features_str = if runtime_features.is_empty() {
+    let runtime_features = runtime_features_for_cargo(features);
+    let runtime_refs: Vec<&str> = runtime_features.iter().map(String::as_str).collect();
+    let features_str = if runtime_refs.is_empty() {
         String::new()
     } else {
-        format!(", features = {:?}", runtime_features)
+        format!(", features = {:?}", runtime_refs)
     };
 
     let needs_tokio = rust_code.contains("#[tokio::main]");
@@ -114,3 +134,24 @@ tishlang_runtime = {{ path = {:?}{} }}{}{}{}
     Ok(())
 }
 
+#[cfg(test)]
+mod tests {
+    use super::runtime_features_for_cargo;
+
+    #[test]
+    fn runtime_features_full_expands() {
+        let f = runtime_features_for_cargo(&["full".to_string()]);
+        assert!(f.contains(&"http".to_string()));
+        assert!(f.contains(&"fs".to_string()));
+        assert!(f.contains(&"process".to_string()));
+        assert!(f.contains(&"regex".to_string()));
+        assert!(f.contains(&"ws".to_string()));
+    }
+
+    #[test]
+    fn runtime_features_merges_full_and_specific() {
+        let f = runtime_features_for_cargo(&["full".to_string(), "http".to_string()]);
+        assert_eq!(f.len(), 5);
+    }
+}
+

package/crates/tish_native/src/lib.rs

@@ -57,7 +57,7 @@ pub fn compile_to_native(
 
     match backend {
         Backend::Rust => {
-            let (rust_code, native_modules) = tishlang_compile::compile_project_full(
+            let (rust_code, native_modules, effective_features) = tishlang_compile::compile_project_full(
                 entry_path,
                 project_root,
                 features,
@@ -67,8 +67,13 @@ pub fn compile_to_native(
                 message: e.to_string(),
             })?;
 
-            crate::build::build_via_cargo(&rust_code, native_modules, output_path, features)
-                .map_err(|e| NativeError { message: e })
+            crate::build::build_via_cargo(
+                &rust_code,
+                native_modules,
+                output_path,
+                &effective_features,
+            )
+            .map_err(|e| NativeError { message: e })
         }
         Backend::Cranelift => {
             let modules = tishlang_compile::resolve_project(entry_path, project_root)

package/crates/tish_runtime/src/lib.rs

@@ -71,6 +71,7 @@ pub use tishlang_builtins::string::{
     repeat as string_repeat_impl,
     pad_start as string_pad_start_impl,
     pad_end as string_pad_end_impl,
+    last_index_of as string_last_index_of_impl,
 };
 
 // Wrapper functions to maintain API compatibility
@@ -119,6 +120,9 @@ pub fn string_char_code_at(s: &Value, idx: &Value) -> Value { string_char_code_a
 pub fn string_repeat(s: &Value, count: &Value) -> Value { string_repeat_impl(s, count) }
 pub fn string_pad_start(s: &Value, target_len: &Value, pad: &Value) -> Value { string_pad_start_impl(s, target_len, pad) }
 pub fn string_pad_end(s: &Value, target_len: &Value, pad: &Value) -> Value { string_pad_end_impl(s, target_len, pad) }
+pub fn string_last_index_of(s: &Value, search: &Value, position: &Value) -> Value {
+    string_last_index_of_impl(s, search, position)
+}
 
 /// Number.prototype.toFixed(digits) - format number with fixed decimal places (0-20)
 pub fn number_to_fixed(n: &Value, digits: &Value) -> Value {

package/crates/tish_vm/src/lib.rs

@@ -2,7 +2,7 @@
 
 mod vm;
 
-pub use vm::{run, Vm};
+pub use vm::{all_compiled_capabilities, run, run_with_options, Vm, VmRunOptions};
 
 #[cfg(test)]
 mod tests {

package/crates/tish_vm/src/vm.rs

@@ -1,6 +1,7 @@
 //! Stack-based bytecode VM.
 
 use std::cell::RefCell;
+use std::collections::HashSet;
 use std::rc::Rc;
 use std::sync::Arc;
 
@@ -15,15 +16,40 @@ use tishlang_core::{ObjectMap, Value};
 
 type ArrayMethodFn = Rc<dyn Fn(&[Value]) -> Value>;
 
+/// Feature names enabled for this VM run (`tish run --feature …`). `full` enables every optional capability.
+#[cfg_attr(
+    not(any(feature = "fs", feature = "http", feature = "process", feature = "ws")),
+    allow(dead_code)
+)]
+fn cap_allows(enabled: &HashSet<String>, name: &str) -> bool {
+    enabled.contains("full") || enabled.contains(name)
+}
+
+/// Capabilities linked into this `tishlang_vm` binary (compile-time). Used by [`Vm::new`] and `run()`.
+pub fn all_compiled_capabilities() -> HashSet<String> {
+    #[allow(unused_mut)]
+    let mut s = HashSet::new();
+    #[cfg(feature = "http")]
+    s.insert("http".to_string());
+    #[cfg(feature = "fs")]
+    s.insert("fs".to_string());
+    #[cfg(feature = "process")]
+    s.insert("process".to_string());
+    #[cfg(feature = "regex")]
+    s.insert("regex".to_string());
+    #[cfg(feature = "ws")]
+    s.insert("ws".to_string());
+    s
+}
+
 /// Look up built-in module export for LoadNativeExport. Returns None if unknown or feature disabled.
-/// Parameters are only used when the corresponding feature (fs, http, process) is enabled.
 #[cfg_attr(
     not(any(feature = "fs", feature = "http", feature = "process", feature = "ws")),
     allow(unused_variables)
 )]
-fn get_builtin_export(spec: &str, export_name: &str) -> Option<Value> {
+fn get_builtin_export(enabled: &HashSet<String>, spec: &str, export_name: &str) -> Option<Value> {
     #[cfg(feature = "fs")]
-    if spec == "tish:fs" {
+    if spec == "tish:fs" && cap_allows(enabled, "fs") {
         return match export_name {
             "readFile" => Some(Value::Function(Rc::new(|args: &[Value]| tishlang_runtime::read_file(args)))),
             "writeFile" => Some(Value::Function(Rc::new(|args: &[Value]| tishlang_runtime::write_file(args)))),
@@ -35,7 +61,7 @@ fn get_builtin_export(spec: &str, export_name: &str) -> Option<Value> {
         };
     }
     #[cfg(feature = "http")]
-    if spec == "tish:http" {
+    if spec == "tish:http" && cap_allows(enabled, "http") {
         return match export_name {
             // Bytecode compiler lowers `await expr` to `tish:http.await(promise)` (see tish_bytecode compiler).
             "await" => Some(Value::Function(Rc::new(|args: &[Value]| {
@@ -59,7 +85,7 @@ fn get_builtin_export(spec: &str, export_name: &str) -> Option<Value> {
         };
     }
     #[cfg(feature = "process")]
-    if spec == "tish:process" {
+    if spec == "tish:process" && cap_allows(enabled, "process") {
         return match export_name {
             "exit" => Some(Value::Function(Rc::new(|args: &[Value]| tishlang_runtime::process_exit(args)))),
             "cwd" => Some(Value::Function(Rc::new(|args: &[Value]| tishlang_runtime::process_cwd(args)))),
@@ -97,7 +123,7 @@ fn get_builtin_export(spec: &str, export_name: &str) -> Option<Value> {
         };
     }
     #[cfg(feature = "ws")]
-    if spec == "tish:ws" {
+    if spec == "tish:ws" && cap_allows(enabled, "ws") {
         return match export_name {
             "WebSocket" => Some(Value::Function(Rc::new(|args: &[Value]| {
                 tishlang_runtime::web_socket_client(args)
@@ -149,7 +175,8 @@ fn vm_log_err(s: &str) {
 }
 
 /// Initialize default globals (console, Math, JSON, etc.)
-fn init_globals() -> ObjectMap {
+#[allow(unused_variables)]
+fn init_globals(enabled: &HashSet<String>) -> ObjectMap {
     let mut g = ObjectMap::default();
 
     let mut console = ObjectMap::default();
@@ -381,7 +408,7 @@ fn init_globals() -> ObjectMap {
     g.insert("document".into(), Value::Object(Rc::new(RefCell::new(document_obj))));
 
     #[cfg(feature = "process")]
-    {
+    if cap_allows(enabled, "process") {
         let mut process_obj = ObjectMap::default();
         process_obj.insert(
             "exit".into(),
@@ -413,7 +440,7 @@ fn init_globals() -> ObjectMap {
     }
 
     #[cfg(feature = "http")]
-    {
+    if cap_allows(enabled, "http") {
         g.insert(
             "serve".into(),
             Value::Function(Rc::new(|args: &[Value]| {
@@ -433,21 +460,44 @@ fn init_globals() -> ObjectMap {
 /// Shared scope for closure capture (parent frame's locals).
 type ScopeMap = Rc<RefCell<ObjectMap>>;
 
+/// Options for the convenience [`run_with_options`] helper (one-shot VM run from the CLI).
+#[derive(Clone, Debug, Default)]
+pub struct VmRunOptions {
+    /// When true and not inside a nested chunk (`enclosing` is `None`), top-level [`Opcode::DeclareVar`]
+    /// also writes to globals so the REPL keeps bindings across input lines.
+    pub repl_mode: bool,
+    /// Enabled capabilities for this run (e.g. `fs`, `http`, `full`). Empty = none (secure default).
+    pub capabilities: HashSet<String>,
+}
+
 pub struct Vm {
     stack: Vec<Value>,
     scope: ObjectMap,
     /// Enclosing scope for closures (captured parent frame locals).
     enclosing: Option<ScopeMap>,
     globals: Rc<RefCell<ObjectMap>>,
+    /// Capabilities for `LoadNativeExport` and globals such as `process` / `serve`.
+    capabilities: Arc<HashSet<String>>,
 }
 
 impl Vm {
+    /// VM with every capability that exists in this `tishlang_vm` build (embedders, tests, `run()`).
     pub fn new() -> Self {
+        Self::with_capabilities_arc(Arc::new(all_compiled_capabilities()))
+    }
+
+    /// VM with an explicit capability set (e.g. from `tish run --feature …`).
+    pub fn with_capabilities(capabilities: HashSet<String>) -> Self {
+        Self::with_capabilities_arc(Arc::new(capabilities))
+    }
+
+    fn with_capabilities_arc(capabilities: Arc<HashSet<String>>) -> Self {
         Self {
             stack: Vec::new(),
             scope: ObjectMap::default(),
             enclosing: None,
-            globals: Rc::new(RefCell::new(init_globals())),
+            globals: Rc::new(RefCell::new(init_globals(capabilities.as_ref()))),
+            capabilities,
         }
     }
 
@@ -476,7 +526,12 @@ impl Vm {
     }
 
     pub fn run(&mut self, chunk: &Chunk) -> Result<Value, String> {
-        self.run_chunk(chunk, &chunk.nested, &[])
+        self.run_with_options(chunk, false)
+    }
+
+    /// Run a chunk using this VM's capability set. `repl_mode` persists top-level `let` across REPL lines.
+    pub fn run_with_options(&mut self, chunk: &Chunk, repl_mode: bool) -> Result<Value, String> {
+        self.run_chunk(chunk, &chunk.nested, &[], repl_mode)
     }
 
     fn run_chunk(
@@ -484,6 +539,7 @@ impl Vm {
         chunk: &Chunk,
         nested: &[Chunk],
         args: &[Value],
+        repl_mode: bool,
     ) -> Result<Value, String> {
         let code = &chunk.code;
         let constants = &chunk.constants;
@@ -517,6 +573,7 @@ impl Vm {
             }
         }
         let mut try_handlers: Vec<(usize, usize)> = vec![];
+        let mut block_undo_stack: Vec<Vec<(Arc<str>, Option<Value>)>> = vec![];
 
         loop {
             if ip >= code.len() {
@@ -548,14 +605,16 @@ impl Vm {
                             let inner_clone = inner.clone();
                             let globals = Rc::clone(&self.globals);
                             let enclosing = Some(Rc::clone(&local_scope));
+                            let capabilities = Arc::clone(&self.capabilities);
                             Value::Function(Rc::new(move |args: &[Value]| {
                                 let mut vm = Vm {
                                     stack: Vec::new(),
                                     scope: ObjectMap::default(),
                                     enclosing: enclosing.clone(),
                                     globals: Rc::clone(&globals),
+                                    capabilities: Arc::clone(&capabilities),
                                 };
-                                vm.run_chunk(&inner_clone, &inner_clone.nested, args)
+                                vm.run_chunk(&inner_clone, &inner_clone.nested, args, false)
                                     .unwrap_or(Value::Null)
                             }))
                         }
@@ -616,6 +675,62 @@ impl Vm {
                         }
                     }
                 }
+                Opcode::DeclareVar => {
+                    let idx = Self::read_u16(code, &mut ip);
+                    let name = names
+                        .get(idx as usize)
+                        .ok_or_else(|| format!("Name index out of bounds: {}", idx))?;
+                    let v = self
+                        .stack
+                        .pop()
+                        .ok_or_else(|| "Stack underflow".to_string())?;
+                    if let Some(frame) = block_undo_stack.last_mut() {
+                        let old = local_scope.borrow().get(name.as_ref()).cloned();
+                        frame.push((Arc::clone(name), old));
+                    }
+                    // REPL: persist top-level bindings only (not block-locals shadowing globals).
+                    if repl_mode && self.enclosing.is_none() && block_undo_stack.is_empty() {
+                        self.globals
+                            .borrow_mut()
+                            .insert(Arc::clone(name), v.clone());
+                    }
+                    local_scope.borrow_mut().insert(Arc::clone(name), v);
+                }
+                Opcode::DeclareVarPlain => {
+                    let idx = Self::read_u16(code, &mut ip);
+                    let name = names
+                        .get(idx as usize)
+                        .ok_or_else(|| format!("Name index out of bounds: {}", idx))?;
+                    let v = self
+                        .stack
+                        .pop()
+                        .ok_or_else(|| "Stack underflow".to_string())?;
+                    if repl_mode && self.enclosing.is_none() && block_undo_stack.is_empty() {
+                        self.globals
+                            .borrow_mut()
+                            .insert(Arc::clone(name), v.clone());
+                    }
+                    local_scope.borrow_mut().insert(Arc::clone(name), v);
+                }
+                Opcode::EnterBlock => {
+                    block_undo_stack.push(Vec::new());
+                }
+                Opcode::ExitBlock => {
+                    let frame = block_undo_stack.pop().ok_or_else(|| {
+                        "ExitBlock without matching EnterBlock".to_string()
+                    })?;
+                    for (name, old) in frame.into_iter().rev() {
+                        let mut ls = local_scope.borrow_mut();
+                        match old {
+                            Some(prev) => {
+                                ls.insert(name, prev);
+                            }
+                            None => {
+                                ls.remove(name.as_ref());
+                            }
+                        }
+                    }
+                }
                 Opcode::LoadGlobal => {
                     let idx = Self::read_u16(code, &mut ip);
                     let name = names
@@ -1144,9 +1259,9 @@ impl Vm {
                             return Err("LoadNativeExport: export_name constant out of bounds or not string".to_string());
                         }
                     };
-                    let v = get_builtin_export(spec, export_name).ok_or_else(|| {
+                    let v = get_builtin_export(self.capabilities.as_ref(), spec, export_name).ok_or_else(|| {
                         format!(
-                            "Built-in module '{}' does not export '{}' or feature not enabled. Rebuild with --features full (or fs, http, process, ws).",
+                            "Built-in module '{}' does not export '{}' or capability not enabled for this run. Use e.g. tish run --feature fs (or full). The tish binary must also be built with that capability linked in.",
                             spec, export_name
                         )
                     })?;
@@ -1379,6 +1494,12 @@ fn get_member(obj: &Value, key: &Arc<str>) -> Result<Value, String> {
         }
         Value::String(s) => {
             let key_s = key.as_ref();
+            if let Ok(idx) = key_s.parse::<usize>() {
+                return match s.chars().nth(idx) {
+                    Some(c) => Ok(Value::String(Arc::from(c.to_string()))),
+                    None => Err("Index out of bounds".to_string()),
+                };
+            }
             if key_s == "length" {
                 return Ok(Value::Number(s.chars().count() as f64));
             }
@@ -1389,6 +1510,18 @@ fn get_member(obj: &Value, key: &Arc<str>) -> Result<Value, String> {
                     let from = args.get(1);
                     str_builtins::index_of(&Value::String(Arc::clone(&s_clone)), search, from)
                 }),
+                "lastIndexOf" => Rc::new(move |args: &[Value]| {
+                    let search = args.first().unwrap_or(&Value::Null);
+                    let position = args
+                        .get(1)
+                        .cloned()
+                        .unwrap_or(Value::Number(f64::INFINITY));
+                    str_builtins::last_index_of(
+                        &Value::String(Arc::clone(&s_clone)),
+                        search,
+                        &position,
+                    )
+                }),
                 "includes" => Rc::new(move |args: &[Value]| {
                     let search = args.first().unwrap_or(&Value::Null);
                     let from = args.get(1);
@@ -1490,8 +1623,14 @@ fn set_index(obj: &Value, idx: &Value, val: Value) -> Result<(), String> {
     set_member(obj, &key, val)
 }
 
-/// Run a chunk and return the result.
+/// Run a chunk with every capability linked into this `tishlang_vm` build (tests, embedders).
 pub fn run(chunk: &Chunk) -> Result<Value, String> {
     let mut vm = Vm::new();
-    vm.run(chunk)
+    vm.run_with_options(chunk, false)
+}
+
+/// Run a chunk with options (e.g. REPL persistence for top-level declarations).
+pub fn run_with_options(chunk: &Chunk, opts: VmRunOptions) -> Result<Value, String> {
+    let mut vm = Vm::with_capabilities(opts.capabilities);
+    vm.run_with_options(chunk, opts.repl_mode)
 }

package/crates/tish_vm/tests/lexical_scope_declare.rs

@@ -0,0 +1,34 @@
+//! `DeclareVar` + block scopes: function `let` shadows script-level names (bytecode VM).
+
+use tishlang_bytecode::compile;
+use tishlang_vm::run;
+
+#[test]
+fn declare_var_shadows_script_let_inside_fn() {
+    let src = r#"
+let x = 1
+fn f() {
+  let x = 2
+  return x
+}
+let r = f()
+console.log("script", x, "fn", r)
+"#;
+    let program = tishlang_parser::parse(src).expect("parse");
+    let chunk = compile(&program).expect("compile");
+    run(&chunk).expect("run");
+}
+
+#[test]
+fn block_let_restores_outer_binding() {
+    let src = r#"
+let x = 1
+{
+  let x = 2
+}
+console.log(x)
+"#;
+    let program = tishlang_parser::parse(src).expect("parse");
+    let chunk = compile(&program).expect("compile");
+    run(&chunk).expect("run");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "Tish - minimal TS/JS-compatible language. Run, REPL, build to native or other targets.",
   "license": "PIF",
   "repository": {