@tishlang/tish 1.9.2 → 1.12.0

package/crates/tish_runtime/src/ws.rs

@@ -5,10 +5,8 @@
 //! - **Connection**: `send(data)`, `close()`, `readyState` (1=OPEN), `receive()` / `receiveTimeout(ms)`
 //! - **Broadcast** (Node pattern): `server.clients.forEach(ws => ws.send(data))` or iterate room conns and `wsSend(ws, data)` (same as `ws.send(data)`)
 
-use std::cell::RefCell;
 use tishlang_core::VmRef;
 use std::collections::HashMap;
-use std::rc::Rc;
 use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::mpsc;
 use std::sync::{Arc, Mutex};
@@ -151,7 +149,7 @@ fn conn_id_from_value(v: &Value) -> Option<u32> {
         Value::Object(o) => {
             let b = o.borrow();
             // Direct conn: { _id, send, ... }
-            if let Some(idv) = b.get(&Arc::from("_id")) {
+            if let Some(idv) = b.strings.get("_id") {
                 if let Value::Number(n) = idv {
                     if n.is_finite() && *n >= 0.0 {
                         return Some(*n as u32);
@@ -159,7 +157,7 @@ fn conn_id_from_value(v: &Value) -> Option<u32> {
                 }
             }
             // Wrapper: { ws: conn, ... }
-            if let Some(ws) = b.get(&Arc::from("ws")) {
+            if let Some(ws) = b.strings.get("ws") {
                 return conn_id_from_value(ws);
             }
             None
@@ -221,7 +219,7 @@ fn conn_object(id: u32) -> Value {
             Some(s) => {
                 let mut ev: ObjectMap = ObjectMap::default();
                 ev.insert(Arc::from("data"), Value::String(s.into()));
-                Value::Object(VmRef::new(ev))
+                Value::object(ev)
             }
             None => Value::Null,
         }),
@@ -243,18 +241,18 @@ fn conn_object(id: u32) -> Value {
                 Some(s) => {
                     let mut ev: ObjectMap = ObjectMap::default();
                     ev.insert(Arc::from("data"), Value::String(s.into()));
-                    Value::Object(VmRef::new(ev))
+                    Value::object(ev)
                 }
                 None => Value::Null,
             }
         }),
     );
-    Value::Object(VmRef::new(obj))
+    Value::object(obj)
 }
 
 fn parse_port(args: &[Value]) -> Option<u16> {
     args.first().and_then(|v| match v {
-        Value::Object(o) => o.borrow().get(&Arc::from("port")).and_then(|v| match v {
+        Value::Object(o) => o.borrow().strings.get("port").and_then(|v| match v {
             Value::Number(n) if n.is_finite() && *n >= 0.0 => Some(*n as u16),
             _ => None,
         }),
@@ -485,7 +483,9 @@ pub fn web_socket_server_construct(args: &[Value]) -> Value {
             .unwrap_or_default();
         let cb = args.get(2).cloned().unwrap_or(Value::Null);
         if event == "connection" {
-            so.borrow_mut().insert(Arc::from("_onConnection"), cb);
+            so.borrow_mut()
+                .strings
+                .insert(Arc::from("_onConnection"), cb);
         }
         Value::Null
     });
@@ -498,14 +498,20 @@ pub fn web_socket_server_construct(args: &[Value]) -> Value {
         loop {
             let handle_n = {
                 let b = so.borrow();
-                match b.get(&Arc::from("_handle")).cloned().unwrap_or(Value::Null) {
+                match b
+                    .strings
+                    .get("_handle")
+                    .cloned()
+                    .unwrap_or(Value::Null)
+                {
                     Value::Number(n) if n.is_finite() && n >= 0.0 => n,
                     _ => break,
                 }
             };
             let cb = so
                 .borrow()
-                .get(&Arc::from("_onConnection"))
+                .strings
+                .get("_onConnection")
                 .cloned()
                 .unwrap_or(Value::Null);
             let ws = web_socket_server_accept(&[Value::Number(handle_n)]);
@@ -527,7 +533,8 @@ pub fn web_socket_server_construct(args: &[Value]) -> Value {
         };
         let handle_n = so
             .borrow()
-            .get(&Arc::from("_handle"))
+            .strings
+            .get("_handle")
             .cloned()
             .unwrap_or(Value::Null);
         let timeout_ms = args.get(1).cloned().unwrap_or(Value::Number(100.0));
@@ -545,7 +552,7 @@ pub fn web_socket_server_construct(args: &[Value]) -> Value {
     m.insert(Arc::from("on"), on_fn);
     m.insert(Arc::from("listen"), listen_fn);
     m.insert(Arc::from("acceptTimeout"), accept_timeout_fn);
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }
 
 #[cfg(test)]
@@ -560,7 +567,7 @@ mod tests {
         let opts = {
             let mut m: ObjectMap = ObjectMap::default();
             m.insert(Arc::from("port"), Value::Number(port as f64));
-            Value::Object(VmRef::new(m))
+            Value::object(m)
         };
 
         let handle = match web_socket_server_listen(std::slice::from_ref(&opts)) {
@@ -575,20 +582,21 @@ mod tests {
             };
             // Echo one message
             for _ in 0..50 {
-                let recv_fn = wso.borrow().get(&Arc::from("receive")).cloned();
+                let recv_fn = wso.borrow().strings.get("receive").cloned();
                 if let Some(Value::Function(rf)) = recv_fn {
                     let msg = rf(&[]);
                     if !matches!(msg, Value::Null) {
                         let data = match msg {
                             Value::Object(ev) => ev
                                 .borrow()
-                                .get(&Arc::from("data"))
+                                .strings
+                                .get("data")
                                 .map(|v| v.to_display_string())
                                 .unwrap_or_default(),
                             _ => String::new(),
                         };
                         if let Some(Value::Function(sf)) =
-                            wso.borrow().get(&Arc::from("send")).cloned()
+                            wso.borrow().strings.get("send").cloned()
                         {
                             let _ = sf(&[Value::String(data.into())]);
                         }
@@ -607,13 +615,13 @@ mod tests {
         let Value::Object(co) = client else {
             panic!("client not object");
         };
-        let send = co.borrow().get(&Arc::from("send")).cloned().unwrap();
+        let send = co.borrow().strings.get("send").cloned().unwrap();
         let Value::Function(send_f) = send else {
             panic!("no send");
         };
         let _ = send_f(&[Value::String("hello".into())]);
 
-        let recv = co.borrow().get(&Arc::from("receive")).cloned().unwrap();
+        let recv = co.borrow().strings.get("receive").cloned().unwrap();
         let Value::Function(recv_f) = recv else {
             panic!("no receive");
         };
@@ -630,7 +638,8 @@ mod tests {
         };
         let data = ev
             .borrow()
-            .get(&Arc::from("data"))
+            .strings
+            .get("data")
             .map(|v| v.to_display_string())
             .unwrap_or_default();
         assert_eq!(data, "hello");
@@ -645,7 +654,7 @@ mod tests {
         let opts = {
             let mut m: ObjectMap = ObjectMap::default();
             m.insert(Arc::from("port"), Value::Number(port as f64));
-            Value::Object(VmRef::new(m))
+            Value::object(m)
         };
 
         let handle = match web_socket_server_listen(std::slice::from_ref(&opts)) {
@@ -658,7 +667,7 @@ mod tests {
             let Value::Object(wso) = ws else {
                 panic!("accept failed");
             };
-            let recv_fn = wso.borrow().get(&Arc::from("receive")).cloned();
+            let recv_fn = wso.borrow().strings.get("receive").cloned();
             let Value::Function(rf) = recv_fn.unwrap() else {
                 panic!("no receive");
             };
@@ -669,7 +678,8 @@ mod tests {
                     let data = match &msg {
                         Value::Object(ev) => ev
                             .borrow()
-                            .get(&Arc::from("data"))
+                            .strings
+                            .get("data")
                             .map(|v| v.to_display_string())
                             .unwrap_or_default(),
                         _ => String::new(),
@@ -695,7 +705,7 @@ mod tests {
         let Value::Object(co) = client else {
             panic!("client not object");
         };
-        let send = co.borrow().get(&Arc::from("send")).cloned().unwrap();
+        let send = co.borrow().strings.get("send").cloned().unwrap();
         let Value::Function(send_f) = send else {
             panic!("no send");
         };
@@ -705,7 +715,8 @@ mod tests {
         // Client uses receiveTimeout like the agent
         let recv_timeout = co
             .borrow()
-            .get(&Arc::from("receiveTimeout"))
+            .strings
+            .get("receiveTimeout")
             .cloned()
             .unwrap();
         let Value::Function(recv_timeout_f) = recv_timeout else {
@@ -719,7 +730,8 @@ mod tests {
         };
         let data1 = ev1
             .borrow()
-            .get(&Arc::from("data"))
+            .strings
+            .get("data")
             .map(|v| v.to_display_string())
             .unwrap_or_default();
         assert!(
@@ -734,7 +746,8 @@ mod tests {
         };
         let data2 = ev2
             .borrow()
-            .get(&Arc::from("data"))
+            .strings
+            .get("data")
             .map(|v| v.to_display_string())
             .unwrap_or_default();
         assert!(

package/crates/tish_runtime/tests/fetch_readable_stream.rs

@@ -52,11 +52,15 @@ fn fetch_readable_stream_read_chunks() {
         _ => panic!("expected object response, got {:?}", resp),
     };
     assert!(obj
+        .strings
         .get(&std::sync::Arc::from("ok"))
         .map(|v| matches!(v, Value::Bool(true)))
         .unwrap_or(false));
 
-    let body = obj.get(&std::sync::Arc::from("body")).expect("body");
+    let body = obj
+        .strings
+        .get(&std::sync::Arc::from("body"))
+        .expect("body");
     let stream = match body {
         Value::Opaque(s) => s.as_ref(),
         _ => panic!("expected ReadableStream opaque"),
@@ -74,14 +78,12 @@ fn fetch_readable_stream_read_chunks() {
         let (done, chunk_bytes) = match chunk {
             Value::Object(o) => {
                 let m = o.borrow();
-                let done = m
-                    .get(&std::sync::Arc::from("done"))
-                    .and_then(|v| match v {
-                        Value::Bool(b) => Some(*b),
-                        _ => None,
-                    })
-                    .unwrap_or(true);
+                let done = match m.strings.get(&std::sync::Arc::from("done")) {
+                    Some(Value::Bool(b)) => *b,
+                    _ => true,
+                };
                 let bytes = m
+                    .strings
                     .get(&std::sync::Arc::from("value"))
                     .map(|v| byte_array_to_vec(v))
                     .unwrap_or_default();

package/crates/tish_ui/src/jsx.rs

@@ -344,7 +344,9 @@ fn collect_fun_decl_names_expr(expr: &Expr, names: &mut HashSet<String>) {
         | Expr::PrefixInc { .. }
         | Expr::PostfixDec { .. }
         | Expr::PrefixDec { .. } => {}
-        Expr::JsxElement { props, children, .. } => {
+        Expr::JsxElement {
+            props, children, ..
+        } => {
             for p in props {
                 match p {
                     JsxProp::Attr { value, .. } => {
@@ -466,14 +468,14 @@ where
                 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()); }} }}",
+                        "if let Value::Object(ref _spread) = {} {{ for (k, v) in _spread.borrow().strings.iter() {{ _obj.insert(Arc::clone(k), v.clone()); }} }}",
                         val
                     ));
                 }
             }
         }
         Ok(format!(
-            "{{ let mut _obj: ObjectMap = ObjectMap::default(); {} Value::Object(VmRef::new(_obj)) }}",
+            "{{ let mut _obj: ObjectMap = ObjectMap::default(); {} Value::object(_obj) }}",
             parts.join(" ")
         ))
     } else {
@@ -495,7 +497,7 @@ where
             }
         }
         Ok(format!(
-            "Value::Object(VmRef::new(ObjectMap::from([{}])))",
+            "Value::object(ObjectMap::from([{}]))",
             kv.join(", ")
         ))
     }

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

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

@@ -5,6 +5,8 @@ use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
 use std::rc::Rc;
 
+use std::sync::Arc;
+
 use tishlang_core::{ObjectMap, Value, VmRef};
 
 use super::Host;
@@ -18,9 +20,10 @@ pub const LEGACY_ROOT_ID: RootId = 1;
 thread_local! {
     static HOOKS: RefCell<HashMap<RootId, HookState>> = RefCell::new(HashMap::new());
     static CURRENT_ROOT: Cell<Option<RootId>> = Cell::new(None);
-    static HOSTS: RefCell<HashMap<RootId, Box<dyn Host>>> = RefCell::new(HashMap::new());
+    static HOSTS: RefCell<HashMap<RootId, Rc<RefCell<Box<dyn Host>>>>> = RefCell::new(HashMap::new());
     static NEXT_DYNAMIC_ROOT_ID: Cell<RootId> = Cell::new(2);
     static IN_FLUSH: Cell<bool> = Cell::new(false);
+    static IN_EFFECT_FLUSH: Cell<bool> = Cell::new(false);
 }
 
 /// Allocate an id for an additional in-process window (starts at 2; 1 is legacy primary).
@@ -42,7 +45,8 @@ fn ensure_hook_entry(root_id: RootId) {
 pub fn install_host_for_root(root_id: RootId, host: Box<dyn Host>) {
     ensure_hook_entry(root_id);
     HOSTS.with(|h| {
-        h.borrow_mut().insert(root_id, host);
+        h.borrow_mut()
+            .insert(root_id, Rc::new(RefCell::new(host)));
     });
 }
 
@@ -77,8 +81,10 @@ pub fn unregister_root(root_id: RootId) {
 
 pub fn with_host_for_root<R>(root_id: RootId, f: impl FnOnce(&mut dyn Host) -> R) -> Option<R> {
     HOSTS.with(|c| {
-        let mut m = c.borrow_mut();
-        m.get_mut(&root_id).map(|host| f(host.as_mut()))
+        let m = c.borrow();
+        let host = m.get(&root_id)?;
+        let mut host = host.try_borrow_mut().ok()?;
+        Some(f(host.as_mut()))
     })
 }
 
@@ -128,6 +134,11 @@ pub struct HookState {
     effect_cells: Rc<RefCell<Vec<EffectCell>>>,
     effect_cursor: usize,
     pending_effects: Rc<RefCell<Vec<PendingEffect>>>,
+    layout_effect_cells: Rc<RefCell<Vec<EffectCell>>>,
+    layout_effect_cursor: usize,
+    pending_layout_effects: Rc<RefCell<Vec<PendingEffect>>>,
+    ref_slots: Rc<RefCell<Vec<Value>>>,
+    ref_cursor: usize,
 }
 
 impl Default for HookState {
@@ -143,6 +154,11 @@ impl Default for HookState {
             effect_cells: Rc::new(RefCell::new(Vec::new())),
             effect_cursor: 0,
             pending_effects: Rc::new(RefCell::new(Vec::new())),
+            layout_effect_cells: Rc::new(RefCell::new(Vec::new())),
+            layout_effect_cursor: 0,
+            pending_layout_effects: Rc::new(RefCell::new(Vec::new())),
+            ref_slots: Rc::new(RefCell::new(Vec::new())),
+            ref_cursor: 0,
         }
     }
 }
@@ -160,11 +176,17 @@ fn run_all_effect_cleanups(cells: &RefCell<Vec<EffectCell>>) {
 impl HookState {
     pub fn reset_for_new_root(&mut self) {
         run_all_effect_cleanups(self.effect_cells.as_ref());
+        run_all_effect_cleanups(self.layout_effect_cells.as_ref());
         self.effect_cells.borrow_mut().clear();
+        self.layout_effect_cells.borrow_mut().clear();
         self.effect_cursor = 0;
+        self.layout_effect_cursor = 0;
         self.pending_effects.borrow_mut().clear();
+        self.pending_layout_effects.borrow_mut().clear();
         self.state_slots.borrow_mut().clear();
         self.cursor = 0;
+        self.ref_slots.borrow_mut().clear();
+        self.ref_cursor = 0;
         self.root_vnode = None;
         self.flush_scheduled = false;
         self.memo_cache.borrow_mut().clear();
@@ -189,20 +211,15 @@ fn memo_dep_eq(a: &Value, b: &Value) -> bool {
             if ab.len() != bb.len() {
                 return false;
             }
-            ab.iter()
-                .zip(bb.iter())
-                .all(|(x, y)| memo_dep_eq(x, y))
+            ab.iter().zip(bb.iter()).all(|(x, y)| memo_dep_eq(x, y))
         }
+        (Value::Object(a), Value::Object(b)) => tishlang_core::VmRef::ptr_eq(a, b),
         _ => false,
     }
 }
 
 fn memo_deps_unchanged(prev: &[Value], next: &[Value]) -> bool {
-    prev.len() == next.len()
-        && prev
-            .iter()
-            .zip(next.iter())
-            .all(|(a, b)| memo_dep_eq(a, b))
+    prev.len() == next.len() && prev.iter().zip(next.iter()).all(|(a, b)| memo_dep_eq(a, b))
 }
 
 fn root_id_for_hooks() -> RootId {
@@ -245,7 +262,7 @@ pub fn native_use_state(args: &[Value]) -> Value {
                     st.flush_scheduled = true;
                 }
             });
-            if !IN_FLUSH.get() {
+            if !IN_FLUSH.get() && !IN_EFFECT_FLUSH.get() {
                 drain_flush_queue();
             }
             Value::Null
@@ -290,9 +307,29 @@ pub fn native_use_memo(args: &[Value]) -> Value {
     })
 }
 
-/// `useEffect(effect, deps?)` — runs `effect` after the host commits the tree; compares `deps` like `useMemo`.
-/// If `effect` returns a function, it is called before the next run or on root teardown (`render` replacement / [`unregister_root`]).
-pub fn native_use_effect(args: &[Value]) -> Value {
+/// `useRef(initial)` → `{ current: initial }` (stable object identity per slot).
+pub fn native_use_ref(args: &[Value]) -> Value {
+    let initial = args.first().cloned().unwrap_or(Value::Null);
+    let root_id = root_id_for_hooks();
+    HOOKS.with(|h| {
+        let mut map = h.borrow_mut();
+        let st = map.entry(root_id).or_default();
+        let i = st.ref_cursor;
+        st.ref_cursor += 1;
+        while i >= st.ref_slots.borrow().len() {
+            let mut m = ObjectMap::default();
+            m.insert(Arc::from("current"), initial.clone());
+            st.ref_slots.borrow_mut().push(Value::object(m));
+        }
+        let out = st.ref_slots.borrow()[i].clone();
+        out
+    })
+}
+
+fn queue_effect(
+    args: &[Value],
+    layout: bool,
+) -> Value {
     let Some(Value::Function(effect_fn)) = args.first() else {
         return Value::Null;
     };
@@ -307,9 +344,22 @@ pub fn native_use_effect(args: &[Value]) -> Value {
     HOOKS.with(|h| {
         let mut map = h.borrow_mut();
         let st = map.entry(root_id).or_default();
-        let i = st.effect_cursor;
-        st.effect_cursor += 1;
-        let cells = &st.effect_cells.clone();
+        let (cursor, cells, pending) = if layout {
+            (
+                &mut st.layout_effect_cursor,
+                &st.layout_effect_cells,
+                &st.pending_layout_effects,
+            )
+        } else {
+            (
+                &mut st.effect_cursor,
+                &st.effect_cells,
+                &st.pending_effects,
+            )
+        };
+        let i = *cursor;
+        *cursor += 1;
+        let cells = cells.clone();
         let mut cells_b = cells.borrow_mut();
         while cells_b.len() <= i {
             cells_b.push(EffectCell::default());
@@ -321,7 +371,7 @@ pub fn native_use_effect(args: &[Value]) -> Value {
         drop(cells_b);
 
         if should_run {
-            st.pending_effects.borrow_mut().push(PendingEffect {
+            pending.borrow_mut().push(PendingEffect {
                 slot: i,
                 effect_fn: Value::Function(effect_fn),
                 new_deps: deps,
@@ -331,18 +381,29 @@ pub fn native_use_effect(args: &[Value]) -> Value {
     })
 }
 
-fn flush_pending_effects(root_id: RootId) {
+/// `useLayoutEffect(effect, deps?)` — runs synchronously after commit, before `useEffect`.
+pub fn native_use_layout_effect(args: &[Value]) -> Value {
+    queue_effect(args, true)
+}
+
+/// `useEffect(effect, deps?)` — runs `effect` after the host commits the tree; compares `deps` like `useMemo`.
+/// If `effect` returns a function, it is called before the next run or on root teardown (`render` replacement / [`unregister_root`]).
+pub fn native_use_effect(args: &[Value]) -> Value {
+    queue_effect(args, false)
+}
+
+fn flush_pending_effects_for(
+    root_id: RootId,
+    pending_key: impl FnOnce(&mut HookState) -> &Rc<RefCell<Vec<PendingEffect>>>,
+    cells_key: impl FnOnce(&HookState) -> Rc<RefCell<Vec<EffectCell>>>,
+) {
     let pending: Vec<PendingEffect> = HOOKS.with(|h| {
         h.borrow_mut()
             .get_mut(&root_id)
-            .map(|st| std::mem::take(&mut *st.pending_effects.borrow_mut()))
+            .map(|st| std::mem::take(&mut *pending_key(st).borrow_mut()))
             .unwrap_or_default()
     });
-    let cells_rc = HOOKS.with(|h| {
-        h.borrow()
-            .get(&root_id)
-            .map(|st| st.effect_cells.clone())
-    });
+    let cells_rc = HOOKS.with(|h| h.borrow().get(&root_id).map(cells_key));
     let Some(cells_rc) = cells_rc else {
         return;
     };
@@ -380,6 +441,26 @@ fn flush_pending_effects(root_id: RootId) {
     }
 }
 
+fn flush_pending_layout_effects(root_id: RootId) {
+    IN_EFFECT_FLUSH.set(true);
+    flush_pending_effects_for(
+        root_id,
+        |st| &st.pending_layout_effects,
+        |st| st.layout_effect_cells.clone(),
+    );
+    IN_EFFECT_FLUSH.set(false);
+}
+
+fn flush_pending_effects(root_id: RootId) {
+    IN_EFFECT_FLUSH.set(true);
+    flush_pending_effects_for(
+        root_id,
+        |st| &st.pending_effects,
+        |st| st.effect_cells.clone(),
+    );
+    IN_EFFECT_FLUSH.set(false);
+}
+
 fn parse_root_id_arg(args: &[Value]) -> RootId {
     match args.first() {
         Some(Value::Number(n)) if n.is_finite() && *n >= 1.0 && n.fract() == 0.0 => *n as u64,
@@ -405,10 +486,10 @@ pub fn native_create_root(args: &[Value]) -> Value {
         drain_flush_queue();
         Value::Null
     });
-    Value::Object(VmRef::new(ObjectMap::from([(
+    Value::object(ObjectMap::from([(
         std::sync::Arc::from("render"),
         render_fn,
-    )])))
+    )]))
 }
 
 /// Request a re-render (coalesced; safe if called during flush).
@@ -426,6 +507,10 @@ pub fn schedule_flush() {
 }
 
 fn drain_flush_queue() {
+    drain_flush_queue_on_current_thread();
+}
+
+fn drain_flush_queue_on_current_thread() {
     loop {
         let root_id = HOOKS.with(|h| {
             h.borrow()
@@ -450,8 +535,11 @@ fn drain_flush_queue() {
             let st = map.get_mut(&root_id)?;
             st.cursor = 0;
             st.memo_cursor = 0;
+            st.ref_cursor = 0;
             st.effect_cursor = 0;
+            st.layout_effect_cursor = 0;
             st.pending_effects.borrow_mut().clear();
+            st.pending_layout_effects.borrow_mut().clear();
             let app = st.root_app.clone()?;
             let Value::Function(f) = app else {
                 return None;
@@ -462,18 +550,16 @@ fn drain_flush_queue() {
         if let Some(f) = app_fn {
             let tree = f(&[]);
             HOOKS.with(|h| {
-                let mut map = h.borrow_mut();
-                if let Some(st) = map.get_mut(&root_id) {
+                if let Some(st) = h.borrow_mut().get_mut(&root_id) {
                     st.root_vnode = Some(tree.clone());
-                    HOSTS.with(|hosts| {
-                        let mut hm = hosts.borrow_mut();
-                        if let Some(host) = hm.get_mut(&root_id) {
-                            host.commit_root(&tree);
-                        }
-                    });
                 }
             });
+            let host = HOSTS.with(|hosts| hosts.borrow().get(&root_id).cloned());
+            if let Some(host) = host {
+                host.borrow_mut().commit_root(&tree);
+            }
             IN_FLUSH.set(false);
+            flush_pending_layout_effects(root_id);
             flush_pending_effects(root_id);
         }