@tishlang/tish 1.10.0 → 1.12.0

package/crates/tish_core/src/value.rs

@@ -70,6 +70,14 @@ pub type NativeFn = std::rc::Rc<dyn Fn(&[Value]) -> Value>;
 
 /// Trait for opaque Rust types exposed to Tish (e.g. Polars DataFrame).
 /// Implementors provide method dispatch so Tish can call methods on the value.
+///
+/// The `Send + Sync` supertrait bound is conditional on the `send-values`
+/// feature. When `send-values` is off (single-threaded VMs: wasm browser /
+/// wasi / interpreter / cranelift), `NativeFn` is already `Rc<dyn Fn>`, so
+/// `Value` is `!Send` anyway — dropping the bound here loses nothing and lets
+/// `!Send` opaques like `JsHandle(wasm_bindgen::JsValue)` be stored in a
+/// `Value::Opaque` on the browser runtime.
+#[cfg(feature = "send-values")]
 pub trait TishOpaque: Send + Sync {
     /// Display name for the type (e.g. "DataFrame").
     fn type_name(&self) -> &'static str;
@@ -81,6 +89,19 @@ pub trait TishOpaque: Send + Sync {
     fn as_any(&self) -> &dyn std::any::Any;
 }
 
+/// Single-threaded variant (no `Send + Sync` bound); see the `send-values` doc above.
+#[cfg(not(feature = "send-values"))]
+pub trait TishOpaque {
+    /// Display name for the type (e.g. "DataFrame").
+    fn type_name(&self) -> &'static str;
+
+    /// Get a method by name. Returns a native function if the method exists.
+    fn get_method(&self, name: &str) -> Option<NativeFn>;
+
+    /// For downcasting `Arc<dyn TishOpaque>` in native crates (e.g. Polars → `DataFrame`).
+    fn as_any(&self) -> &dyn std::any::Any;
+}
+
 /// Trait for Promise-like values that can be awaited (block until settled).
 /// Implemented by the runtime for native compile; interpreter uses its own Promise.
 pub trait TishPromise: Send + Sync {

package/crates/tish_cranelift/src/link.rs

@@ -103,7 +103,7 @@ fn main() {{
         message: format!("Cannot write build.rs: {}", e),
     })?;
 
-    tishlang_build_utils::run_cargo_build(&build_dir, None)
+    tishlang_build_utils::run_cargo_build(&build_dir, None, None)
         .map_err(|e| CraneliftError { message: e })?;
 
     let binary_dir = build_dir.join("target").join("release");

package/crates/tish_native/src/build.rs

@@ -5,6 +5,8 @@ use std::path::Path;
 
 use tishlang_compile::ResolvedNativeModule;
 
+use crate::config::{NativeArtifact, NativeBuildConfig};
+
 /// `tishlang_runtime` Cargo feature names (subset of CLI / compile feature names).
 const RUNTIME_CARGO_FEATURES: &[&str] = &[
     "http",
@@ -69,6 +71,10 @@ fn inject_generated_native_mod(rust_code: &str) -> String {
     }
 }
 
+pub(crate) fn rust_code_needs_tokio(rust_code: &str) -> bool {
+    rust_code.contains("#[tokio::main]") || rust_code.contains("tokio::runtime::Runtime")
+}
+
 pub fn build_via_cargo(
     rust_code: &str,
     native_modules: Vec<ResolvedNativeModule>,
@@ -78,11 +84,34 @@ pub fn build_via_cargo(
     generated_native_rs: Option<&str>,
     project_root: Option<&Path>,
 ) -> Result<(), String> {
-    let out_name = output_path
+    build_via_cargo_with_config(
+        rust_code,
+        native_modules,
+        output_path,
+        features,
+        extra_dependencies_toml,
+        generated_native_rs,
+        project_root,
+        &NativeBuildConfig::desktop(),
+    )
+}
+
+pub fn build_via_cargo_with_config(
+    rust_code: &str,
+    native_modules: Vec<ResolvedNativeModule>,
+    output_path: &Path,
+    features: &[String],
+    extra_dependencies_toml: &str,
+    generated_native_rs: Option<&str>,
+    project_root: Option<&Path>,
+    build_config: &NativeBuildConfig,
+) -> Result<(), String> {
+    let out_stem = output_path
         .file_stem()
         .and_then(|s| s.to_str())
         .unwrap_or("tish_out");
-    let build_dir = tishlang_build_utils::create_build_dir("tish_build", out_name)?;
+    let cargo_name = tishlang_build_utils::cargo_target_name(out_stem);
+    let build_dir = tishlang_build_utils::create_build_dir("tish_build", out_stem)?;
 
     let runtime_path = tishlang_build_utils::find_runtime_path_for_project(project_root)?;
 
@@ -94,7 +123,7 @@ pub fn build_via_cargo(
         format!(", features = {:?}", runtime_refs)
     };
 
-    let needs_tokio = rust_code.contains("#[tokio::main]");
+    let needs_tokio = rust_code_needs_tokio(rust_code);
     let tokio_dep = if needs_tokio {
         "\ntokio = { version = \"1\", features = [\"rt-multi-thread\", \"macros\"] }\n"
     } else {
@@ -139,22 +168,42 @@ pub fn build_via_cargo(
     };
 
     let profile = nested_release_profile_toml();
+    let src_file = if build_config.artifact == NativeArtifact::StaticLib {
+        "lib.rs"
+    } else {
+        "main.rs"
+    };
+    let crate_section = if build_config.artifact == NativeArtifact::StaticLib {
+        format!(
+            r#"[lib]
+name = "{}"
+crate-type = ["staticlib"]
+path = "src/lib.rs"
+
+"#,
+            cargo_name
+        )
+    } else {
+        format!(
+            r#"[[bin]]
+name = "{}"
+path = "src/main.rs"
+
+"#,
+            cargo_name
+        )
+    };
     let cargo_toml = format!(
         r#"[package]
 name = "tish_output"
 version = "0.1.0"
 edition = "2021"
 
-[[bin]]
-name = "{}"
-path = "src/main.rs"
-
-{}
-
+{}{}
 [dependencies]
 tishlang_runtime = {{ path = {:?}{} }}
 {}{}"#,
-        out_name, profile, runtime_path, features_str, more_deps, ui_dep
+        crate_section, profile, runtime_path, features_str, more_deps, ui_dep
     );
 
     fs::write(build_dir.join("Cargo.toml"), cargo_toml)
@@ -163,24 +212,44 @@ tishlang_runtime = {{ path = {:?}{} }}
         fs::write(build_dir.join("src/generated_native.rs"), gen)
             .map_err(|e| format!("Cannot write generated_native.rs: {}", e))?;
     }
-    fs::write(build_dir.join("src/main.rs"), rust_main)
-        .map_err(|e| format!("Cannot write main.rs: {}", e))?;
+    fs::write(build_dir.join("src").join(src_file), rust_main)
+        .map_err(|e| format!("Cannot write {}: {}", src_file, e))?;
 
     let workspace_target = Path::new(&runtime_path)
         .parent()
         .and_then(|p| p.parent())
         .map(|ws| ws.join("target"));
     let target_dir = workspace_target.filter(|p| p.exists());
+    let cross = build_config.cargo_target.as_deref();
+    let release_sub = if let Some(triple) = cross {
+        format!("{triple}/release")
+    } else {
+        "release".to_string()
+    };
     let binary_dir = target_dir
         .as_ref()
-        .map(|t| t.join("release"))
-        .unwrap_or_else(|| build_dir.join("target").join("release"));
+        .map(|t| t.join(&release_sub))
+        .unwrap_or_else(|| build_dir.join("target").join(&release_sub));
 
-    tishlang_build_utils::run_cargo_build(&build_dir, target_dir.as_deref())?;
+    tishlang_build_utils::run_cargo_build(&build_dir, target_dir.as_deref(), cross)?;
 
-    let binary = tishlang_build_utils::find_release_binary(&binary_dir, out_name)?;
-    let target = tishlang_build_utils::resolve_output_path(output_path, out_name);
-    tishlang_build_utils::copy_binary_to_output(&binary, &target)?;
+    let artifact = if build_config.artifact == NativeArtifact::StaticLib {
+        tishlang_build_utils::find_release_staticlib(&binary_dir, &cargo_name)?
+    } else {
+        tishlang_build_utils::find_release_binary(&binary_dir, &cargo_name)?
+    };
+    let target = if build_config.artifact == NativeArtifact::StaticLib {
+        if output_path.extension().is_some_and(|e| e == "a") {
+            output_path.to_path_buf()
+        } else if output_path.to_string_lossy().ends_with('/') || output_path.is_dir() {
+            output_path.join(format!("lib{out_stem}.a"))
+        } else {
+            output_path.with_extension("a")
+        }
+    } else {
+        tishlang_build_utils::resolve_output_path(output_path, out_stem)
+    };
+    tishlang_build_utils::copy_binary_to_output(&artifact, &target)?;
 
     Ok(())
 }
@@ -321,7 +390,7 @@ tishlang_runtime = {{ path = {:?}{} }}
         .map(|t| t.join("release"))
         .unwrap_or_else(|| build_dir.join("target").join("release"));
 
-    tishlang_build_utils::run_cargo_build(&build_dir, target_dir.as_deref())?;
+    tishlang_build_utils::run_cargo_build(&build_dir, target_dir.as_deref(), None)?;
 
     for i in 0..bins.len() {
         let stem = bins[i].0.as_str();

package/crates/tish_native/src/config.rs

@@ -0,0 +1,48 @@
+//! Native build configuration (desktop binary vs iOS staticlib, cross-target).
+
+use tishlang_compile::NativeEmitMode;
+
+/// Output artifact kind for `tish build --target native`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum NativeArtifact {
+    #[default]
+    Bin,
+    StaticLib,
+}
+
+/// Options passed from the CLI into nested `cargo build`.
+#[derive(Debug, Clone, Default)]
+pub struct NativeBuildConfig {
+    pub artifact: NativeArtifact,
+    /// When set, run `cargo build --target <triple>` and skip `-C target-cpu=native`.
+    pub cargo_target: Option<String>,
+    pub emit_mode: NativeEmitMode,
+}
+
+impl NativeBuildConfig {
+    pub fn desktop() -> Self {
+        Self::default()
+    }
+
+    pub fn ios_staticlib(triple: &str) -> Self {
+        Self {
+            artifact: NativeArtifact::StaticLib,
+            cargo_target: Some(triple.to_string()),
+            emit_mode: NativeEmitMode::EmbeddedLib,
+        }
+    }
+
+    pub fn is_cross_compile(&self) -> bool {
+        self.cargo_target.is_some()
+    }
+}
+
+/// Filter runtime features for iOS sandbox builds.
+pub fn ios_runtime_features(features: &[String]) -> Vec<String> {
+    const ALLOW: &[&str] = &["http", "http-hyper", "regex", "timers"];
+    features
+        .iter()
+        .filter(|f| ALLOW.contains(&f.as_str()))
+        .cloned()
+        .collect()
+}

package/crates/tish_native/src/lib.rs

@@ -10,6 +10,9 @@
 //! emit Rust using `Vec<f64>` / fixed primitives instead of `Value` on hot paths.
 
 mod build;
+mod config;
+
+pub use config::{ios_runtime_features, NativeArtifact, NativeBuildConfig};
 
 use std::path::Path;
 use tishlang_ast::Program;
@@ -56,6 +59,27 @@ pub fn compile_to_native(
     features: &[String],
     native_backend: &str,
     optimize: bool,
+) -> Result<(), NativeError> {
+    compile_to_native_with_config(
+        entry_path,
+        project_root,
+        output_path,
+        features,
+        native_backend,
+        optimize,
+        &NativeBuildConfig::desktop(),
+    )
+}
+
+/// Compile a Tish project to a native binary or static library.
+pub fn compile_to_native_with_config(
+    entry_path: &Path,
+    project_root: Option<&Path>,
+    output_path: &Path,
+    features: &[String],
+    native_backend: &str,
+    optimize: bool,
+    build_config: &NativeBuildConfig,
 ) -> Result<(), NativeError> {
     let backend = match native_backend {
         "rust" => Backend::Rust,
@@ -73,25 +97,44 @@ pub fn compile_to_native(
 
     match backend {
         Backend::Rust => {
+            let ios_cap = build_config.cargo_target.as_ref().map(|_| {
+                ios_runtime_features(features)
+                    .into_iter()
+                    .collect::<std::collections::HashSet<_>>()
+            });
+            let compile_features = if ios_cap.is_some() {
+                ios_runtime_features(features)
+            } else {
+                features.to_vec()
+            };
             let (rust_code, native_modules, effective_features, native_build) =
-                tishlang_compile::compile_project_full(
+                tishlang_compile::compile_project_full_emit(
                     entry_path,
                     project_root,
-                    features,
+                    &compile_features,
                     optimize,
+                    build_config.emit_mode,
+                    ios_cap.as_ref(),
                 )
                 .map_err(|e| NativeError {
                     message: e.to_string(),
                 })?;
 
-            crate::build::build_via_cargo(
+            let features_for_cargo = if build_config.cargo_target.is_some() {
+                ios_runtime_features(&effective_features)
+            } else {
+                effective_features
+            };
+
+            crate::build::build_via_cargo_with_config(
                 &rust_code,
                 native_modules,
                 output_path,
-                &effective_features,
+                &features_for_cargo,
                 &native_build.rust_dependencies_toml,
                 native_build.generated_native_rs.as_deref(),
                 project_root,
+                build_config,
             )
             .map_err(|e| NativeError { message: e })
         }
@@ -347,7 +390,7 @@ pub fn compile_many_to_native(
             merged_extra_deps.push_str(extra);
             merged_extra_deps.push('\n');
         }
-        needs_tokio |= rust_code.contains("#[tokio::main]");
+        needs_tokio |= crate::build::rust_code_needs_tokio(&rust_code);
         needs_ui |= rust_code.contains("tishlang_ui");
         bins.push((stem, rust_code, native_build.generated_native_rs));
     }

package/crates/tish_runtime/src/lib.rs

@@ -47,7 +47,8 @@ pub use tishlang_builtins::string::{
     pad_start as string_pad_start_impl, repeat as string_repeat_impl,
     replace as string_replace_impl, replace_all as string_replace_all_impl,
     slice as string_slice_impl, split as string_split_impl,
-    starts_with as string_starts_with_impl, substring as string_substring_impl,
+    starts_with as string_starts_with_impl, substr as string_substr_impl,
+    substring as string_substring_impl,
     to_lower_case as string_to_lower_case, to_upper_case as string_to_upper_case,
     trim as string_trim,
 };
@@ -105,6 +106,9 @@ pub fn string_slice(s: &Value, start: &Value, end: &Value) -> Value {
 pub fn string_substring(s: &Value, start: &Value, end: &Value) -> Value {
     string_substring_impl(s, start, end)
 }
+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 {
     string_split_impl(s, sep)
 }
@@ -420,6 +424,7 @@ pub use tishlang_builtins::math::{
     exp as tish_math_exp_impl, floor as tish_math_floor_impl, max as tish_math_max_impl,
     min as tish_math_min_impl, pow as tish_math_pow_impl, random as tish_math_random_impl,
     round as tish_math_round_impl, sign as tish_math_sign_impl, sin as tish_math_sin_impl,
+    imul as tish_math_imul_impl,
     sqrt as tish_math_sqrt_impl, tan as tish_math_tan_impl, trunc as tish_math_trunc_impl,
 };
 
@@ -460,6 +465,9 @@ pub fn math_exp(args: &[Value]) -> Value {
 pub fn math_trunc(args: &[Value]) -> Value {
     tish_math_trunc_impl(args)
 }
+pub fn math_imul(args: &[Value]) -> Value {
+    tish_math_imul_impl(args)
+}
 pub fn math_pow(args: &[Value]) -> Value {
     tish_math_pow_impl(args)
 }

package/crates/tish_runtime/src/timers.rs

@@ -47,15 +47,20 @@ pub fn drain_timers() {
     run_due_timers();
 }
 
-/// Run all due timer callbacks.
+/// Run all due timer callbacks (including timers scheduled by other timers).
 fn run_due_timers() {
-    let due = take_due_timers();
-    for (id, callback, args, interval_ms) in due {
-        if let Value::Function(f) = &callback {
-            let _ = f(&args);
+    for _ in 0..64 {
+        let due = take_due_timers();
+        if due.is_empty() {
+            break;
         }
-        if interval_ms > 0 {
-            re_register_interval(id, callback, args, interval_ms);
+        for (id, callback, args, interval_ms) in due {
+            if let Value::Function(f) = &callback {
+                let _ = f(&args);
+            }
+            if interval_ms > 0 {
+                re_register_interval(id, callback, args, interval_ms);
+            }
         }
     }
 }

package/crates/tish_ui/src/lib.rs

@@ -12,8 +12,9 @@ pub mod runtime;
 #[cfg(feature = "runtime")]
 pub use runtime::{
     alloc_root_id, current_root_id, drop_host_for_root, fragment_value, install_host_for_root,
-    install_thread_local_host, native_create_root, native_use_effect, native_use_memo,
-    native_use_state, run_with_current_root, ui_h, ui_text, unregister_root,
-    unregister_root_hooks_and_effects, with_host_for_root, with_thread_local_host, HeadlessHost,
-    Host, RootId, FRAGMENT_SENTINEL, LEGACY_ROOT_ID,
+    install_thread_local_host, native_create_root,
+    native_use_effect, native_use_layout_effect, native_use_memo, native_use_ref,
+    native_use_state, run_with_current_root, ui_h, ui_text,
+    unregister_root, unregister_root_hooks_and_effects, with_host_for_root,
+    with_thread_local_host, HeadlessHost, Host, RootId, FRAGMENT_SENTINEL, LEGACY_ROOT_ID,
 };