@tishlang/tish 1.0.29 → 1.0.33

package/crates/tish_runtime/src/http_fetch.rs

@@ -1,7 +1,6 @@
 //! Web Fetch–aligned Response, ReadableStream, reader.read(), text()/json().
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::pin::Pin;
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};
@@ -9,7 +8,7 @@ use std::sync::{Arc, Mutex};
 use bytes::Bytes;
 use futures::Stream;
 use futures::StreamExt;
-use tishlang_core::{NativeFn, TishOpaque, TishPromise, Value};
+use tishlang_core::{NativeFn, ObjectMap, TishOpaque, TishPromise, Value};
 
 use crate::http::{build_error_response, extract_body, extract_headers, extract_method};
 
@@ -77,14 +76,14 @@ impl TishPromise for ReadChunkPromise {
             let r = crate::http::block_on_http(rx);
             match r {
                 Ok(Ok(ReadChunk::Done)) => {
-                    let mut o = HashMap::new();
+                    let mut o = ObjectMap::default();
                     o.insert(Arc::from("done"), Value::Bool(true));
                     o.insert(Arc::from("value"), Value::Null);
                     Ok(Value::Object(Rc::new(RefCell::new(o))))
                 }
                 Ok(Ok(ReadChunk::Bytes(b))) => {
                     let arr: Vec<Value> = b.iter().map(|u| Value::Number(*u as f64)).collect();
-                    let mut o = HashMap::new();
+                    let mut o = ObjectMap::default();
                     o.insert(Arc::from("done"), Value::Bool(false));
                     o.insert(
                         Arc::from("value"),
@@ -93,7 +92,7 @@ impl TishPromise for ReadChunkPromise {
                     Ok(Value::Object(Rc::new(RefCell::new(o))))
                 }
                 Ok(Err(e)) => Err({
-                    let mut obj = HashMap::new();
+                    let mut obj = ObjectMap::default();
                     obj.insert(Arc::from("error"), Value::String(e.into()));
                     Value::Object(Rc::new(RefCell::new(obj)))
                 }),
@@ -118,13 +117,13 @@ impl TishPromise for JsonTextPromise {
                 Ok(Ok(s)) => match tishlang_core::json_parse(&s) {
                     Ok(v) => Ok(v),
                     Err(e) => Err({
-                        let mut obj = HashMap::new();
+                        let mut obj = ObjectMap::default();
                         obj.insert(Arc::from("error"), Value::String(e.into()));
                         Value::Object(Rc::new(RefCell::new(obj)))
                     }),
                 },
                 Ok(Err(e)) => Err({
-                    let mut obj = HashMap::new();
+                    let mut obj = ObjectMap::default();
                     obj.insert(Arc::from("error"), Value::String(e.into()));
                     Value::Object(Rc::new(RefCell::new(obj)))
                 }),
@@ -226,7 +225,7 @@ impl TishOpaque for HttpReadableStream {
                 }))
             }
             Err(e) => {
-                let mut m = HashMap::new();
+                let mut m = ObjectMap::default();
                 m.insert(Arc::from("error"), Value::String(e.into()));
                 Value::Object(Rc::new(RefCell::new(m)))
             }
@@ -283,7 +282,7 @@ impl TishOpaque for HttpStreamReader {
 }
 
 fn headers_to_value(headers: &reqwest::header::HeaderMap) -> Value {
-    let mut headers_obj: HashMap<Arc<str>, Value> = HashMap::with_capacity(headers.len());
+    let mut headers_obj: ObjectMap = ObjectMap::with_capacity(headers.len());
     for (key, value) in headers.iter() {
         if let Ok(v) = value.to_str() {
             headers_obj.insert(Arc::from(key.as_str()), Value::String(v.into()));
@@ -327,7 +326,7 @@ pub fn response_value_from_reqwest(response: reqwest::Response) -> Value {
             rx: Mutex::new(Some(rx)),
         }))
     });
-    let mut obj: HashMap<Arc<str>, Value> = HashMap::new();
+    let mut obj: ObjectMap = ObjectMap::default();
     obj.insert(Arc::from("status"), Value::Number(status));
     obj.insert(Arc::from("ok"), Value::Bool(ok));
     obj.insert(Arc::from("headers"), headers_val);

package/crates/tish_runtime/src/lib.rs

@@ -13,8 +13,15 @@ use tishlang_builtins::helpers::extract_num;
 #[cfg(feature = "fs")]
 use tishlang_builtins::helpers::make_error_value;
 
+pub use tishlang_core::ObjectMap;
 pub use tishlang_core::Value;
 
+pub use tishlang_builtins::construct::{
+    audio_context_constructor_value as tish_audio_context_constructor,
+    construct as tish_construct,
+    uint8_array_constructor_value as tish_uint8_array_constructor,
+};
+
 // Re-export array methods from tishlang_builtins
 pub use tishlang_builtins::array::{
     push as array_push_impl,
@@ -754,7 +761,7 @@ pub fn regexp_exec(re: &Value, input: &Value) -> Value {
 
 #[cfg(feature = "regex")]
 fn regexp_exec_impl(re: &mut tishlang_core::TishRegExp, input: &str) -> Value {
-    use std::collections::HashMap;
+    use tishlang_core::ObjectMap;
 
     let start = if re.flags.global || re.flags.sticky {
         re.last_index
@@ -785,7 +792,7 @@ fn regexp_exec_impl(re: &mut tishlang_core::TishRegExp, input: &str) -> Value {
             let match_byte_start = byte_start + full_match.start();
             let match_char_index = input[..match_byte_start].chars().count();
 
-            let mut obj: HashMap<std::sync::Arc<str>, Value> = HashMap::new();
+            let mut obj: ObjectMap = ObjectMap::default();
             obj.insert(Arc::from("0"), Value::String(full_match.as_str().into()));
             for i in 1..caps.len() {
                 let val = match caps.get(i) {

package/crates/tish_runtime/src/promise.rs

@@ -1,10 +1,9 @@
 //! Promise static methods for compiled Tish (resolve, reject, all, race).
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
-use tishlang_core::Value;
+use tishlang_core::{ObjectMap, Value};
 
 /// Promise.resolve(value) - returns the value (immediate resolve).
 pub fn promise_resolve(args: &[Value]) -> Value {
@@ -56,7 +55,7 @@ pub fn promise_race(args: &[Value]) -> Value {
 
 /// Build the Promise object with resolve, reject, all, race static methods.
 pub fn promise_object() -> Value {
-    let mut map: HashMap<Arc<str>, Value> = HashMap::new();
+    let mut map: ObjectMap = ObjectMap::default();
     map.insert(
         Arc::from("resolve"),
         Value::Function(Rc::new(|args: &[Value]| promise_resolve(args))),

package/crates/tish_runtime/src/promise_io.rs

@@ -1,14 +1,13 @@
 //! Promises carrying only Send payloads (string results for text(), etc.).
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};
-use tishlang_core::{Value, TishPromise};
+use tishlang_core::{ObjectMap, TishPromise, Value};
 use tokio::sync::oneshot;
 
 fn error_value(msg: String) -> Value {
-    let mut obj: HashMap<Arc<str>, Value> = HashMap::with_capacity(2);
+    let mut obj: ObjectMap = ObjectMap::with_capacity(2);
     obj.insert(Arc::from("error"), Value::String(msg.into()));
     obj.insert(Arc::from("ok"), Value::Bool(false));
     Value::Object(Rc::new(RefCell::new(obj)))

package/crates/tish_runtime/src/ws.rs

@@ -15,7 +15,7 @@ use std::time::{Duration, Instant};
 
 use futures_util::{SinkExt, StreamExt};
 use lazy_static::lazy_static;
-use tishlang_core::Value;
+use tishlang_core::{ObjectMap, Value};
 use tokio::sync::mpsc as tokio_mpsc;
 use tokio::runtime::Runtime;
 
@@ -194,7 +194,7 @@ pub fn ws_broadcast_native(args: &[Value]) -> Value {
 
 /// Build connection object: { _id, send, close, readyState, receive }. JS-like.
 fn conn_object(id: u32) -> Value {
-    let mut obj: HashMap<Arc<str>, Value> = HashMap::new();
+    let mut obj: ObjectMap = ObjectMap::default();
     obj.insert(Arc::from("_id"), Value::Number(id as f64));
     obj.insert(Arc::from("readyState"), Value::Number(1.0)); // OPEN
     obj.insert(
@@ -216,7 +216,7 @@ fn conn_object(id: u32) -> Value {
         Value::Function(Rc::new(move |_args: &[Value]| {
             match conn_receive(id) {
                 Some(s) => {
-                    let mut ev: HashMap<Arc<str>, Value> = HashMap::new();
+                    let mut ev: ObjectMap = ObjectMap::default();
                     ev.insert(Arc::from("data"), Value::String(s.into()));
                     Value::Object(Rc::new(RefCell::new(ev)))
                 }
@@ -237,7 +237,7 @@ fn conn_object(id: u32) -> Value {
                 .unwrap_or(1000);
             match conn_receive_timeout(id_timeout, timeout_ms) {
                 Some(s) => {
-                    let mut ev: HashMap<Arc<str>, Value> = HashMap::new();
+                    let mut ev: ObjectMap = ObjectMap::default();
                     ev.insert(Arc::from("data"), Value::String(s.into()));
                     Value::Object(Rc::new(RefCell::new(ev)))
                 }
@@ -529,7 +529,7 @@ pub fn web_socket_server_construct(args: &[Value]) -> Value {
         ws
     });
 
-    let mut m: HashMap<Arc<str>, Value> = HashMap::new();
+    let mut m: ObjectMap = ObjectMap::default();
     m.insert(Arc::from("_handle"), handle_val);
     m.insert(Arc::from("_onConnection"), Value::Null);
     m.insert(Arc::from("clients"), Value::Array(clients));
@@ -549,7 +549,7 @@ mod tests {
     fn ws_echo_roundtrip() {
         let port: u16 = 18_742;
         let opts = {
-            let mut m: HashMap<Arc<str>, Value> = HashMap::new();
+            let mut m: ObjectMap = ObjectMap::default();
             m.insert(Arc::from("port"), Value::Number(port as f64));
             Value::Object(Rc::new(RefCell::new(m)))
         };
@@ -632,7 +632,7 @@ mod tests {
     fn ws_gateway_agent_flow() {
         let port: u16 = 18_743;
         let opts = {
-            let mut m: HashMap<Arc<str>, Value> = HashMap::new();
+            let mut m: ObjectMap = ObjectMap::default();
             m.insert(Arc::from("port"), Value::Number(port as f64));
             Value::Object(Rc::new(RefCell::new(m)))
         };

package/crates/tish_ui/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "tishlang_ui"
+version = "0.1.0"
+edition = "2021"
+description = "Shared JSX lowering and UI runtime (vnode, hooks, host protocol) for Tish"
+
+license-file = { workspace = true }
+repository = { workspace = true }
+
+[features]
+default = ["runtime"]
+compiler = ["dep:tishlang_ast"]
+runtime = ["dep:tishlang_core"]
+
+[dependencies]
+tishlang_ast = { path = "../tish_ast", version = ">=0.1", optional = true }
+tishlang_core = { path = "../tish_core", version = ">=0.1", optional = true }

package/crates/tish_ui/src/jsx.rs

@@ -0,0 +1,390 @@
+//! Shared JSX lowering: emit `h(tag, props, children)` as JavaScript or Rust (`Value`) source.
+
+use tishlang_ast::{
+    ArrayElement, Expr, JsxAttrValue, JsxChild, JsxProp, Literal, ObjectProp,
+};
+
+/// Escape a Tish identifier for Rust output (matches `tishlang_compile` conventions).
+pub fn escape_ident_rust(s: &str) -> String {
+    if s == "await" || s == "default" {
+        format!("_{}", s)
+    } else {
+        s.to_string()
+    }
+}
+
+/// Emit JSX expression as JavaScript (same rules as legacy `tishlang_compile_js`).
+pub fn emit_jsx_js<F, E>(expr: &Expr, emit_expr: &mut F) -> Result<String, E>
+where
+    F: FnMut(&Expr) -> Result<String, E>,
+    E: From<String>,
+{
+    match expr {
+        Expr::JsxElement {
+            tag,
+            props,
+            children,
+            ..
+        } => {
+            let tag_str = if tag.chars().next().map(|c| c.is_uppercase()).unwrap_or(false) {
+                tag.as_ref().to_string()
+            } else {
+                format!("{:?}", tag.as_ref())
+            };
+            let props_str = emit_jsx_props_js(props, emit_expr)?;
+            let children_strs: Result<Vec<_>, _> =
+                children.iter().map(|c| emit_jsx_child_js(c, emit_expr)).collect();
+            let children_str = children_strs?.join(", ");
+            Ok(format!("h({}, {}, [{}])", tag_str, props_str, children_str))
+        }
+        Expr::JsxFragment { children, .. } => {
+            let children_strs: Result<Vec<_>, _> =
+                children.iter().map(|c| emit_jsx_child_js(c, emit_expr)).collect();
+            let children_str = children_strs?.join(", ");
+            Ok(format!("h(Fragment, null, [{}])", children_str))
+        }
+        _ => Err(emit_err("emit_jsx_js: not a JSX expression")),
+    }
+}
+
+fn emit_err<E>(msg: &str) -> E
+where
+    E: From<String>,
+{
+    E::from(msg.to_string())
+}
+
+fn emit_jsx_props_js<F, E>(props: &[JsxProp], emit_expr: &mut F) -> Result<String, E>
+where
+    F: FnMut(&Expr) -> Result<String, E>,
+{
+    if props.is_empty() {
+        return Ok("null".to_string());
+    }
+    let parts: Result<Vec<_>, _> = props
+        .iter()
+        .map(|p| match p {
+            JsxProp::Attr { name, value } => {
+                let val = match value {
+                    JsxAttrValue::String(s) => format!("{:?}", s.as_ref()),
+                    JsxAttrValue::Expr(e) => emit_expr(e)?,
+                    JsxAttrValue::ImplicitTrue => "true".to_string(),
+                };
+                let key = name.as_ref();
+                Ok(if key.chars().all(|c| c.is_alphanumeric() || c == '_') {
+                    format!("{}: {}", key, val)
+                } else {
+                    format!("{:?}: {}", key, val)
+                })
+            }
+            JsxProp::Spread(e) => Ok(format!("...{}", emit_expr(e)?)),
+        })
+        .collect();
+    Ok(format!("{{ {} }}", parts?.join(", ")))
+}
+
+fn emit_jsx_child_js<F, E>(child: &JsxChild, emit_expr: &mut F) -> Result<String, E>
+where
+    F: FnMut(&Expr) -> Result<String, E>,
+{
+    match child {
+        JsxChild::Text(s) => Ok(format!("{:?}", s.as_ref())),
+        JsxChild::Expr(e) => {
+            let inner = emit_expr(e)?;
+            let needs_string = matches!(
+                e,
+                Expr::Literal {
+                    value: Literal::Number(_) | Literal::Bool(_) | Literal::Null,
+                    ..
+                }
+            );
+            Ok(if needs_string {
+                format!("String({})", inner)
+            } else {
+                inner
+            })
+        }
+    }
+}
+
+/// Emit JSX as Rust `Value` by calling `tishlang_ui::ui_h` directly (no closure capture of a local `h` binding).
+pub fn emit_jsx_rust<F, E>(expr: &Expr, emit_expr: &mut F) -> Result<String, E>
+where
+    F: FnMut(&Expr) -> Result<String, E>,
+    E: From<String>,
+{
+    match expr {
+        Expr::JsxElement {
+            tag,
+            props,
+            children,
+            ..
+        } => {
+            let is_component = tag.chars().next().map(|c| c.is_uppercase()).unwrap_or(false);
+            let tag_rust = if is_component {
+                escape_ident_rust(tag.as_ref())
+            } else {
+                format!("Value::String({:?}.into())", tag.as_ref())
+            };
+            let props_rust = emit_jsx_props_rust(props, emit_expr)?;
+            let child_parts: Result<Vec<_>, _> = children
+                .iter()
+                .map(|c| emit_jsx_child_rust(c, emit_expr))
+                .collect();
+            let children_rust = format!(
+                "Value::Array(Rc::new(RefCell::new(vec![{}])))",
+                child_parts?.join(", ")
+            );
+            Ok(wrap_h_call_rust(&tag_rust, &props_rust, &children_rust))
+        }
+        Expr::JsxFragment { children, .. } => {
+            let child_parts: Result<Vec<_>, _> = children
+                .iter()
+                .map(|c| emit_jsx_child_rust(c, emit_expr))
+                .collect();
+            let children_rust = format!(
+                "Value::Array(Rc::new(RefCell::new(vec![{}])))",
+                child_parts?.join(", ")
+            );
+            Ok(wrap_h_call_rust(
+                "Fragment",
+                "Value::Null",
+                &children_rust,
+            ))
+        }
+        _ => Err(E::from("emit_jsx_rust: not a JSX expression".to_string())),
+    }
+}
+
+fn wrap_h_call_rust(tag: &str, props: &str, children: &str) -> String {
+    format!(
+        "tishlang_ui::ui_h(&[({}).clone(), ({}).clone(), ({}).clone()])",
+        tag, props, children
+    )
+}
+
+fn emit_jsx_props_rust<F, E>(props: &[JsxProp], emit_expr: &mut F) -> Result<String, E>
+where
+    F: FnMut(&Expr) -> Result<String, E>,
+    E: From<String>,
+{
+    if props.is_empty() {
+        return Ok("Value::Null".to_string());
+    }
+    let has_spread = props.iter().any(|p| matches!(p, JsxProp::Spread(_)));
+    if has_spread {
+        let mut parts = Vec::new();
+        for prop in props {
+            match prop {
+                JsxProp::Attr { name, value } => {
+                    let val = match value {
+                        JsxAttrValue::String(s) => {
+                            format!("Value::String({:?}.into())", s.as_ref())
+                        }
+                        JsxAttrValue::Expr(e) => emit_expr(e)?,
+                        JsxAttrValue::ImplicitTrue => "Value::Bool(true)".to_string(),
+                    };
+                    parts.push(format!(
+                        "_obj.insert(Arc::from({:?}), ({}).clone());",
+                        name.as_ref(),
+                        val
+                    ));
+                }
+                JsxProp::Spread(e) => {
+                    let val = emit_expr(e)?;
+                    parts.push(format!(
+                        "if let Value::Object(ref _spread) = {} {{ for (k, v) in _spread.borrow().iter() {{ _obj.insert(Arc::clone(k), v.clone()); }} }}",
+                        val
+                    ));
+                }
+            }
+        }
+        Ok(format!(
+            "{{ let mut _obj: ObjectMap = ObjectMap::default(); {} Value::Object(Rc::new(RefCell::new(_obj))) }}",
+            parts.join(" ")
+        ))
+    } else {
+        let mut kv = Vec::new();
+        for prop in props {
+            if let JsxProp::Attr { name, value } = prop {
+                let val = match value {
+                    JsxAttrValue::String(s) => {
+                        format!("Value::String({:?}.into())", s.as_ref())
+                    }
+                    JsxAttrValue::Expr(e) => emit_expr(e)?,
+                    JsxAttrValue::ImplicitTrue => "Value::Bool(true)".to_string(),
+                };
+                kv.push(format!(
+                    "(Arc::from({:?}), ({}).clone())",
+                    name.as_ref(),
+                    val
+                ));
+            }
+        }
+        Ok(format!(
+            "Value::Object(Rc::new(RefCell::new(ObjectMap::from([{}]))))",
+            kv.join(", ")
+        ))
+    }
+}
+
+fn emit_jsx_child_rust<F, E>(child: &JsxChild, emit_expr: &mut F) -> Result<String, E>
+where
+    F: FnMut(&Expr) -> Result<String, E>,
+    E: From<String>,
+{
+    match child {
+        JsxChild::Text(s) => Ok(format!("Value::String({:?}.into())", s.as_ref())),
+        JsxChild::Expr(e) => {
+            let inner = emit_expr(e)?;
+            let needs_string = matches!(
+                e,
+                Expr::Literal {
+                    value: Literal::Number(_) | Literal::Bool(_) | Literal::Null,
+                    ..
+                }
+            );
+            Ok(if needs_string {
+                format!("Value::String(({}).to_display_string().into())", inner)
+            } else {
+                format!("({}).clone()", inner)
+            })
+        }
+    }
+}
+
+/// Whether the program contains any JSX syntax (for conditional native UI globals).
+pub fn program_contains_jsx(program: &tishlang_ast::Program) -> bool {
+    program.statements.iter().any(stmt_contains_jsx)
+}
+
+fn stmt_contains_jsx(stmt: &tishlang_ast::Statement) -> bool {
+    use tishlang_ast::{ExportDeclaration, Statement};
+    match stmt {
+        Statement::Block { statements, .. } => statements.iter().any(stmt_contains_jsx),
+        Statement::VarDecl { init, .. } => init.as_ref().is_some_and(expr_contains_jsx),
+        Statement::VarDeclDestructure { init, .. } => expr_contains_jsx(init),
+        Statement::ExprStmt { expr, .. } => expr_contains_jsx(expr),
+        Statement::Return { value, .. } => value.as_ref().is_some_and(expr_contains_jsx),
+        Statement::If {
+            cond,
+            then_branch,
+            else_branch,
+            ..
+        } => {
+            expr_contains_jsx(cond)
+                || stmt_contains_jsx(then_branch)
+                || else_branch.as_ref().is_some_and(|s| stmt_contains_jsx(s))
+        }
+        Statement::While { cond, body, .. } | Statement::DoWhile { body, cond, .. } => {
+            expr_contains_jsx(cond) || stmt_contains_jsx(body)
+        }
+        Statement::For { init, cond, update, body, .. } => {
+            init.as_ref().is_some_and(|s| stmt_contains_jsx(s))
+                || cond.as_ref().is_some_and(expr_contains_jsx)
+                || update.as_ref().is_some_and(expr_contains_jsx)
+                || stmt_contains_jsx(body)
+        }
+        Statement::ForOf { iterable, body, .. } => {
+            expr_contains_jsx(iterable) || stmt_contains_jsx(body)
+        }
+        Statement::Switch { expr, cases, default_body, .. } => {
+            expr_contains_jsx(expr)
+                || cases.iter().any(|(e, ss)| {
+                    e.as_ref().is_some_and(expr_contains_jsx) || ss.iter().any(stmt_contains_jsx)
+                })
+                || default_body
+                    .as_ref()
+                    .is_some_and(|ss| ss.iter().any(stmt_contains_jsx))
+        }
+        Statement::Try {
+            body,
+            catch_body,
+            finally_body,
+            ..
+        } => {
+            stmt_contains_jsx(body)
+                || catch_body.as_ref().is_some_and(|s| stmt_contains_jsx(s))
+                || finally_body.as_ref().is_some_and(|s| stmt_contains_jsx(s))
+        }
+        Statement::FunDecl { body, .. } => stmt_contains_jsx(body),
+        Statement::Throw { value, .. } => expr_contains_jsx(value),
+        Statement::Export { declaration, .. } => match declaration.as_ref() {
+            ExportDeclaration::Named(inner) => stmt_contains_jsx(inner),
+            ExportDeclaration::Default(e) => expr_contains_jsx(e),
+        },
+        Statement::Import { .. } | Statement::Break { .. } | Statement::Continue { .. } => false,
+    }
+}
+
+fn expr_contains_jsx(expr: &Expr) -> bool {
+    match expr {
+        Expr::JsxElement { .. } | Expr::JsxFragment { .. } => true,
+        Expr::Binary { left, right, .. } => expr_contains_jsx(left) || expr_contains_jsx(right),
+        Expr::Unary { operand, .. } => expr_contains_jsx(operand),
+        Expr::Assign { value, .. } => expr_contains_jsx(value),
+        Expr::Call { callee, args, .. } => {
+            expr_contains_jsx(callee)
+                || args.iter().any(|a| match a {
+                    tishlang_ast::CallArg::Expr(e) | tishlang_ast::CallArg::Spread(e) => {
+                        expr_contains_jsx(e)
+                    }
+                })
+        }
+        Expr::Member { object, prop, .. } => {
+            expr_contains_jsx(object)
+                || matches!(prop, tishlang_ast::MemberProp::Expr(e) if expr_contains_jsx(e))
+        }
+        Expr::Index { object, index, .. } => expr_contains_jsx(object) || expr_contains_jsx(index),
+        Expr::Conditional {
+            cond,
+            then_branch,
+            else_branch,
+            ..
+        } => {
+            expr_contains_jsx(cond)
+                || expr_contains_jsx(then_branch)
+                || expr_contains_jsx(else_branch)
+        }
+        Expr::Array { elements, .. } => elements.iter().any(|el| match el {
+            ArrayElement::Expr(e) | ArrayElement::Spread(e) => expr_contains_jsx(e),
+        }),
+        Expr::Object { props, .. } => props.iter().any(|p| match p {
+            ObjectProp::KeyValue(_, e) | ObjectProp::Spread(e) => expr_contains_jsx(e),
+        }),
+        Expr::ArrowFunction { body, .. } => match body {
+            tishlang_ast::ArrowBody::Expr(e) => expr_contains_jsx(e),
+            tishlang_ast::ArrowBody::Block(s) => stmt_contains_jsx(s),
+        },
+        Expr::NullishCoalesce { left, right, .. } => {
+            expr_contains_jsx(left) || expr_contains_jsx(right)
+        }
+        Expr::TemplateLiteral { exprs, .. } => exprs.iter().any(expr_contains_jsx),
+        Expr::Await { operand, .. } => expr_contains_jsx(operand),
+        Expr::TypeOf { operand, .. } => expr_contains_jsx(operand),
+        Expr::PostfixInc { .. }
+        | Expr::PrefixInc { .. }
+        | Expr::PostfixDec { .. }
+        | Expr::PrefixDec { .. } => false,
+        Expr::CompoundAssign { value, .. } | Expr::LogicalAssign { value, .. } => {
+            expr_contains_jsx(value)
+        }
+        Expr::MemberAssign { object, value, .. } => {
+            expr_contains_jsx(object) || expr_contains_jsx(value)
+        }
+        Expr::IndexAssign { object, index, value, .. } => {
+            expr_contains_jsx(object) || expr_contains_jsx(index) || expr_contains_jsx(value)
+        }
+        Expr::New { callee, args, .. } => {
+            expr_contains_jsx(callee)
+                || args.iter().any(|a| match a {
+                    tishlang_ast::CallArg::Expr(e) | tishlang_ast::CallArg::Spread(e) => {
+                        expr_contains_jsx(e)
+                    }
+                })
+        }
+        Expr::Literal { .. }
+        | Expr::Ident { .. }
+        | Expr::NativeModuleLoad { .. } => false,
+    }
+}

package/crates/tish_ui/src/lib.rs

@@ -0,0 +1,16 @@
+//! JSX lowering (compiler) and UI runtime (vnode + hooks + host) for cross-target Tish UI.
+//!
+//! - Feature **`compiler`**: AST → JS / Rust `h(...)` emission helpers (depends on `tishlang_ast`).
+//! - Feature **`runtime`**: `Value`-based `h`, `Fragment`, hooks, and [`Host`] (depends on `tishlang_core`).
+
+#[cfg(feature = "compiler")]
+pub mod jsx;
+
+#[cfg(feature = "runtime")]
+pub mod runtime;
+
+#[cfg(feature = "runtime")]
+pub use runtime::{
+    fragment_value, install_thread_local_host, native_create_root, native_use_state, ui_h,
+    ui_text, with_thread_local_host, Host, HeadlessHost, FRAGMENT_SENTINEL,
+};