feat(ui): add a Solid universal renderer for native widgets

changelog.d/9825-solid-native-renderer.md

@@ -0,0 +1 @@
+- Add `perry-solid`, a Solid universal-renderer bridge for native stacks, text, buttons, spacers, and dividers, with hyperscript authoring, reactive properties, keyed widget moves, and owner disposal. Add a counter/list example, a Node/native release fixture, and a macOS Geisterhand smoke test. Correct macOS indexed stack insertion and retained layout metadata, match the compiler's reorder arguments to the native floating-point ABI, and implement Windows child reordering. Solid JSX compilation remains a separate stage of #4644.

crates/perry-dispatch/src/ui_table/part_a.rs

@@ -934,7 +934,7 @@ pub(crate) const PERRY_UI_TABLE_PART_A: &[MethodRow] = &[
     MethodRow {
         method: "widgetReorderChild",
         runtime: "perry_ui_widget_reorder_child",
-        args: &[ArgKind::Widget, ArgKind::I64Raw, ArgKind::I64Raw],
+        args: &[ArgKind::Widget, ArgKind::F64, ArgKind::F64],
         ret: ReturnKind::Void,
     },
     MethodRow {

crates/perry-ui-macos/Cargo.toml

@@ -69,3 +69,11 @@ objc2-app-kit = { version = "0.3", features = [
     "NSStatusItem",
     "NSStatusBarButton",
 ] }
+
+[target.'cfg(target_os = "macos")'.dev-dependencies]
+perry-runtime.workspace = true
+
+[[test]]
+name = "native_widget_order"
+path = "tests/native_widget_order.rs"
+harness = false

crates/perry-ui-macos/src/widgets/mod.rs

@@ -47,7 +47,7 @@ pub mod zstack;
 use objc2::rc::Retained;
 use objc2::runtime::{AnyClass, AnyObject};
 use objc2::{msg_send, AnyThread, DefinedClass};
-use objc2_app_kit::{NSStackView, NSView};
+use objc2_app_kit::{NSStackView, NSStackViewGravity, NSView};
 use objc2_foundation::NSObjectProtocol;
 use std::cell::RefCell;
 
@@ -284,13 +284,13 @@ pub fn set_hidden(handle: i64, hidden: bool) {
                         if is_stack {
                             let stack: &NSStackView =
                                 unsafe { &*(Retained::as_ptr(&parent) as *const NSStackView) };
-                            let count = stack.arrangedSubviews().len();
-                            let insert_idx = index.min(count);
-                            unsafe {
-                                let _: () = objc2::msg_send![
-                                    stack, insertArrangedSubview: &*view, atIndex: insert_idx
-                                ];
-                            }
+                            let count = stack.viewsInGravity(NSStackViewGravity::Top).len();
+                            stack.insertView_atIndex_inGravity(
+                                &view,
+                                index.min(count),
+                                NSStackViewGravity::Top,
+                            );
+                            refresh_stack_parent_map(parent_handle, stack);
                         }
                     }
                 }
@@ -486,27 +486,50 @@ pub fn clear_children(handle: i64) {
     }
 }
 
