@tishlang/tish 1.0.28 → 1.0.33

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,
+};

package/crates/tish_ui/src/runtime/hooks.rs

@@ -0,0 +1,122 @@
+//! Minimal hook state: `useState` + render flush (Lattish-style cursor reset).
+
+use std::cell::{Cell, RefCell};
+use std::rc::Rc;
+
+use tishlang_core::{ObjectMap, Value};
+
+use super::ACTIVE_HOST;
+
+thread_local! {
+    pub static HOOK: RefCell<HookState> = RefCell::new(HookState::default());
+    static IN_FLUSH: Cell<bool> = Cell::new(false);
+}
+
+#[derive(Default)]
+pub struct HookState {
+    pub state_slots: Rc<RefCell<Vec<Value>>>,
+    pub cursor: usize,
+    pub root_app: Option<Value>,
+    pub root_vnode: Option<Value>,
+    pub flush_scheduled: bool,
+}
+
+impl HookState {
+    pub fn reset_for_new_root(&mut self) {
+        self.state_slots.borrow_mut().clear();
+        self.cursor = 0;
+        self.root_vnode = None;
+        self.flush_scheduled = false;
+    }
+}
+
+/// `useState(initial)` → `[state, setState]` as a Tish array.
+pub fn native_use_state(args: &[Value]) -> Value {
+    let initial = args.first().cloned().unwrap_or(Value::Null);
+    HOOK.with(|h| {
+        let mut st = h.borrow_mut();
+        let i = st.cursor;
+        st.cursor += 1;
+        let slots = Rc::clone(&st.state_slots);
+        while i >= slots.borrow().len() {
+            slots.borrow_mut().push(initial.clone());
+        }
+        let current = slots.borrow()[i].clone();
+        let idx = i;
+        let setter = Value::Function(Rc::new(move |a: &[Value]| {
+            let new_v = a.first().cloned().unwrap_or(Value::Null);
+            slots.borrow_mut()[idx] = new_v;
+            schedule_flush();
+            Value::Null
+        }));
+        Value::Array(Rc::new(RefCell::new(vec![current, setter])))
+    })
+}
+
+/// `createRoot(container)` → `{ render: (App) => { ... } }` (container ignored for headless native).
+pub fn native_create_root(args: &[Value]) -> Value {
+    let _container = args.first();
+    let render_fn = Value::Function(Rc::new(|app_args: &[Value]| {
+        let app = app_args.first().cloned().unwrap_or(Value::Null);
+        HOOK.with(|h| {
+            let mut st = h.borrow_mut();
+            st.reset_for_new_root();
+            st.root_app = Some(app);
+            st.flush_scheduled = true;
+        });
+        drain_flush_queue();
+        Value::Null
+    }));
+    Value::Object(Rc::new(RefCell::new(ObjectMap::from([(
+        std::sync::Arc::from("render"),
+        render_fn,
+    )]))))
+}
+
+/// Request a re-render (coalesced; safe if called during flush).
+pub fn schedule_flush() {
+    HOOK.with(|h| {
+        h.borrow_mut().flush_scheduled = true;
+    });
+    if IN_FLUSH.get() {
+        return;
+    }
+    drain_flush_queue();
+}
+
+fn drain_flush_queue() {
+    loop {
+        let run = HOOK.with(|h| {
+            let mut st = h.borrow_mut();
+            if st.flush_scheduled {
+                st.flush_scheduled = false;
+                true
+            } else {
+                false
+            }
+        });
+        if !run {
+            break;
+        }
+        IN_FLUSH.set(true);
+        HOOK.with(|h| {
+            let mut st = h.borrow_mut();
+            st.cursor = 0;
+            let Some(app) = st.root_app.clone() else {
+                return;
+            };
+            let Value::Function(f) = app else {
+                return;
+            };
+            let tree = f(&[]);
+            st.root_vnode = Some(tree.clone());
+            ACTIVE_HOST.with(|host_cell| {
+                let mut host_opt = host_cell.borrow_mut();
+                if let Some(host) = host_opt.as_deref_mut() {
+                    host.commit_root(&tree);
+                }
+            });
+        });
+        IN_FLUSH.set(false);
+    }
+}

package/crates/tish_ui/src/runtime/mod.rs

