@effindomv2/fui-rs 0.1.17 → 0.1.18

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fui-rs"
-version = "0.1.17"
+version = "0.1.18"
 edition = "2021"
 license = "AGPL-3.0-only OR LicenseRef-EffinDom-Commercial"
 

package/README.md

@@ -74,6 +74,75 @@ fui_app!(FlexBox, build_page);
 | Browser file/fetch/worker bridges | Available |
 | Host services/events generator support | Available |
 
+## Recycled virtual-list rows
+
+`VirtualList` creates a fixed retained row pool. Use `item_template` once to
+construct typed row state, then update that state from `on_bind_item` whenever a
+pool slot is assigned a new item index:
+
+```rust
+struct ContactRow {
+    name: TextNode,
+}
+
+let contacts = virtual_list(10_000, 28.0)
+    .item_template(|container| {
+        let name = text("");
+        container.child(&name);
+        ContactRow { name }
+    });
+contacts.on_bind_item(|row, index| {
+    row.name.text(format!("Contact {index}"));
+});
+```
+
+The template is not rerun while scrolling. Do not key recycled rows by pointer
+or create controls inside `on_bind_item`.
+
+## Scrollbar styling
+
+Apply common scrollbar chrome without leaving fluent `ScrollBox` construction:
+
+```rust
+let content = scroll_box().scrollbar_style(
+    ScrollBarStyle::new()
+        .track_width(10.0)
+        .thumb_width(7.0)
+        .thumb_corner_radius(3.5),
+);
+```
+
+Use `vertical_scrollbar()` or `horizontal_scrollbar()` afterward for an
+axis-specific override.
+
+## Host-event lifetime
+
+Generated `on_*` host-event functions return `HostEventSubscription`. Retain
+the guard for exactly as long as the handler should remain active; dropping it
+unsubscribes automatically. Replacing a handler is generation-safe, so dropping
+an older guard cannot remove its replacement.
+
+## Worker entrypoints
+
+Enable the `worker-runtime` feature, implement `Default + WorkerJob`, and let
+the SDK emit resumable entries plus the shared callback-buffer ABI:
+
+```rust
+use fui::prelude::*;
+
+#[derive(Default)]
+struct PrimeJob {
+    state: WorkerJobState,
+}
+
+impl WorkerJob for PrimeJob {
+    fn state(&mut self) -> &mut WorkerJobState { &mut self.state }
+    fn run(&mut self) { self.complete("done"); }
+}
+
+fui_worker!(primeWorker => PrimeJob);
+```
+
 ## Architecture
 
 FUI-RS builds Rust retained UI objects into the EffinDom v2 runtime through the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effindomv2/fui-rs",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "private": false,
   "license": "AGPL-3.0-only OR LicenseRef-EffinDom-Commercial",
   "description": "EffinDom v2 Rust frontend framework SDK and host generators",

package/scripts/hostgen/rust-host-events.ts

