fix(iced): scope tab release fallback

Author: charliek

crates/roost-iced/src/app.rs

@@ -3857,6 +3857,10 @@ impl App {
         );
     }
 
+    pub(crate) fn has_tab_drag_preview(&self) -> bool {
+        self.tab_drag_preview.is_some()
+    }
+
     pub(crate) fn tab_strip_event(&mut self, event: TabStripEvent) {
         match event {
             TabStripEvent::Started {

crates/roost-iced/src/main.rs

@@ -214,7 +214,7 @@ fn update(app: &mut App, message: Message) -> Task<Message> {
 }
 
 fn view(app: &App) -> iced::Element<'_, Message> {
-    tab_reorder::ReleaseBoundary::new(app.view()).into()
+    tab_reorder::ReleaseBoundary::new(app.view(), app.has_tab_drag_preview()).into()
 }
 
 fn subscription(_app: &App) -> Subscription<Message> {

crates/roost-iced/src/tab_reorder.rs

@@ -13,31 +13,37 @@ use crate::Message;
 const DRAG_THRESHOLD: f32 = 8.0;
 
 /// Provides a same-event root release fallback after direct child ownership.
-/// The boundary delegates without changing capture, then publishes even when a
-/// reflowed scrollable withheld the event from the tab strip.
+/// The boundary delegates without changing capture, then publishes for an
+/// application-owned preview even when a reflowed scrollable withheld the
+/// event from the tab strip.
 pub(crate) struct ReleaseBoundary<'a> {
     content: Element<'a, Message>,
+    enabled: bool,
 }
 
 impl<'a> ReleaseBoundary<'a> {
-    pub(crate) fn new(content: impl Into<Element<'a, Message>>) -> Self {
+    pub(crate) fn new(content: impl Into<Element<'a, Message>>, enabled: bool) -> Self {
         Self {
             content: content.into(),
+            enabled,
         }
     }
 }
 
 fn release_after_child<Message>(
     event: &Event,
     shell: &mut Shell<'_, Message>,
+    enabled: bool,
     release: impl FnOnce() -> Message,
     update_child: impl FnOnce(&mut Shell<'_, Message>),
 ) {
     update_child(shell);
-    if matches!(
-        event,
-        Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left))
-    ) {
+    if enabled
+        && matches!(
+            event,
+            Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left))
+        )
+    {
         tracing::debug!("Iced root observed left-button release");
         shell.publish(release());
     }
@@ -95,6 +101,7 @@ impl Widget<Message, iced::Theme, iced::Renderer> for ReleaseBoundary<'_> {
         release_after_child(
             event,
             shell,
+            self.enabled,
             || Message::TabPointerReleased,
             |shell| {
                 content.as_widget_mut().update(
@@ -709,6 +716,7 @@ mod tests {
             release_after_child(
                 &release,
                 &mut shell,
+                true,
                 || "root",
                 |shell| {
                     shell.publish("child");
@@ -726,6 +734,7 @@ mod tests {
             release_after_child(
                 &release,
                 &mut shell,
+                true,
                 || "root",
                 |shell| {
                     shell.publish("ignored child");
@@ -735,6 +744,40 @@ mod tests {
         };
         assert_eq!(messages, ["ignored child", "root"]);
         assert_eq!(status, iced::event::Status::Ignored);
+
+        messages.clear();
+        let status = {
+            let mut shell = Shell::new(&mut messages);
+            release_after_child(
+                &release,
+                &mut shell,
+                false,
+                || "root",
+                |shell| {
+                    shell.publish("disabled child");
+                    shell.capture_event();
+                },
+            );
+            shell.event_status()
+        };
+        assert_eq!(messages, ["disabled child"]);
+        assert_eq!(status, iced::event::Status::Captured);
+
+        messages.clear();
+        let motion = Event::Mouse(mouse::Event::CursorMoved {
+            position: Point::new(10.0, 10.0),
+        });
+        let mut shell = Shell::new(&mut messages);
+        release_after_child(
+            &motion,
+            &mut shell,
+            true,
+            || "root",
+            |shell| {
+                shell.publish("motion child");
+            },
+        );
+        assert_eq!(messages, ["motion child"]);
     }
 
     #[test]

docs/development/iced-poc-plan.md

@@ -2413,9 +2413,10 @@ making press ownership stable across preview reflow.
 
 The scrollable parent can also withhold the release from the child strip
 entirely. A transparent widget at the application root must therefore delegate
-the event, then unconditionally publish a same-event release fallback even if a
-child captured it. Unlike a runtime-event subscription, this preserves causal
-ordering: an asynchronously delayed release can never settle a later gesture.
+the event, then publish a same-event release fallback for an application-owned
+preview even if a child captured it. Unlike a runtime-event subscription, this
+preserves causal ordering: an asynchronously delayed release can never settle a
+later gesture. Ordinary terminal releases do not create application messages.
 When the strip receives release, its pre-child commit is queued first; when the
 scrollable withholds release, the root fallback remains. The application port
 settles only the matching generation-stamped preview and reuses the same