-/// Add a child view to a parent view at a specific index.
+/// Refresh positions used when AppKit detaches and later reattaches hidden views.
+fn refresh_stack_parent_map(parent_handle: i64, stack: &NSStackView) {
+    let views = stack.viewsInGravity(NSStackViewGravity::Top);
+    WIDGETS.with(|widgets| {
+        let widgets = widgets.borrow();
+        PARENT_MAP.with(|parents| {
+            let mut parents = parents.borrow_mut();
+            for (index, view) in views.iter().enumerate() {
+                if let Some(handle_index) = widgets
+                    .iter()
+                    .position(|registered| Retained::as_ptr(registered) == Retained::as_ptr(&view))
+                {
+                    parents.insert(handle_index as i64 + 1, (parent_handle, index));
+                }
+            }
+        });
+    });
+}
+
+/// Insert or move a child at an index, retaining its own layout metadata.
+/// Perry stacks use the top/leading gravity area for both orientations.
 pub fn add_child_at(parent_handle: i64, child_handle: i64, index: i64) {
     if let (Some(parent), Some(child)) = (get_widget(parent_handle), get_widget(child_handle)) {
-        let is_stack = if let Some(cls) = AnyClass::get(c"NSStackView") {
-            parent.isKindOfClass(cls)
-        } else {
-            false
-        };
-
+        let is_stack = AnyClass::get(c"NSStackView")
+            .map(|class| parent.isKindOfClass(class))
+            .unwrap_or(false);
         if is_stack {
-            let stack: &NSStackView =
-                unsafe { &*(Retained::as_ptr(&parent) as *const NSStackView) };
-            // Use addView:inGravity: with top/leading gravity for consistent packing
-            unsafe {
-                let _: () = objc2::msg_send![stack, addView: &*child, inGravity: 1i64];
+            // A move must detach from the previous arranged-view list without
+            // remove_child's disposal cleanup (which deactivates width/height).
+            let previous = PARENT_MAP.with(|parents| parents.borrow().get(&child_handle).copied());
+            if let Some((old_handle, _)) = previous {
+                if let Some(old_view) = get_widget(old_handle) {
+                    let old_stack =
+                        unsafe { &*(Retained::as_ptr(&old_view) as *const NSStackView) };
+                    old_stack.removeView(&child);
+                    refresh_stack_parent_map(old_handle, old_stack);
+                }
             }
-            // Track parent-child for re-attachment after hide/show
-            PARENT_MAP.with(|m| {
-                m.borrow_mut()
-                    .insert(child_handle, (parent_handle, index as usize));
-            });
+            child.removeFromSuperview();
+            let stack = unsafe { &*(Retained::as_ptr(&parent) as *const NSStackView) };
+            let count = stack.viewsInGravity(NSStackViewGravity::Top).len();
+            let index = index.max(0) as usize;
+            stack.insertView_atIndex_inGravity(&child, index.min(count), NSStackViewGravity::Top);
+            refresh_stack_parent_map(parent_handle, stack);
         } else if zstack::is_zstack(parent_handle) {
             zstack::add_child(parent_handle, child_handle);
         } else {
@@ -530,17 +553,8 @@ pub fn add_child(parent_handle: i64, child_handle: i64) {
             // Safety: we verified the type with isKindOfClass
             let stack: &NSStackView =
                 unsafe { &*(Retained::as_ptr(&parent) as *const NSStackView) };
-            let index = stack.arrangedSubviews().len();
-            // Use addView:inGravity: with Top/Leading gravity (1) so children
-            // pack tightly from the top (VStack) or leading edge (HStack)
-            // instead of defaulting to center gravity area.
-            unsafe {
-                let _: () = objc2::msg_send![stack, addView: &*child, inGravity: 1i64];
-            }
-            // Track parent-child for re-attachment after hide/show
-            PARENT_MAP.with(|m| {
-                m.borrow_mut().insert(child_handle, (parent_handle, index));
-            });
+            let count = stack.viewsInGravity(NSStackViewGravity::Top).len();
+            add_child_at(parent_handle, child_handle, count as i64);
         } else if zstack::is_zstack(parent_handle) {
             zstack::add_child(parent_handle, child_handle);
         } else {
@@ -573,6 +587,10 @@ pub fn remove_child(parent_handle: i64, child_handle: i64) {
 
         // Clean up metadata maps
         cleanup_widget_maps(&handles_to_clean);
+        if is_stack {
+            let stack = unsafe { &*(Retained::as_ptr(&parent) as *const NSStackView) };
+            refresh_stack_parent_map(parent_handle, stack);
+        }
     }
 }
 
@@ -601,31 +619,22 @@ pub fn set_overlay_frame(handle: i64, x: f64, y: f64, w: f64, h: f64) {
     }
 }
 
-/// Reorder a child within an NSStackView by moving from one index to another.
+/// Reorder a child within a stack, preserving gravity and hidden-view positions.
 pub fn reorder_child(parent_handle: i64, from_index: i64, to_index: i64) {
     if let Some(parent) = get_widget(parent_handle) {
-        let is_stack = if let Some(cls) = AnyClass::get(c"NSStackView") {
-            parent.isKindOfClass(cls)
-        } else {
-            false
-        };
-
+        let is_stack = AnyClass::get(c"NSStackView")
+            .map(|class| parent.isKindOfClass(class))
+            .unwrap_or(false);
         if is_stack {
-            let stack: &NSStackView =
-                unsafe { &*(Retained::as_ptr(&parent) as *const NSStackView) };
-            let subviews = stack.arrangedSubviews();
-            let count = subviews.len();
-            let fi = from_index as usize;
-            let ti = to_index as usize;
-            if fi < count && ti < count {
-                let child: *const NSView =
-                    unsafe { objc2::msg_send![&subviews, objectAtIndex: fi] };
-                let child_ref: &NSView = unsafe { &*child };
-                stack.removeArrangedSubview(child_ref);
-                unsafe {
-                    let _: () =
-                        objc2::msg_send![stack, insertArrangedSubview: child_ref, atIndex: ti];
-                }
+            let stack = unsafe { &*(Retained::as_ptr(&parent) as *const NSStackView) };
+            let views = stack.viewsInGravity(NSStackViewGravity::Top);
+            let from = from_index as usize;
+            let to = to_index as usize;
+            if from < views.len() && to < views.len() && from != to {
+                let child = views.objectAtIndex(from);
+                stack.removeView(&child);
+                stack.insertView_atIndex_inGravity(&child, to, NSStackViewGravity::Top);
+                refresh_stack_parent_map(parent_handle, stack);
             }
         }
     }

crates/perry-ui-macos/tests/native_widget_order.rs

@@ -0,0 +1,89 @@
+#[cfg(target_os = "macos")]
+fn main() {
+    use objc2::rc::Retained;
+    use objc2_app_kit::{NSApplication, NSStackView, NSView};
+    use objc2_foundation::MainThreadMarker;
+    use perry_runtime as _;
+    use perry_ui_macos::widgets;
+
+    fn children(handle: i64) -> Vec<usize> {
+        let view = widgets::get_widget(handle).unwrap();
+        let stack = unsafe { &*(Retained::as_ptr(&view) as *const NSStackView) };
+        stack
+            .arrangedSubviews()
+            .iter()
+            .map(|v| Retained::as_ptr(&v) as usize)
+            .collect()
+    }
+    fn ptr(handle: i64) -> usize {
+        Retained::as_ptr(&widgets::get_widget(handle).unwrap()) as usize
+    }
+
+    if std::env::args().any(|arg| arg == "--list") {
+        println!("native_widget_order: test");
+        return;
+    }
+    let mtm = MainThreadMarker::new().expect("native widget test runs on the main thread");
+    let _app = NSApplication::sharedApplication(mtm);
+    let parent = widgets::vstack::create(0.0);
+    let other = widgets::hstack::create(0.0);
+    let a = widgets::spacer::create();
+    let b = widgets::spacer::create();
+    let c = widgets::spacer::create();
+    widgets::add_child(parent, a);
+    widgets::add_child(parent, b);
+    widgets::add_child_at(parent, c, 1);
+    assert_eq!(
+        children(parent),
+        vec![ptr(a), ptr(c), ptr(b)],
+        "indexed insertion must affect native order"
+    );
+
+    widgets::add_child_at(parent, a, 2);
+    assert_eq!(children(parent), vec![ptr(c), ptr(b), ptr(a)]);
+    widgets::set_width(b, 80.0);
+    widgets::add_child_at(other, b, 0);
+    assert_eq!(children(parent), vec![ptr(c), ptr(a)]);
+    assert_eq!(children(other), vec![ptr(b)]);
+    let b_view = widgets::get_widget(b).unwrap();
+    assert!(
+        b_view
+            .constraints()
+            .iter()
+            .any(|constraint| constraint.constant() == 80.0 && constraint.isActive()),
+        "moving a widget preserves its width constraint"
+    );
+
+    widgets::add_child_at(parent, b, -1);
+    assert_eq!(children(parent), vec![ptr(b), ptr(c), ptr(a)]);
+    assert!(children(other).is_empty());
+    widgets::reorder_child(parent, 0, 2);
+    assert_eq!(children(parent), vec![ptr(c), ptr(a), ptr(b)]);
+
+    // Simulate a stack-detached hidden child, then exercise the cached position
+    // used by set_hidden. Reordering must update that position for every child.
+    let parent_view = widgets::get_widget(parent).unwrap();
+    let stack = unsafe { &*(Retained::as_ptr(&parent_view) as *const NSStackView) };
+    let a_view: Retained<NSView> = widgets::get_widget(a).unwrap();
+    stack.removeArrangedSubview(&a_view);
+    a_view.removeFromSuperview();
+    widgets::set_hidden(a, false);
+    assert_eq!(children(parent), vec![ptr(c), ptr(a), ptr(b)]);
+    widgets::remove_child(parent, c);
+    stack.removeArrangedSubview(&a_view);
+    a_view.removeFromSuperview();
+    widgets::set_hidden(a, false);
+    assert_eq!(
+        children(parent),
+        vec![ptr(a), ptr(b)],
+        "removal refreshes surviving cached positions"
+    );
+    widgets::add_child_at(parent, c, i64::MAX);
+    assert_eq!(children(parent), vec![ptr(a), ptr(b), ptr(c)]);
+    println!(
+        "PASS native widget ordering, reparenting, retained constraints, and hidden reattachment"
+    );
+}
+
+#[cfg(not(target_os = "macos"))]
+fn main() {}

crates/perry-ui-windows/src/ffi/widget_layout_extras.rs

@@ -143,7 +143,9 @@ pub extern "C" fn perry_ui_stack_set_distribution(handle: i64, distribution: f64
 }
 
 #[no_mangle]
-pub extern "C" fn perry_ui_widget_reorder_child(_parent: i64, _child: i64, _index: i64) {}
+pub extern "C" fn perry_ui_widget_reorder_child(parent: i64, from: f64, to: f64) {
+    widgets::reorder_child(parent, from as i64, to as i64);
+}
 
 // perry_debug_trace_init and perry_debug_trace_init_done are provided by perry_runtime
 

crates/perry-ui-windows/src/widgets/mod.rs

@@ -679,6 +679,30 @@ pub fn add_child_at(parent_handle: i64, child_handle: i64, index: i64) {
     crate::app::request_layout();
 }
 
+/// Move an existing child without changing its native window or layout metadata.
+pub fn reorder_child(parent_handle: i64, from_index: i64, to_index: i64) {
+    if parent_handle <= 0 {
+        return;
+    }
+    let changed = WIDGETS.with(|widgets| {
+        let mut widgets = widgets.borrow_mut();
+        let Some(parent) = widgets.get_mut((parent_handle - 1) as usize) else {
+            return false;
+        };
+        let from = from_index as usize;
+        let to = to_index as usize;
+        if from >= parent.children.len() || to >= parent.children.len() || from == to {
+            return false;
+        }
+        let child = parent.children.remove(from);
+        parent.children.insert(to, child);
+        true
+    });
+    if changed {
+        crate::app::request_layout();
+    }
+}
+
 /// Remove a specific child from a parent container.
 pub fn remove_child(parent_handle: i64, child_handle: i64) {
     // Remove from children list

packages/perry-solid/.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+*.log
+out