@@ -38,9 +38,9 @@ function rustValueType(type: HostServiceTypeName): string {
 
 function callbackType(args: readonly HostServiceTypeName[]): string {
   if (args.length === 0) {
-    return "Box<dyn Fn()>";
+    return "Rc<dyn Fn()>";
   }
-  return `Box<dyn Fn(${args.map((arg) => rustValueType(arg)).join(", ")})>`;
+  return `Rc<dyn Fn(${args.map((arg) => rustValueType(arg)).join(", ")})>`;
 }
 
 function emitExportArgs(args: readonly HostServiceTypeName[]): string {
@@ -125,7 +125,21 @@ export async function generateRustHostEventsFile(
     "#![allow(dead_code)]",
     "#![allow(non_snake_case)]",
     "",
-    "use std::cell::RefCell;",
+    "use fui::HostEventSubscription;",
+    "use std::cell::{Cell, RefCell};",
+    "use std::rc::Rc;",
+    "",
+    "thread_local! {",
+    "    static NEXT_HOST_EVENT_SUBSCRIPTION_ID: Cell<u64> = const { Cell::new(1) };",
+    "}",
+    "",
+    "fn next_host_event_subscription_id() -> u64 {",
+    "    NEXT_HOST_EVENT_SUBSCRIPTION_ID.with(|next| {",
+    "        let id = next.get();",
+    "        next.set(id.wrapping_add(1).max(1));",
+    "        id",
+    "    })",
+    "}",
     "",
   ];
   methods.forEach((method) => {
@@ -133,36 +147,52 @@ export async function generateRustHostEventsFile(
     const callbackTy = callbackType(method.args);
     lines.push("thread_local! {");
     lines.push(
-      `    static ${handlerName.toUpperCase()}_HANDLER: RefCell<Option<${callbackTy}>> = const { RefCell::new(None) };`,
+      `    static ${handlerName.toUpperCase()}_HANDLER: RefCell<Option<(u64, ${callbackTy})>> = const { RefCell::new(None) };`,
     );
     lines.push("}");
     lines.push("");
     lines.push(
-      `pub fn on_${handlerName}(callback: impl Fn(${method.args.map((arg) => rustValueType(arg)).join(", ")}) + 'static) {`,
+      `pub fn on_${handlerName}(callback: impl Fn(${method.args.map((arg) => rustValueType(arg)).join(", ")}) + 'static) -> HostEventSubscription {`,
     );
+    lines.push("    let subscription_id = next_host_event_subscription_id();");
     lines.push(
-      `    ${handlerName.toUpperCase()}_HANDLER.with(|slot| *slot.borrow_mut() = Some(Box::new(callback)));`,
+      `    ${handlerName.toUpperCase()}_HANDLER.with(|slot| *slot.borrow_mut() = Some((subscription_id, Rc::new(callback))));`,
     );
+    lines.push("    HostEventSubscription::new(move || {");
+    lines.push(`        ${handlerName.toUpperCase()}_HANDLER.with(|slot| {`);
+    lines.push("            let should_clear = slot.borrow().as_ref().is_some_and(|(id, _)| *id == subscription_id);");
+    lines.push("            if should_clear {");
+    lines.push("                *slot.borrow_mut() = None;");
+    lines.push("            }");
+    lines.push("        });");
+    lines.push("    })");
     lines.push("}");
     lines.push("");
     lines.push(`pub fn clear_${handlerName}() {`);
     lines.push(`    ${handlerName.toUpperCase()}_HANDLER.with(|slot| *slot.borrow_mut() = None);`);
     lines.push("}");
     lines.push("");
+    const hasPointerArgs = method.args.some((type) =>
+      type === "string" || type === "bytes" || type.endsWith("_array")
+    );
+    if (hasPointerArgs) {
+      lines.push("/// # Safety");
+      lines.push("/// Pointer arguments must reference readable WASM memory for their declared lengths.");
+    }
     lines.push("#[no_mangle]");
-    lines.push(`pub extern "C" fn ${method.exportName}(${emitExportArgs(method.args)}) {`);
-    lines.push(`    ${handlerName.toUpperCase()}_HANDLER.with(|slot| {`);
-    lines.push("        let handler = slot.borrow();");
-    lines.push("        let Some(callback) = handler.as_ref() else {");
-    lines.push("            return;");
-    lines.push("        };");
+    lines.push(`pub ${hasPointerArgs ? "unsafe " : ""}extern "C" fn ${method.exportName}(${emitExportArgs(method.args)}) {`);
+    lines.push(`    let callback = ${handlerName.toUpperCase()}_HANDLER.with(|slot| {`);
+    lines.push("        slot.borrow().as_ref().map(|(_, callback)| callback.clone())");
+    lines.push("    });");
+    lines.push("    let Some(callback) = callback else {");
+    lines.push("        return;");
+    lines.push("    };");
     lines.push(...emitDecodedArgs(method.args));
     if (method.args.length === 0) {
       lines.push("        callback();");
     } else {
       lines.push(`        callback(${method.args.map((_arg, index) => `arg${String(index)}`).join(", ")});`);
     }
-    lines.push("    });");
     lines.push("}");
     lines.push("");
   });

package/src/app.rs

@@ -102,6 +102,12 @@ pub struct ApplicationRegistration {
     build_page_fn: Rc<dyn Fn() -> FlexBox>,
 }
 
+impl Default for ApplicationRegistration {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl ApplicationRegistration {
     pub fn new() -> Self {
         Self {
@@ -318,6 +324,7 @@ impl Node for NodeRefMount {
     fn build_self(&self) {}
 }
 
+#[cfg(not(feature = "worker-runtime"))]
 #[no_mangle]
 pub extern "C" fn __flushRenders() {
     Application::flush_renders();

package/src/assets.rs

@@ -332,7 +332,7 @@ pub fn release_svg_asset(svg_id: u32) {
     }
     let remaining = SVG_REF_COUNTS.with(|ref_counts| decrement_ref_count(ref_counts, svg_id));
     let pinned = PINNED_SVG_IDS.with(|ids| ids.borrow().contains(&svg_id));
-    if remaining > 0 || remaining < 0 || pinned {
+    if remaining != 0 || pinned {
         return;
     }
     let url = get_svg_record(svg_id).borrow().url.clone();
@@ -352,7 +352,7 @@ pub fn release_texture_asset(texture_id: u32) {
     let remaining =
         TEXTURE_REF_COUNTS.with(|ref_counts| decrement_ref_count(ref_counts, texture_id));
     let pinned = PINNED_TEXTURE_IDS.with(|ids| ids.borrow().contains(&texture_id));
-    if remaining > 0 || remaining < 0 || pinned {
+    if remaining != 0 || pinned {
         return;
     }
     let url = get_texture_record(texture_id).borrow().url.clone();

package/src/bindings/ui.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::too_many_arguments)]
+
 use crate::ffi;
 use crate::ffi::{GridUnit, ImageSamplingKind};
 

package/src/bridge_callbacks.rs

@@ -105,25 +105,27 @@ pub fn persisted_restore_count() -> u32 {
     PERSIST_RESTORE_COUNT.with(Cell::get)
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_on_viewport_changed(width: f32, height: f32) {
     ui::resize_window(width, height);
     viewport::set_viewport_size(width, height);
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_on_frame(timestamp_ms: f64) {
     frame_signal::set_frame_time(timestamp_ms);
     animation::tick_animations(timestamp_ms);
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_route_changed(route_ptr: *const u8, route_len: u32) {
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `route_ptr` must be null for an empty route or point to `route_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_route_changed(route_ptr: *const u8, route_len: u32) {
     let route = read_utf8(route_ptr, route_len);
     CURRENT_ROUTE.with(|slot| slot.replace(route));
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_on_scroll(
     handle: u64,
     offset_x: f32,
@@ -155,25 +157,25 @@ pub extern "C" fn __fui_on_scroll(
     );
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_can_show_context_menu(handle: u64) -> bool {
     context_menu_manager::can_show_for_handle(handle)
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_on_context_menu(handle: u64, x: f32, y: f32) {
     LAST_CONTEXT_MENU.with(|slot| slot.replace(Some(ContextMenuRequest { handle, x, y })));
     let shown = context_menu_manager::show_for_current_selection(handle, x, y);
     CONTEXT_MENU_VISIBLE.with(|visible| visible.set(shown));
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_hide_active_context_menu() {
     context_menu_manager::hide_active_menu();
     CONTEXT_MENU_VISIBLE.with(|visible| visible.set(false));
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_on_font_loaded(font_id: u32) {
     LAST_FONT_LOADED.with(|slot| slot.set(Some(font_id)));
     assets::on_font_loaded(font_id);
@@ -182,7 +184,7 @@ pub extern "C" fn __fui_on_font_loaded(font_id: u32) {
     crate::frame_scheduler::mark_needs_commit();
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_on_svg_loaded(svg_id: u32, width: f32, height: f32) {
     LAST_SVG_LOADED.with(|slot| {
         slot.replace(Some(AssetReady {
@@ -194,8 +196,10 @@ pub extern "C" fn __fui_on_svg_loaded(svg_id: u32, width: f32, height: f32) {
     assets::on_svg_loaded(svg_id, width, height);
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_svg_failed(svg_id: u32, error_ptr: *const u8, error_len: u32) {
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `error_ptr` must be null for an empty message or point to `error_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_svg_failed(svg_id: u32, error_ptr: *const u8, error_len: u32) {
     let error = read_utf8(error_ptr, error_len);
     LAST_SVG_FAILED.with(|slot| {
         slot.replace(Some(AssetFailure {
@@ -206,7 +210,7 @@ pub extern "C" fn __fui_on_svg_failed(svg_id: u32, error_ptr: *const u8, error_l
     assets::on_svg_failed(svg_id, error);
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_on_texture_loaded(texture_id: u32, width: f32, height: f32) {
     LAST_TEXTURE_LOADED.with(|slot| {
         slot.replace(Some(AssetReady {
@@ -218,8 +222,14 @@ pub extern "C" fn __fui_on_texture_loaded(texture_id: u32, width: f32, height: f
     assets::on_texture_loaded(texture_id, width, height);
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_on_texture_failed(texture_id: u32, error_ptr: *const u8, error_len: u32) {
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `error_ptr` must be null for an empty message or point to `error_len` readable bytes.
+pub unsafe extern "C" fn __fui_on_texture_failed(
+    texture_id: u32,
+    error_ptr: *const u8,
+    error_len: u32,
+) {
     let error = read_utf8(error_ptr, error_len);
     LAST_TEXTURE_FAILED.with(|slot| {
         slot.replace(Some(AssetFailure {
@@ -230,13 +240,13 @@ pub extern "C" fn __fui_on_texture_failed(texture_id: u32, error_ptr: *const u8,
     assets::on_texture_failed(texture_id, error);
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_capture_persisted_ui_state() {
     PERSIST_CAPTURE_COUNT.with(|count| count.set(count.get() + 1));
     Application::capture_persisted_ui_state();
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_restore_persisted_ui_state() {
     PERSIST_RESTORE_COUNT.with(|count| count.set(count.get() + 1));
     Application::restore_persisted_ui_state();

package/src/controls/button.rs

@@ -374,6 +374,7 @@ impl LabeledControlTextStyle for Button {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn sync_button_visual_state(
     root: &FlexBox,
     presenter: &Rc<RefCell<Rc<dyn ButtonPresenter>>>,

package/src/controls/checkbox.rs

@@ -409,6 +409,7 @@ impl CheckboxEventTarget {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn apply_checkbox_state(
     presenter: &Rc<RefCell<Rc<dyn CheckboxIndicatorPresenter>>>,
     weak_root: &Rc<WeakNodeRef>,

package/src/controls/combobox.rs

@@ -28,6 +28,9 @@ use crate::{app, frame_scheduler, ThemeBindable};
 use std::cell::{Cell, RefCell};
 use std::rc::{Rc, Weak};
 
+type ComboBoxChangedCallback = Rc<dyn Fn(crate::controls::ComboBoxChangedEventArgs<ComboBoxItem>)>;
+type ComboBoxTextChangedCallback = Rc<dyn Fn(TextChangedEventArgs)>;
+
 const DEFAULT_PANEL_BACKGROUND_BLUR_SIGMA: f32 = 10.0;
 
 fn strings_equal_ignore_case(left: &str, right: &str) -> bool {
@@ -211,9 +214,8 @@ struct ComboBoxShared {
     popup_panel_background_blur_overridden: Cell<bool>,
     suppress_editor_changed: Cell<bool>,
     last_auto_complete_text_value: RefCell<String>,
-    changed_callback:
-        RefCell<Option<Rc<dyn Fn(crate::controls::ComboBoxChangedEventArgs<ComboBoxItem>)>>>,
-    text_changed_callback: RefCell<Option<Rc<dyn Fn(TextChangedEventArgs)>>>,
+    changed_callback: RefCell<Option<ComboBoxChangedCallback>>,
+    text_changed_callback: RefCell<Option<ComboBoxTextChangedCallback>>,
     theme_guard: RefCell<Option<SubscriptionGuard>>,
     focus_visibility_guard: RefCell<Option<SubscriptionGuard>>,
 }

package/src/controls/dropdown.rs

@@ -26,6 +26,8 @@ use crate::ThemeBindable;
 use std::cell::{Cell, RefCell};
 use std::rc::{Rc, Weak};
 
+type DropdownChangedCallback = Rc<dyn Fn(DropdownChangedEventArgs<DropdownItem>)>;
+
 const DEFAULT_PANEL_BACKGROUND_BLUR_SIGMA: f32 = 10.0;
 
 fn is_activation_key(event: &KeyEventArgs) -> bool {
@@ -110,7 +112,7 @@ struct DropdownShared {
     popup_panel_background_blur_sigma_value: Cell<f32>,
     popup_panel_color_overridden: Cell<bool>,
     popup_panel_background_blur_overridden: Cell<bool>,
-    changed_callback: RefCell<Option<Rc<dyn Fn(DropdownChangedEventArgs<DropdownItem>)>>>,
+    changed_callback: RefCell<Option<DropdownChangedCallback>>,
     theme_guard: RefCell<Option<SubscriptionGuard>>,
     focus_visibility_guard: RefCell<Option<SubscriptionGuard>>,
 }

package/src/controls/internal/pressable_labeled_control.rs

@@ -372,6 +372,7 @@ impl WeakPressableLabeledControl {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn sync_base_theme_parts(
     root: &FlexBox,
     label_node: &TextCore,

package/src/controls/internal/text_input_core.rs

@@ -25,6 +25,10 @@ use std::rc::{Rc, Weak};
 
 const UNLIMITED_TEXT_LENGTH: i32 = i32::MAX;
 
+type TextChangedCallback = Rc<dyn Fn(TextChangedEventArgs)>;
+type SelectionChangedCallback = Rc<dyn Fn(SelectionChangedEventArgs)>;
+type FocusChangedCallback = Rc<dyn Fn(FocusChangedEventArgs)>;
+
 #[derive(Clone, Copy)]
 pub(crate) struct TextInputProfile {
     max_lines: i32,
@@ -140,9 +144,9 @@ pub struct TextInputCore {
     selection_start_bytes: Cell<u32>,
     selection_end_bytes: Cell<u32>,
     focused_state: Cell<bool>,
-    changed_callback: RefCell<Option<Rc<dyn Fn(TextChangedEventArgs)>>>,
-    selection_changed_callback: RefCell<Option<Rc<dyn Fn(SelectionChangedEventArgs)>>>,
-    focus_changed_callback: RefCell<Option<Rc<dyn Fn(FocusChangedEventArgs)>>>,
+    changed_callback: RefCell<Option<TextChangedCallback>>,
+    selection_changed_callback: RefCell<Option<SelectionChangedCallback>>,
+    focus_changed_callback: RefCell<Option<FocusChangedCallback>>,
     theme_guard: RefCell<Option<SubscriptionGuard>>,
     focus_visibility_guard: RefCell<Option<SubscriptionGuard>>,
 }

package/src/controls/radio_button.rs

@@ -383,6 +383,7 @@ impl RadioEventTarget {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn apply_radio_checked(
     presenter: &Rc<RefCell<Rc<dyn RadioIndicatorPresenter>>>,
     weak_root: &Rc<WeakNodeRef>,

package/src/controls/slider.rs

@@ -673,6 +673,7 @@ impl SliderEventTarget {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn create_slider_visual_state(
     value: f32,
     min: f32,

package/src/controls/switch.rs

@@ -324,6 +324,7 @@ impl SwitchEventTarget {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn apply_switch_checked(
     presenter: &Rc<RefCell<Rc<dyn SwitchIndicatorPresenter>>>,
     weak_root: &Rc<WeakNodeRef>,

package/src/controls/tests.rs

@@ -213,7 +213,9 @@ fn press_enter(node_ref: &crate::node::NodeRef) {
 }
 
 fn key_event(event_type: KeyEventType, key: &str, modifiers: u32) -> bool {
-    event::__fui_on_key_event(event_type as u32, key.as_ptr(), key.len() as u32, modifiers)
+    unsafe {
+        event::__fui_on_key_event(event_type as u32, key.as_ptr(), key.len() as u32, modifiers)
+    }
 }
 
 fn blur(node_ref: &crate::node::NodeRef) {
@@ -1407,7 +1409,7 @@ fn retained_dropdown_keeps_theme_subscription_after_wrapper_drop() {
     let mut theme = current_theme();
     theme.colors.surface = 0x135724FF;
     theme.colors.border = 0x246813FF;
-    theme.colors.text_primary = 0xABCDEFff;
+    theme.colors.text_primary = 0xABCDEFFF;
     use_custom_theme(theme.clone());
     let calls = ffi::test::take_calls();
 
@@ -4212,7 +4214,9 @@ fn text_input_text_replaced_event_updates_value_and_emits_changed() {
         })
         .expect("expected text input editor node id to be applied");
 
-    event::__fui_on_text_replaced(editor_handle, 0, 0, b"hello".as_ptr(), 5);
+    unsafe {
+        event::__fui_on_text_replaced(editor_handle, 0, 0, b"hello".as_ptr(), 5);
+    }
 
     assert_eq!(input.value(), "hello");
     assert_eq!(&*last_text.borrow(), "hello");
@@ -4474,7 +4478,9 @@ fn text_input_text_replacement_clamps_selection_bytes_from_char_positions() {
         })
         .expect("expected text input editor node id to be applied");
 
-    event::__fui_on_text_replaced(editor_handle, 1, 5, std::ptr::null(), 0);
+    unsafe {
+        event::__fui_on_text_replaced(editor_handle, 1, 5, std::ptr::null(), 0);
+    }
 
     assert_eq!(input.value(), "ab");
     assert_eq!(input.selection_start(), 0);
@@ -4660,16 +4666,22 @@ fn text_area_readonly_disabled_placeholder_and_line_height_follow_text_input_cor
             if *handle == editor_handle && (*line_height - 26.0).abs() < f32::EPSILON
     )));
 
-    event::__fui_on_text_replaced(editor_handle, 0, 0, b"Hello\nworld".as_ptr(), 11);
+    unsafe {
+        event::__fui_on_text_replaced(editor_handle, 0, 0, b"Hello\nworld".as_ptr(), 11);
+    }
     assert_eq!(input.value(), "Hello\nworld");
 
-    event::__fui_on_text_changed(editor_handle, b"alpha\nbeta".as_ptr(), 10);
+    unsafe {
+        event::__fui_on_text_changed(editor_handle, b"alpha\nbeta".as_ptr(), 10);
+    }
     assert_eq!(input.value(), "alpha\nbeta");
     event::__fui_on_selection_changed(editor_handle, 6, 10);
     assert_eq!(input.selection_start(), 6);
     assert_eq!(input.selection_end(), 10);
 
-    event::__fui_on_text_replaced(editor_handle, 0, 11, std::ptr::null(), 0);
+    unsafe {
+        event::__fui_on_text_replaced(editor_handle, 0, 11, std::ptr::null(), 0);
+    }
     assert_eq!(input.value(), "");
     Application::unmount();
 }

package/src/debug.rs

@@ -2,6 +2,7 @@ use crate::event::{self, PointerType};
 use crate::ffi::{self, KeyEventType, PointerEventType};
 use crate::node::NodeHandle;
 
+#[allow(clippy::too_many_arguments)]
 pub fn pointer_event(
     event_type: PointerEventType,
     handle: NodeHandle,
@@ -42,7 +43,7 @@ pub fn key_event(event_type: KeyEventType, key: &str, modifiers: u32) -> bool {
     event::dispatch_key_event(event_type, key.to_string(), modifiers)
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_debug_pointer_event(
     event_type: u32,
     handle: u64,
@@ -74,8 +75,10 @@ pub extern "C" fn __fui_debug_pointer_event(
     );
 }
 
-#[no_mangle]
-pub extern "C" fn __fui_debug_key_event(
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
+/// # Safety
+/// `key_ptr` must be null for an empty key or point to `key_len` readable bytes.
+pub unsafe extern "C" fn __fui_debug_key_event(
     event_type: u32,
     key_ptr: *const u8,
     key_len: u32,
@@ -97,12 +100,12 @@ pub extern "C" fn __fui_debug_key_event(
     );
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_debug_focus_changed(handle: u64, focused: bool) {
     event::dispatch_focus_changed(NodeHandle::from_raw(handle), focused);
 }
 
-#[no_mangle]
+#[cfg_attr(not(feature = "worker-runtime"), no_mangle)]
 pub extern "C" fn __fui_debug_scroll(
     handle: u64,
     offset_x: f32,

package/src/drag_drop.rs

@@ -399,9 +399,7 @@ fn finish_session(
     notify_target_leave: bool,
 ) {
     let target = with_state(|state| {
-        let Some(active) = state.active_session.as_ref() else {
-            return None;
-        };
+        let active = state.active_session.as_ref()?;
         if !Rc::ptr_eq(&active.inner, &session.inner) {
             return None;
         }

package/src/drawing.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::too_many_arguments)]
+
 use crate::ffi;
 use crate::image_sampling::ImageSampling;
 use crate::logger::error;
@@ -78,6 +80,12 @@ pub struct Path {
     resource: Rc<PathResource>,
 }
 
+impl Default for Path {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Path {
     pub fn new() -> Self {
         let id = unsafe { ffi::fui_path_create() };