@@ -0,0 +1,173 @@
+//! UI runtime: `h`, `Fragment`, vnode shapes compatible with Lattish, minimal hooks, and [`Host`].
+
+mod hooks;
+
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::sync::Arc;
+
+pub use hooks::{native_create_root, native_use_state, schedule_flush, HookState, HOOK};
+
+use tishlang_core::{ObjectMap, Value};
+
+/// Sentinel string for `Fragment` (native). JS/Lattish uses `Symbol`; hosts compare via equality.
+pub const FRAGMENT_SENTINEL: &str = "__tish_ui_Fragment__";
+
+/// `Fragment` marker value for `h(Fragment, null, children)`.
+pub fn fragment_value() -> Value {
+    Value::String(FRAGMENT_SENTINEL.into())
+}
+
+/// Returns true if `tag` refers to [`fragment_value`].
+pub fn is_fragment_tag(tag: &Value) -> bool {
+    matches!(tag, Value::String(s) if s.as_ref() == FRAGMENT_SENTINEL)
+}
+
+/// `text(s)` helper — returns string as `Value::String` for JSX text nodes.
+pub fn ui_text(args: &[Value]) -> Value {
+    let s = args
+        .first()
+        .map(|v| v.to_display_string())
+        .unwrap_or_default();
+    Value::String(s.into())
+}
+
+/// Vnode factory: `h(tag, props, children)` (Lattish-compatible shape).
+pub fn ui_h(args: &[Value]) -> Value {
+    let tag = args.get(0).cloned().unwrap_or(Value::Null);
+    let props = args.get(1).cloned().unwrap_or(Value::Null);
+    let children_arg = args.get(2).cloned().unwrap_or(Value::Null);
+
+    let children_vec = normalize_children_list(children_arg);
+
+    if let Value::Function(f) = &tag {
+        let mut merged = if matches!(props, Value::Null) {
+            ObjectMap::default()
+        } else if let Value::Object(obj) = props {
+            obj.borrow().clone()
+        } else {
+            ObjectMap::default()
+        };
+        if !children_vec.is_empty() {
+            merged.insert(
+                Arc::from("children"),
+                Value::Array(Rc::new(RefCell::new(children_vec.clone()))),
+            );
+        }
+        return f(&[Value::Object(Rc::new(RefCell::new(merged)))]);
+    }
+
+    if is_fragment_tag(&tag) {
+        return vnode_fragment(children_vec);
+    }
+
+    let tag_str: Arc<str> = match tag {
+        Value::String(s) => s,
+        _ => return Value::Null,
+    };
+
+    vnode_element(tag_str, props, children_vec)
+}
+
+fn normalize_children_list(children_arg: Value) -> Vec<Value> {
+    match children_arg {
+        Value::Null => vec![],
+        Value::Array(a) => a.borrow().clone(),
+        other => vec![other],
+    }
+}
+
+fn vnode_element(tag: Arc<str>, props: Value, children: Vec<Value>) -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("tag"), Value::String(tag));
+    m.insert(
+        Arc::from("props"),
+        if matches!(props, Value::Null) {
+            Value::Null
+        } else {
+            props
+        },
+    );
+    m.insert(
+        Arc::from("children"),
+        Value::Array(Rc::new(RefCell::new(children))),
+    );
+    m.insert(Arc::from("_el"), Value::Null);
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+fn vnode_fragment(children: Vec<Value>) -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("tag"), fragment_value());
+    m.insert(Arc::from("props"), Value::Null);
+    m.insert(
+        Arc::from("children"),
+        Value::Array(Rc::new(RefCell::new(children))),
+    );
+    m.insert(Arc::from("_el"), Value::Null);
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+/// Pluggable UI backend (Floem, DOM, SwiftUI, …). Main-thread / single-threaded by default.
+pub trait Host {
+    /// Apply a new root vnode (after each render flush).
+    fn commit_root(&mut self, vnode: &Value);
+}
+
+/// No-op / test host that only stores the last committed tree.
+pub struct HeadlessHost {
+    pub last: Option<Value>,
+}
+
+impl Default for HeadlessHost {
+    fn default() -> Self {
+        Self { last: None }
+    }
+}
+
+impl Host for HeadlessHost {
+    fn commit_root(&mut self, vnode: &Value) {
+        self.last = Some(vnode.clone());
+    }
+}
+
+thread_local! {
+    static ACTIVE_HOST: RefCell<Option<Box<dyn Host>>> = RefCell::new(None);
+}
+
+/// Install the thread-local host used by [`schedule_flush`] / `createRoot`.
+pub fn install_thread_local_host(host: Box<dyn Host>) {
+    ACTIVE_HOST.with(|c| {
+        *c.borrow_mut() = Some(host);
+    });
+}
+
+pub fn with_thread_local_host<R>(f: impl FnOnce(&mut dyn Host) -> R) -> Option<R> {
+    ACTIVE_HOST.with(|c| {
+        let mut opt = c.borrow_mut();
+        match opt.as_deref_mut() {
+            Some(host) => Some(f(host)),
+            None => None,
+        }
+    })
+}
+
+/// Tag registry hook for future host-specific intrinsic mapping (HTML tag → component kind).
+#[derive(Default)]
+pub struct TagRegistry;
+
+impl TagRegistry {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+/// Placeholder for subset CSS / style object interpretation.
+#[derive(Default)]
+pub struct StyleInterpreter;
+
+impl StyleInterpreter {
+    pub fn new() -> Self {
+        Self
+    }
+}