@tishlang/tish 1.10.0 → 1.13.0

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

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();
@@ -191,6 +213,7 @@ fn memo_dep_eq(a: &Value, b: &Value) -> bool {
             }
             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,
     }
 }
@@ -239,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
@@ -284,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;
     };
@@ -301,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());
@@ -315,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,
@@ -325,14 +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;
     };
@@ -370,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,
@@ -416,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()
@@ -440,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;
@@ -452,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);
         }