Sync agent instructions from main

crates/oa-desktop/src/app.rs

@@ -10,10 +10,7 @@ mod hosted;
 mod reference_authoring;
 #[cfg(test)]
 mod review_navigation_tests;
-#[cfg(test)]
-mod scenario_details_tests;
 mod scenario_diagram;
-mod scenario_spacing;
 pub(crate) mod source_rename;
 mod source_symbols;
 #[cfg(test)]
@@ -1274,9 +1271,6 @@ impl App {
         ])
     }
     pub fn update(&mut self, message: Message) -> Task<Message> {
-        if let Message::ScenarioCanvas(behavior::scenario::CanvasEvent::Spacing(event)) = &message {
-            return self.scenario_spacing(*event);
-        }
         // Reject stale rename intents before camera/reveal reconciliation or
         // source interaction can disturb a newer navigation destination.
         if let Message::SourceRename(event) = &message
@@ -1304,21 +1298,6 @@ impl App {
             {
                 return Task::none();
             }
-            // A retained Details button may belong to an earlier selection or
-            // canvas epoch. Refuse it before retiring any newer reveal or draft.
-            if let behavior::scenario::CanvasEvent::Properties(_, id) = event
-                && (self.scenario_context() != Some(captured)
-                    || self.selected != *id
-                    || !self.project().contains(*id)
-                    || !behavior::scenario::properties_target(self.project(), captured, *id)
-                    || self.behavior.has_pending()
-                    || self.draft_dirty()
-                    || self.source_dirty()
-                    || self.source_rename.open()
-                    || !behavior::canvas_workspace::keyboard_enabled(self))
-            {
-                return Task::none();
-            }
         }
         if let Message::BehaviorControl(intent) = &message
             && behavior::canvas_workspace::Scope::current(self).is_none_or(|scope| {
@@ -1351,7 +1330,6 @@ impl App {
                 | Message::TopologyCanvas(crate::behavior::topology::CanvasEvent::Camera(..))
         );
         let before = self.camera_boundary();
-        let spacing_selected = self.selected;
         let task = self.update_inner(message);
         if window_resized && let Some((_, _, epoch)) = &mut self.pending_diagram_reveal {
             *epoch = self.canvas_epoch;
@@ -1366,13 +1344,6 @@ impl App {
         {
             self.diagram_navigation_focus = None;
         }
-        if (self.camera_boundary() != before
-            || self.selected != spacing_selected
-            || !self.spacing_enabled())
-            && self.behavior.scenario.cancel_spacing()
-        {
-            self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
-        }
         if !camera && self.camera_boundary() != before {
             self.camera_epoch = self.camera_epoch.wrapping_add(1);
             self.camera_boundary_epoch = self.canvas_epoch;
@@ -1407,9 +1378,6 @@ impl App {
             Message::ScenarioCanvas(Scenario::Camera(c, lifetime, Camera::Focus))
                 if valid_scenario(*c) && *lifetime == scope.epoch =>
             {
-                if self.behavior.scenario.cancel_spacing() {
-                    self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
-                }
                 return canvas_workspace::focus_task(scope, Camera::Focus);
             }
             Message::TopologyCanvas(Process::Camera(c, lifetime, Camera::Focus))
@@ -1435,9 +1403,6 @@ impl App {
             _ => return Task::none(),
         }
         let task = self.update(message);
-        if self.behavior.scenario.cancel_spacing() {
-            self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
-        }
         // Reapplying Fit or a tool also ends a held gesture. Focus is stamped
         // after the action, for Iced's final-view ordering.
         if self.camera_epoch == scope.epoch {
@@ -2007,9 +1972,6 @@ impl App {
                     {
                         return Task::none();
                     }
-                    if self.behavior.scenario.cancel_spacing() {
-                        self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
-                    }
                     match input {
                         Event::Focus
                         | Event::Traverse(_)
@@ -2043,11 +2005,6 @@ impl App {
                         if checked_owner(self.project(), requested) != Some(context.scenario) {
                             return Task::none();
                         }
-                        // An explicitly selected current view record follows
-                        // the arrangement picker, as with the Diagram picker.
-                        // Independent occurrence/lifeline selection stays put.
-                        let follow_view = matches!(context.representation,
-                            Representation::Saved { diagram } if self.selected == diagram);
                         if !self.apply() {
                             return Task::none();
                         }
@@ -2065,15 +2022,7 @@ impl App {
                             },
                             other => other,
                         };
-                        if self.enter_scenario_representation(requested) && follow_view {
-                            self.selected = match requested {
-                                Representation::Saved { diagram } => diagram,
-                                // Automatic has no Diagram record; its Scenario
-                                // owner is the corresponding inspectable target.
-                                Representation::Derived { owner } => owner,
-                            };
-                            self.refresh_draft();
-                        }
+                        self.enter_scenario_representation(requested);
                     }
                     CanvasEvent::Focus(_) => {
                         self.behavior.scenario.toggle_focus();
@@ -2083,13 +2032,6 @@ impl App {
                         self.behavior.scenario.toggle_shelf(shelf);
                         self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
                     }
-                    CanvasEvent::Properties(_, _) => {
-                        // The checked action opens the current record only: no
-                        // select()/Apply side effect or representation change.
-                        self.behavior.scenario.show_properties();
-                        self.inspector_tab = crate::navigation::InspectorTab::Properties;
-                        self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
-                    }
                     CanvasEvent::Zoom(_, scale) => {
                         let mut state = std::mem::take(&mut self.behavior.scenario);
                         if state.camera_zoom(self.project(), context.scenario, scale) {

crates/oa-desktop/src/app/diagram_usages/tests.rs

@@ -1029,9 +1029,10 @@ fn repeated_preview_arrows_select_the_relation_and_highlight_the_exact_caller_li
         let camera = app.behavior.topology.camera_boundary();
         if call == calls[1]
             && let Some((previous_call, previous)) = &previous_camera
-            && *previous_call != call
         {
-            assert!(&camera != previous);
+            if *previous_call != call {
+                assert!(&camera != previous);
+            }
         }
         if let Some(epoch) = previous_epoch {
             assert_ne!(app.canvas_epoch, epoch);
@@ -1374,7 +1375,7 @@ fn whole_surface_camera_fits_huge_extent_while_target_camera_remains_readable()
     };
     let viewport = iced::Size::new(800., 500.);
     let (zoom, pan) = usage::camera_for(&Target::Whole, bounds, viewport);
-    assert!((0.0001..0.05).contains(&zoom));
+    assert!(zoom < 0.05 && zoom >= 0.0001);
     assert!(bounds.width * zoom <= viewport.width - 64. + 0.01);
     assert!(bounds.height * zoom <= viewport.height - 64. + 0.01);
     assert!((bounds.center_x() * zoom + pan.x - viewport.width / 2.).abs() < 0.01);

crates/oa-desktop/src/app/scenario_details_tests.rs

@@ -1,281 +0,0 @@
-//! Actual arrangement selection and current-record Details admission.
-use super::*;
-use crate::behavior::canvas_workspace::tests::Mounted;
-use crate::behavior::scenario::{CanvasEvent, Context, Shelf};
-use crate::behavior::scenario_layout::Representation;
-use iced::{Point, Size, advanced::widget};
-
-const FIXTURE: &str = include_str!("diagram_usages/tests/saved_scenario.arcadia");
-
-fn id(app: &App, alias: &str) -> Id {
-    app.project()
-        .identities()
-        .into_iter()
-        .find(|(_, name)| *name == alias)
-        .unwrap()
-        .0
-}
-fn setup() -> (App, Id, Id, Id) {
-    let mut app = App::with_project(oa_core::language::parse(FIXTURE).unwrap());
-    let a = id(&app, "incident_readable");
-    let b = id(&app, "incident_wide");
-    let owner = id(&app, "incident_response");
-    let _ = app.update(Message::Select(owner));
-    let _ = app.update(Message::Page(Page::Behavior));
-    choose(&mut app, Representation::Saved { diagram: a });
-    let _ = app.update(Message::Select(a));
-    app.window_size = Size::new(1440., 1000.);
-    (app, a, b, owner)
-}
-fn send(app: &mut App, event: impl FnOnce(Context) -> CanvasEvent) {
-    let context = app.scenario_context().unwrap();
-    let _ = app.update(Message::ScenarioCanvas(event(context)));
-}
-fn choose(app: &mut App, representation: Representation) {
-    send(app, |context| {
-        CanvasEvent::Representation(context, representation)
-    });
-}
-fn model_state(app: &App) -> (u64, bool, bool, bool) {
-    (
-        app.document.revision(),
-        app.document.dirty(),
-        app.document.can_undo(),
-        app.document.can_redo(),
-    )
-}
-
-#[tokio::test]
-async fn actual_arrangement_picker_follows_selected_saved_record_and_opens_b_properties() {
-    let (mut app, a, b, _) = setup();
-    let mut mounted = Mounted::new(&mut app).await;
-    let snapshot = app.document.snapshot();
-    let before = model_state(&app);
-    let captured = app.scenario_context().unwrap();
-    let picker = mounted.geometry(&app).bounds("scenario-arrangement-picker");
-    assert!(
-        app.window_size.height - (picker.y + picker.height) > picker.y,
-        "fixture has room for Iced's menu below the actual picker"
-    );
-    assert_eq!(app.selected, a);
-    mounted.click(&mut app, picker.center()).await;
-    // iced_widget 0.14.2 overlay/menu.rs uses default line height plus
-    // vertical padding for each row. The real workspace orders Automatic,
-    // then the fixture's A/B/C Diagram IDs. Select B from the actual overlay.
-    let row_height =
-        f32::from(iced::advanced::text::LineHeight::default().to_absolute(12.into())) + 10.;
-    let b_row = Point::new(
-        picker.center_x(),
-        picker.y + picker.height + row_height * 2.5,
-    );
-    assert!(b_row.y < app.window_size.height);
-    let events = mounted.click(&mut app, b_row).await;
-    assert!(events.iter().any(|event| matches!(event,
-        Message::ScenarioCanvas(CanvasEvent::Representation(context, Representation::Saved { diagram }))
-        if *context == captured && *diagram == b)), "must exercise the actual arrangement callback");
-    assert_eq!(app.selected, b);
-    assert_eq!(app.draft.as_ref().unwrap().original, b);
-    assert_eq!(
-        app.draft.as_ref().unwrap().value["name"],
-        "B - Incident review negative and far"
-    );
-    assert_eq!(app.active_diagram, Some(b));
-    assert_eq!(
-        app.scenario_context().unwrap().representation,
-        Representation::Saved { diagram: b }
-    );
-    assert_ne!(app.scenario_context().unwrap().visit, captured.visit);
-
-    send(&mut app, CanvasEvent::Focus);
-    send(&mut app, |context| {
-        CanvasEvent::Shelf(context, Shelf::Selection)
-    });
-    mounted.settle(&mut app).await;
-    let geometry = mounted.geometry(&app);
-    let (details, offset) = geometry.scrolls[&widget::Id::new("scenario-details")];
-    let point = geometry.bounds("scenario-properties").center() - offset;
-    assert!(details.contains(point));
-    let events = mounted.click(&mut app, point).await;
-    assert!(events.iter().any(|event| matches!(event,
-        Message::ScenarioCanvas(CanvasEvent::Properties(_, selected)) if *selected == b)));
-    mounted.settle(&mut app).await;
-    let geometry = mounted.geometry(&app);
-    let (inspector, offset) = geometry.scrolls[&widget::Id::new("inspector")];
-    assert!(
-        geometry
-            .text_inputs
-            .iter()
-            .any(|bounds| inspector.contains(bounds.center() - offset)),
-        "current B Properties must expose an actual editable field"
-    );
-    assert!(!app.behavior.scenario.focused());
-    assert!(
-        !geometry
-            .scrolls
-            .contains_key(&widget::Id::new("scenario-details"))
-    );
-    assert_eq!(
-        app.inspector_tab,
-        crate::navigation::InspectorTab::Properties
-    );
-    assert_eq!(app.selected, b);
-    assert_eq!(app.draft.as_ref().unwrap().original, b);
-    assert!(Arc::ptr_eq(&snapshot, &app.document.snapshot()));
-    assert_eq!(app.project(), &snapshot.decoded.project);
-    assert_eq!(app.document.bundle(), &snapshot.bundle);
-    assert_eq!(model_state(&app), before);
-}
-
-#[test]
-fn arrangement_change_preserves_independent_semantic_and_foreign_view_selection() {
-    for alias in [
-        "initial_report",
-        "reporter",
-        "incident_response",
-        "incident_repair",
-    ] {
-        let (mut app, _, b, _) = setup();
-        let selected = id(&app, alias);
-        let _ = app.update(Message::Select(selected));
-        let snapshot = app.document.snapshot();
-        let before = model_state(&app);
-        choose(&mut app, Representation::Saved { diagram: b });
-        assert_eq!(app.selected, selected, "independent selection {alias}");
-        assert_eq!(app.draft.as_ref().unwrap().original, selected);
-        assert_eq!(app.active_diagram, Some(b));
-        assert!(Arc::ptr_eq(&snapshot, &app.document.snapshot()));
-        assert_eq!(app.document.bundle(), &snapshot.bundle);
-        assert_eq!(model_state(&app), before);
-        if alias == "incident_repair" {
-            assert!(!behavior::scenario::properties_target(
-                app.project(),
-                app.scenario_context().unwrap(),
-                selected
-            ));
-        }
-    }
-}
-
-#[test]
-fn arrangement_follows_view_record_to_automatic_owner_but_not_owner_back_to_saved() {
-    let (mut app, _, b, owner) = setup();
-    let snapshot = app.document.snapshot();
-    let before = model_state(&app);
-    choose(&mut app, Representation::Derived { owner });
-    assert_eq!(app.selected, owner);
-    assert_eq!(app.draft.as_ref().unwrap().original, owner);
-    assert_eq!(app.active_diagram, None);
-    assert!(behavior::scenario::properties_target(
-        app.project(),
-        app.scenario_context().unwrap(),
-        owner
-    ));
-    choose(&mut app, Representation::Saved { diagram: b });
-    assert_eq!(
-        app.selected, owner,
-        "Scenario owner is now independent semantic selection"
-    );
-    assert_eq!(app.draft.as_ref().unwrap().original, owner);
-    assert_eq!(app.active_diagram, Some(b));
-    assert!(Arc::ptr_eq(&snapshot, &app.document.snapshot()));
-    assert_eq!(app.document.bundle(), &snapshot.bundle);
-    assert_eq!(model_state(&app), before);
-}
-
-#[test]
-fn arrangement_applies_only_the_old_view_draft_then_follows_b_with_one_undo() {
-    let (mut app, a, b, _) = setup();
-    let snapshot = app.document.snapshot();
-    let mut expected = app.project().clone();
-    expected.diagrams.get_mut(&a).unwrap().name = "Reviewed A".into();
-    let revision = app.document.revision();
-    let _ = app.update(Message::Field("/name".into(), "Reviewed A".into()));
-    choose(&mut app, Representation::Saved { diagram: b });
-    assert_eq!(app.project(), &expected);
-    assert_eq!(app.selected, b);
-    assert_eq!(app.draft.as_ref().unwrap().original, b);
-    assert!(!app.draft_dirty());
-    assert_eq!(app.document.revision(), revision + 1);
-    let accepted = app.document.snapshot();
-    let _ = app.update(Message::Undo);
-    assert_eq!(app.project(), &snapshot.decoded.project);
-    assert_eq!(app.document.bundle(), &snapshot.bundle);
-    assert!(!app.document.can_undo() && app.document.can_redo());
-    let _ = app.update(Message::Redo);
-    assert_eq!(app.project(), &expected);
-    assert_eq!(app.document.bundle(), &accepted.bundle);
-    assert!(app.document.can_undo() && !app.document.can_redo());
-}
-
-#[test]
-fn same_arrangement_uuid_edit_follows_the_reidentified_record_and_round_trips_source() {
-    let (mut app, a, _, _) = setup();
-    let snapshot = app.document.snapshot();
-    let replacement = Id::parse_str("70200000-0000-4000-8000-000000000099").unwrap();
-    let mut expected = app.project().clone();
-    let mut diagram = expected.diagrams.remove(&a).unwrap();
-    diagram.id = replacement;
-    expected.diagrams.insert(replacement, diagram);
-    let _ = app.update(Message::Field("/id".into(), replacement.to_string()));
-    choose(&mut app, Representation::Saved { diagram: a });
-    assert_eq!(app.project(), &expected);
-    assert_eq!(app.selected, replacement);
-    assert_eq!(app.draft.as_ref().unwrap().original, replacement);
-    assert_eq!(app.active_diagram, Some(replacement));
-    assert_eq!(
-        app.scenario_context().unwrap().representation,
-        Representation::Saved {
-            diagram: replacement
-        }
-    );
-    let accepted = app.document.snapshot();
-    let _ = app.update(Message::Undo);
-    assert_eq!(app.project(), &snapshot.decoded.project);
-    assert_eq!(app.document.bundle(), &snapshot.bundle);
-    assert!(!app.document.can_undo() && app.document.can_redo());
-    let _ = app.update(Message::Redo);
-    assert_eq!(app.project(), &expected);
-    assert_eq!(app.document.bundle(), &accepted.bundle);
-    assert!(!app.document.can_redo());
-}
-
-#[test]
-fn invalid_draft_and_stale_arrangement_preserve_selection_inputs_and_accepted_state() {
-    let (mut app, a, b, _) = setup();
-    let old = app.scenario_context().unwrap();
-    let snapshot = app.document.snapshot();
-    let before = model_state(&app);
-    let _ = app.update(Message::Field("/id".into(), "not-a-uuid".into()));
-    let draft_value = app.draft.as_ref().unwrap().value.clone();
-    choose(&mut app, Representation::Saved { diagram: b });
-    assert_eq!(app.selected, a);
-    assert_eq!(app.active_diagram, Some(a));
-    assert_eq!(
-        app.scenario_context().unwrap().representation,
-        old.representation
-    );
-    assert_eq!(app.draft.as_ref().unwrap().value, draft_value);
-    assert_eq!(app.draft.as_ref().unwrap().inputs["/id"].raw, "not-a-uuid");
-    assert!(app.draft_dirty());
-    assert!(Arc::ptr_eq(&snapshot, &app.document.snapshot()));
-    assert_eq!(model_state(&app), before);
-    let _ = app.update(Message::RevertProperties);
-    choose(&mut app, Representation::Saved { diagram: b });
-    let current = app.scenario_context().unwrap();
-    let _ = app.update(Message::Field("/name".into(), "Retained B input".into()));
-    let selected = app.selected;
-    let _ = app.update(Message::ScenarioCanvas(CanvasEvent::Representation(
-        old,
-        Representation::Saved { diagram: a },
-    )));
-    assert_eq!(app.selected, selected);
-    assert_eq!(app.active_diagram, Some(b));
-    assert_eq!(app.scenario_context().unwrap().visit, current.visit);
-    assert_eq!(
-        app.draft.as_ref().unwrap().inputs["/name"].raw,
-        "Retained B input"
-    );
-    assert!(Arc::ptr_eq(&snapshot, &app.document.snapshot()));
-    assert_eq!(app.document.bundle(), &snapshot.bundle);
-    assert_eq!(model_state(&app), before);
-}

crates/oa-desktop/src/app/scenario_spacing.rs

@@ -1,88 +0,0 @@
-//! Admit spacing packets before ordinary navigation can retire a newer reveal.
-use super::*;
-use behavior::scenario::spacing::{Event, controller::Finish};
-
-#[cfg(test)]
-mod tests;
-
-impl App {
-    pub(super) fn spacing_enabled(&self) -> bool {
-        self.pending_diagram_reveal.is_none()
-            && !self.behavior.has_pending()
-            && !self.draft_dirty()
-            && !self.source_dirty()
-            && !self.source_rename.open()
-            && behavior::canvas_workspace::keyboard_enabled(self)
-    }
-
-    pub(super) fn scenario_spacing(&mut self, event: Event) -> Task<Message> {
-        let stamp = event.stamp();
-        if self.scenario_context() != Some(stamp.context) || self.camera_epoch != stamp.camera_epoch
-        {
-            return Task::none();
-        }
-        let state = &self.behavior.scenario;
-        let matches =
-            state.spacing_token() == Some(event.token()) && state.spacing_stamp() == Some(stamp);
-        if match event {
-            Event::Begin { token, .. } => token.is_nil() || state.spacing_token().is_some(),
-            _ => !matches,
-        } {
-            return Task::none();
-        }
-        if matches!(event, Event::Cancel { .. }) || !self.spacing_enabled() {
-            if self.behavior.scenario.cancel_spacing() {
-                self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
-            }
-            return Task::none();
-        }
-        match event {
-            Event::Begin { .. } => {
-                let mut state = std::mem::take(&mut self.behavior.scenario);
-                let result = state.begin_spacing(self.project(), event);
-                self.behavior.scenario = state;
-                if result.is_err() {
-                    self.status = "The drag could not start in this view. Try again.".into();
-                }
-            }
-            Event::Move { screen, .. } => self.behavior.scenario.move_spacing(screen),
-            Event::Finish { screen, .. } => {
-                let finished = self.behavior.scenario.finish_spacing(screen);
-                // Retire queued packets even for zero motion or a refused finish.
-                self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
-                match finished {
-                    Ok(Finish::Click(target)) => self.select(target),
-                    Ok(Finish::Noop) => {}
-                    Ok(Finish::Commit {
-                        command,
-                        selected,
-                        scale,
-                        pan,
-                    }) => {
-                        // Document prepares and writes the source candidate before
-                        // committing its snapshot. Failure leaves camera/selection
-                        // and source/history at their accepted values.
-                        match self.document.execute(*command) {
-                            Ok(_) => {
-                                self.selected = selected;
-                                self.selected_node = None;
-                                self.diagram_navigation_focus = None;
-                                self.behavior.scenario.accept_spacing_camera(scale, pan);
-                                self.sync();
-                                self.status = "Scenario spacing updated.".into();
-                            }
-                            Err(error) => self.status = format!("Spacing was not applied: {error}"),
-                        }
-                    }
-                    Err(_) => {
-                        self.status =
-                            "That position cannot be applied. The saved arrangement is unchanged."
-                                .into()
-                    }
-                }
-            }
-            Event::Cancel { .. } => unreachable!(),
-        }
-        Task::none()
-    }
-}

crates/oa-desktop/src/app/scenario_spacing/tests.rs

@@ -1,272 +0,0 @@
-use super::*;
-use behavior::scenario::{
-    CanvasEvent,
-    spacing::{
-        Target,
-        controller::tests::{fixture, packet},
-    },
-};
-use iced::{Point, Size, Vector};
-
-fn setup() -> (App, Id, Id) {
-    let (document, owner, diagram, lane, message) = fixture();
-    let mut app = App::with_project(document.project().clone());
-    let _ = app.update(Message::Select(owner));
-    let _ = app.update(Message::Diagram(Choice {
-        id: diagram,
-        label: "Saved".into(),
-    }));
-    let c = app.scenario_context().unwrap();
-    let _ = app.update(Message::ScenarioCanvas(CanvasEvent::Viewport(
-        c,
-        Size::new(900., 600.),
-    )));
-    assert!(app.spacing_enabled());
-    (app, lane, message)
-}
-fn begin(app: &mut App, target: Target) -> (Event, Point, f32) {
-    let event = packet(
-        app.project(),
-        &app.behavior.scenario,
-        app.scenario_context().unwrap(),
-        app.camera_epoch,
-        target,
-    );
-    let Event::Begin {
-        press_screen,
-        scale,
-        ..
-    } = event
-    else {
-        unreachable!()
-    };
-    let _ = app.update(Message::ScenarioCanvas(CanvasEvent::Spacing(event)));
-    assert_eq!(app.behavior.scenario.spacing_token(), Some(event.token()));
-    (event, press_screen, scale)
-}
-fn send(app: &mut App, event: Event) {
-    let _ = app.update(Message::ScenarioCanvas(CanvasEvent::Spacing(event)));
-}
-fn move_to(app: &mut App, begin: Event, screen: Point) {
-    send(
-        app,
-        Event::Move {
-            stamp: begin.stamp(),
-            token: begin.token(),
-            screen,
-        },
-    );
-}
-fn finish(app: &mut App, begin: Event, screen: Point) {
-    send(
-        app,
-        Event::Finish {
-            stamp: begin.stamp(),
-            token: begin.token(),
-            screen,
-        },
-    );
-}
-
-#[test]
-fn same_batch_preview_is_immutable_and_one_commit_undo_redo_has_exact_source_parity() {
-    let (mut app, lane, _) = setup();
-    let original = app.document.snapshot();
-    let source = app.source_workspace.bundle();
-    let selected = app.selected;
-    let epoch = app.canvas_epoch;
-    let (event, start, scale) = begin(&mut app, Target::Lane(lane));
-    move_to(&mut app, event, start + Vector::new(40., 300.));
-    assert_eq!(app.selected, selected);
-    assert_eq!(app.canvas_epoch, epoch);
-    assert_eq!(app.project(), &original.decoded.project);
-    assert_eq!(app.source_workspace.bundle(), source);
-    assert!(!app.document.can_undo() && !app.document.can_redo());
-    finish(&mut app, event, start + Vector::new(40., 300.));
-    assert_eq!(app.selected, lane);
-    assert!(app.document.can_undo() && !app.document.can_redo());
-    let accepted = app.document.snapshot();
-    assert_ne!(accepted.bundle, original.bundle);
-    let expected = behavior::scenario::spacing::controller::tests::expected(
-        &original.decoded.project,
-        match event.stamp().context.representation {
-            behavior::scenario_layout::Representation::Saved { diagram } => diagram,
-            _ => unreachable!(),
-        },
-        Target::Lane(lane),
-        40. / scale,
-    );
-    assert_eq!(app.project(), &expected);
-    let _ = app.update(Message::ShortcutUndo(false));
-    assert_eq!(app.project(), &original.decoded.project);
-    assert_eq!(app.document.bundle(), &original.bundle);
-    assert!(!app.document.can_undo() && app.document.can_redo());
-    let _ = app.update(Message::ShortcutUndo(true));
-    assert_eq!(app.project(), &accepted.decoded.project);
-    assert_eq!(app.document.bundle(), &accepted.bundle);
-}
-
-#[test]
-fn click_selects_but_crossed_return_and_cancel_preserve_selection_camera_and_history() {
-    let (mut app, lane, message) = setup();
-    let original = app.document.snapshot();
-    let camera = app.behavior.scenario.camera_boundary();
-    let (event, start, _) = begin(&mut app, Target::Message(message));
-    finish(&mut app, event, start + Vector::new(30., 2.));
-    assert_eq!(app.selected, message);
-    assert!(camera == app.behavior.scenario.camera_boundary());
-    for cancel in [false, true] {
-        let (event, start, _) = begin(&mut app, Target::Lane(lane));
-        move_to(&mut app, event, start + Vector::new(30., 0.));
-        if cancel {
-            send(
-                &mut app,
-                Event::Cancel {
-                    stamp: event.stamp(),
-                    token: event.token(),
-                },
-            );
-        } else {
-            finish(&mut app, event, start);
-        }
-        assert_eq!(app.selected, message);
-        assert!(camera == app.behavior.scenario.camera_boundary());
-        assert_eq!(app.document.bundle(), &original.bundle);
-        assert_eq!(app.project(), &original.decoded.project);
-        assert!(!app.document.can_undo() && !app.document.can_redo());
-    }
-}
-
-#[test]
-fn stale_finish_after_new_view_and_forged_token_are_inert_before_reveal_reconciliation() {
-    let (mut app, lane, _) = setup();
-    let (event, start, _) = begin(&mut app, Target::Lane(lane));
-    let held_epoch = app.canvas_epoch;
-    send(
-        &mut app,
-        Event::Finish {
-            stamp: event.stamp(),
-            token: Id::new_v4(),
-            screen: start + Vector::new(30., 0.),
-        },
-    );
-    assert_eq!(app.canvas_epoch, held_epoch);
-    assert_eq!(app.behavior.scenario.spacing_token(), Some(event.token()));
-    let owner = event.stamp().context.scenario;
-    let _ = app.update(Message::ScenarioCanvas(CanvasEvent::Representation(
-        event.stamp().context,
-        behavior::scenario_layout::Representation::Derived { owner },
-    )));
-    let current = app.scenario_context();
-    let epoch = app.canvas_epoch;
-    let original = app.document.snapshot();
-    finish(&mut app, event, start + Vector::new(50., 0.));
-    assert_eq!(app.scenario_context(), current);
-    assert_eq!(app.canvas_epoch, epoch);
-    assert!(app.behavior.scenario.spacing_token().is_none());
-    assert_eq!(app.document.bundle(), &original.bundle);
-}
-
-#[test]
-fn source_write_failure_cannot_commit_candidate_or_materialize_camera() {
-    let (mut app, lane, _) = setup();
-    let bundle = app.document.bundle().clone();
-    let mut limits = oa_core::source_project::ProjectLimits::default();
-    limits.model.max_source_bytes = bundle.files.values().map(String::len).sum();
-    app.document = Document::from_bundle(bundle, limits).unwrap();
-    app.sync();
-    let original = app.document.snapshot();
-    let selected = app.selected;
-    let camera = app.behavior.scenario.camera_boundary();
-    let (event, start, _) = begin(&mut app, Target::Lane(lane));
-    move_to(&mut app, event, start + Vector::new(40., 0.));
-    finish(&mut app, event, start + Vector::new(40., 0.));
-    assert!(
-        app.status.starts_with("Spacing was not applied:"),
-        "{}",
-        app.status
-    );
-    assert_eq!(app.selected, selected);
-    assert!(camera == app.behavior.scenario.camera_boundary());
-    assert_eq!(app.project(), &original.decoded.project);
-    assert_eq!(app.document.bundle(), &original.bundle);
-    assert!(!app.document.can_undo() && !app.document.can_redo());
-    assert!(app.behavior.scenario.spacing_token().is_none());
-}
-
-#[test]
-fn pending_semantic_draft_and_source_edit_cancel_and_reject_held_finish() {
-    for source in [false, true] {
-        let (mut app, lane, _) = setup();
-        let original = app.document.snapshot();
-        let selected = app.selected;
-        let (event, start, _) = begin(&mut app, Target::Lane(lane));
-        move_to(&mut app, event, start + Vector::new(30., 0.));
-        if source {
-            let _ = app.update(Message::SourceEdit(text_editor::Action::Edit(
-                text_editor::Edit::Insert(' '),
-            )));
-            assert!(app.source_dirty());
-        } else {
-            let _ = app.update(Message::Behavior(behavior::Event::Scenario(
-                behavior::scenario::Event::Start(
-                    event.stamp().context.scenario,
-                    behavior::scenario::Tool::Lifeline,
-                ),
-            )));
-            assert!(app.behavior.has_pending());
-        }
-        let draft = app.source_workspace.bundle();
-        assert!(app.behavior.scenario.spacing_token().is_none());
-        finish(&mut app, event, start + Vector::new(30., 0.));
-        assert_eq!(app.project(), &original.decoded.project);
-        assert_eq!(app.document.bundle(), &original.bundle);
-        assert_eq!(app.source_workspace.bundle(), draft);
-        assert_eq!(app.selected, selected);
-        assert!(!app.document.can_undo());
-    }
-}
-
-#[test]
-fn stale_finish_cannot_remove_new_same_view_deferred_reveal() {
-    let (mut app, lane, message) = setup();
-    let (event, start, _) = begin(&mut app, Target::Lane(lane));
-    let behavior::scenario_layout::Representation::Saved { diagram } =
-        event.stamp().context.representation
-    else {
-        unreachable!()
-    };
-    let _ = app.update(Message::RevealInDiagram(diagram, message));
-    assert!(app.pending_diagram_reveal.is_some());
-    let epoch = app.canvas_epoch;
-    let selected = app.selected;
-    let visit = app.pending_scenario_reveal_visit;
-    let original = app.document.snapshot();
-    finish(&mut app, event, start + Vector::new(50., 0.));
-    assert_eq!(app.canvas_epoch, epoch);
-    assert_eq!(app.pending_scenario_reveal_visit, visit);
-    assert!(app.pending_diagram_reveal.is_some());
-    assert_eq!(app.selected, selected);
-    assert_eq!(app.document.bundle(), &original.bundle);
-    assert!(!app.document.can_undo());
-}
-
-#[test]
-fn modal_open_cancels_preview_and_captured_begin_stays_retired_after_close() {
-    let (mut app, lane, _) = setup();
-    let original = app.document.snapshot();
-    let camera = app.behavior.scenario.camera_boundary();
-    let (event, start, _) = begin(&mut app, Target::Lane(lane));
-    move_to(&mut app, event, start + Vector::new(30., 0.));
-    let _ = app.update(Message::Delete);
-    assert!(app.delete_pending);
-    assert!(app.behavior.scenario.spacing_token().is_none());
-    finish(&mut app, event, start + Vector::new(30., 0.));
-    let _ = app.update(Message::CancelDelete);
-    send(&mut app, event);
-    assert!(app.behavior.scenario.spacing_token().is_none());
-    assert_eq!(app.project(), &original.decoded.project);
-    assert_eq!(app.document.bundle(), &original.bundle);
-    assert!(camera == app.behavior.scenario.camera_boundary());
-    assert!(!app.document.can_undo());
-}

crates/oa-desktop/src/behavior.rs

@@ -21,8 +21,6 @@ pub(crate) mod creation;
 mod form_session;
 pub(crate) mod scenario;
 mod scenario_activation;
-#[cfg(test)]
-mod scenario_hit_tests;
 // Pure saved-geometry bridge; workspace integration is a separate checkpoint.
 #[allow(dead_code)]
 pub(crate) mod scenario_layout;
@@ -684,7 +682,7 @@ mod scenario_scroll {
                         .collect::<Vec<_>>();
                     assert_eq!(
                         actual,
-                        vec![if !(2..4).contains(&change) {
+                        vec![if change < 2 || change >= 4 {
                             Vector::ZERO
                         } else {
                             Vector::new(0., 180.)
@@ -1163,27 +1161,8 @@ fn in_machine(p: &Project, id: Id, machine: Id) -> bool {
     false
 }
 
-/// Identifies the drawn primitive that won selection, not an authoring permission.
-/// In particular an activation and its message can share an occurrence UUID.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum SceneHitRole {
-    LifelineHeader,
-    MessageBody,
-    MessageLabel,
-    Activation,
-    LifecycleMarker,
-    LifelineGuide,
-    Box,
-    OtherLine,
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-struct SceneHit {
-    id: Id,
-    role: SceneHitRole,
-}
 struct BoxItem {
     id: Id,
-    role: SceneHitRole,
     rect: Rectangle,
     title: String,
     detail: String,
@@ -1216,7 +1195,6 @@ fn box_text_clip(
 
 struct Line {
     id: Id,
-    role: SceneHitRole,
     points: Vec<Point>,
     label: String,
     label_at: Point,
@@ -1242,7 +1220,6 @@ struct Scene {
     scale: f32,
     camera_pan: iced::Vector,
     interaction: Option<(scenario::Context, scenario::CanvasTool, bool)>,
-    spacing_stamp: Option<scenario::spacing::Stamp>,
     coordinate_input: bool,
     pending_placement: Option<(scenario::Slot, Option<Id>)>,
     lanes: BTreeMap<Id, f32>,
@@ -1271,10 +1248,6 @@ struct SequenceInput {
 }
 #[derive(Clone, Copy)]
 enum SequencePress {
-    Spacing {
-        stamp: scenario::spacing::Stamp,
-        token: Id,
-    },
     Occurrence {
         tool: scenario::Tool,
         slot: scenario::Slot,
@@ -1295,26 +1268,12 @@ enum SequencePress {
     },
 }
 impl SequenceInput {
-    fn cancel_spacing(&mut self) -> Option<Action<Message>> {
-        let cancel = match self.press {
-            Some(SequencePress::Spacing { stamp, token }) => Some(
-                Action::publish(Message::ScenarioCanvas(scenario::CanvasEvent::Spacing(
-                    scenario::spacing::Event::Cancel { stamp, token },
-                )))
-                .and_capture(),
-            ),
-            _ => None,
-        };
-        self.cancel();
-        cancel
-    }
     fn cancel(&mut self) {
         self.source = None;
         self.press = None;
     }
 }
 impl Scene {
-    #[cfg(test)]
     fn sequence(p: &Project, owner: Id, selected: Id) -> Self {
         Self::sequence_geometry(p, owner, selected, None, None)
     }
@@ -1334,7 +1293,6 @@ impl Scene {
             layout_origin: Point::ORIGIN,
             selected,
             interaction: None,
-            spacing_stamp: None,
             coordinate_input: true,
             pending_placement: None,
             lanes: BTreeMap::new(),
@@ -1492,7 +1450,6 @@ impl Scene {
                     0,
                     Line {
                         id,
-                        role: SceneHitRole::LifelineGuide,
                         points: vec![Point::new(x, 85.), Point::new(x, scene.size.height - 20.)],
                         label: String::new(),
                         label_at: Point::ORIGIN,
@@ -1502,11 +1459,6 @@ impl Scene {
             }
             scene.boxes.push(BoxItem {
                 id,
-                role: if scenario {
-                    SceneHitRole::LifelineHeader
-                } else {
-                    SceneHitRole::Box
-                },
                 rect: Rectangle::new(Point::new(x - 102., 15.), Size::new(204., 70.)),
                 title: if scenario {
                     format!("Lane · {name}")
@@ -1600,7 +1552,6 @@ impl Scene {
                         0,
                         BoxItem {
                             id: *id,
-                            role: SceneHitRole::Box,
                             rect,
                             title: format!("{operator:?} · {}", e.name),
                             detail: String::new(),
@@ -1612,7 +1563,6 @@ impl Scene {
                 OccurrenceBody::Branch { guard, .. } => {
                     self.boxes.push(BoxItem {
                         id: *id,
-                        role: SceneHitRole::Box,
                         rect: Rectangle::new(
                             Point::new(36. + depth as f32 * 10., *y),
                             Size::new(self.size.width - 85. - depth as f32 * 20., 43.),
@@ -1696,7 +1646,6 @@ impl Scene {
                         }
                         self.lines.push(Line {
                             id: *id,
-                            role: SceneHitRole::MessageBody,
                             points,
                             label: format!("{}. {kind}{}", index + 1, message_label),
                             label_at: Point::new(a.min(*b) + 12., *y - 26.),
@@ -1705,7 +1654,6 @@ impl Scene {
                     } else {
                         self.boxes.push(BoxItem {
                             id: *id,
-                            role: SceneHitRole::Box,
                             rect: Rectangle::new(
                                 Point::new(65., *y - 20.),
                                 Size::new(self.size.width - 130., 65.),
@@ -1728,7 +1676,6 @@ impl Scene {
                         .unwrap_or(180.);
                     self.boxes.push(BoxItem {
                         id: *id,
-                        role: SceneHitRole::Box,
                         rect: Rectangle::new(Point::new(x - 110., *y - 20.), Size::new(220., 70.)),
                         title: e.name.clone(),
                         detail: action
@@ -1741,7 +1688,6 @@ impl Scene {
                 OccurrenceBody::Control { kind } => {
                     self.boxes.push(BoxItem {
                         id: *id,
-                        role: SceneHitRole::Box,
                         rect: Rectangle::new(Point::new(65., *y - 20.), Size::new(240., 70.)),
                         title: format!("{kind:?} · {}", e.name),
                         detail: "Contextual process control".into(),
@@ -1752,7 +1698,6 @@ impl Scene {
                 OccurrenceBody::SequenceReference { sequence } => {
                     self.boxes.push(BoxItem {
                         id: *id,
-                        role: SceneHitRole::Box,
                         rect: Rectangle::new(Point::new(65., *y - 20.), Size::new(280., 70.)),
                         title: e.name.clone(),
                         detail: sequence
@@ -1765,7 +1710,6 @@ impl Scene {
                 OccurrenceBody::ScenarioUse { scenario, bindings } => {
                     self.boxes.push(BoxItem {
                         id: *id,
-                        role: SceneHitRole::Box,
                         rect: Rectangle::new(
                             Point::new(65., *y - 20.),
                             Size::new(self.size.width - 130., 70.),
@@ -1831,21 +1775,11 @@ impl Scene {
         ))
     }
     fn hit(&self, point: Point) -> Option<Id> {
-        self.hit_item(point).map(|hit| hit.id)
-    }
-
-    /// Preserve the semantic selection order and tolerance while retaining the
-    /// primitive's identity. Future spacing admission must also validate the
-    /// saved view, owner and core occurrence kind; a hit alone grants no edit.
-    fn hit_item(&self, point: Point) -> Option<SceneHit> {
         if !point.x.is_finite() || !point.y.is_finite() {
             return None;
         }
         if let Some(id) = self.lifecycle.marker_at(point) {
-            return Some(SceneHit {
-                id,
-                role: SceneHitRole::LifecycleMarker,
-            });
+            return Some(id);
         }
         self.boxes
             .iter()
@@ -1855,10 +1789,7 @@ impl Scene {
                     && b.rect.contains(point)
                     && (b.marker != Some(Kind::Occurrence) || point.y < b.rect.y + 38.)
             })
-            .map(|b| SceneHit {
-                id: b.id,
-                role: b.role,
-            })
+            .map(|b| b.id)
             .or_else(|| {
                 self.lines
                     .iter()
@@ -1868,51 +1799,36 @@ impl Scene {
                                 crate::diagram::distance_to_segment(point, p[0], p[1]) < 1.5
                             })
                     })
-                    .map(|line| SceneHit {
-                        id: line.id,
-                        role: line.role,
-                    })
+                    .map(|line| line.id)
             })
             .or_else(|| {
                 self.activations
                     .iter()
                     .rev()
                     .find(|b| b.rect.contains(point))
-                    .map(|b| SceneHit {
-                        id: b.call,
-                        role: SceneHitRole::Activation,
-                    })
+                    .map(|b| b.call)
             })
             .or_else(|| {
                 self.lines
                     .iter()
-                    .find(|line| !line.label.is_empty() && line.label_bounds().contains(point))
-                    .map(|line| SceneHit {
-                        id: line.id,
-                        role: if line.role == SceneHitRole::MessageBody {
-                            SceneHitRole::MessageLabel
-                        } else {
-                            SceneHitRole::OtherLine
-                        },
+                    .find(|line| {
+                        !line.label.is_empty()
+                            && Rectangle::new(
+                                line.label_at,
+                                Size::new(
+                                    (line.label.chars().count() as f32 * 6.8 + 8.).min(225.),
+                                    25.,
+                                ),
+                            )
+                            .contains(point)
                     })
+                    .map(|line| line.id)
             })
             // The generous message tolerance must not steal the exposed
             // shoulder of another call's execution when the view is zoomed out.
             .or_else(|| self.near_sequence_item(point))
-            .or_else(|| {
-                self.lifecycle
-                    .lane_at(point, self.scale)
-                    .map(|id| SceneHit {
-                        id,
-                        role: SceneHitRole::LifelineGuide,
-                    })
-            })
-            .or_else(|| {
-                self.lane_at(point).map(|id| SceneHit {
-                    id,
-                    role: SceneHitRole::LifelineGuide,
-                })
-            })
+            .or_else(|| self.lifecycle.lane_at(point, self.scale))
+            .or_else(|| self.lane_at(point))
             .or_else(|| {
                 self.lines
                     .iter()
@@ -1923,14 +1839,11 @@ impl Scene {
                                     < 8. / self.scale
                             })
                     })
-                    .map(|line| SceneHit {
-                        id: line.id,
-                        role: line.role,
-                    })
+                    .map(|line| line.id)
             })
     }
 
-    fn near_sequence_item(&self, point: Point) -> Option<SceneHit> {
+    fn near_sequence_item(&self, point: Point) -> Option<Id> {
         if !self.scale.is_finite() || self.scale <= 0. {
             return None;
         }
@@ -1944,32 +1857,17 @@ impl Scene {
                     .windows(2)
                     .map(|p| crate::diagram::distance_to_segment(point, p[0], p[1]))
                     .fold(f32::INFINITY, f32::min);
-                (
-                    SceneHit {
-                        id: line.id,
-                        role: line.role,
-                    },
-                    distance,
-                )
+                (line.id, distance)
             });
         // Compare broad message and lifecycle-marker tolerance together after
         // exact shapes, so dense minimum-Fit rows choose the nearer item.
         self.lifecycle
             .nearest_marker(point)
-            .map(|(id, distance)| {
-                (
-                    SceneHit {
-                        id,
-                        role: SceneHitRole::LifecycleMarker,
-                    },
-                    distance,
-                )
-            })
             .into_iter()
             .chain(messages)
             .filter(|(_, distance)| *distance <= 8. / self.scale)
-            .min_by(|a, b| a.1.total_cmp(&b.1).then_with(|| a.0.id.cmp(&b.0.id)))
-            .map(|(hit, _)| hit)
+            .min_by(|a, b| a.1.total_cmp(&b.1).then_with(|| a.0.cmp(&b.0)))
+            .map(|(id, _)| id)
     }
 }
 impl canvas::Program<Message> for Scene {
@@ -1997,33 +1895,15 @@ impl canvas::Program<Message> for Scene {
         // captured insertion slot belongs to the previous view, even if the
         // pointer itself did not move and the semantic context is unchanged.
         if state.bounds.is_some_and(|previous| previous != bounds) {
-            let cancelled = state.cancel_spacing();
+            state.cancel();
             state.pointer = None;
-            state.bounds = Some(bounds);
-            if cancelled.is_some() {
-                return cancelled;
-            }
         }
         state.bounds = Some(bounds);
-        if (!editable || !self.coordinate_input)
-            && let Some(cancelled) = state.cancel_spacing()
-        {
-            return Some(cancelled);
+        if !editable || !self.coordinate_input {
+            state.cancel();
         }
         // The viewport masks input outside its visible canvas bounds.
         let visible = cursor.position().is_some();
-        if !visible
-            && matches!(state.press, Some(SequencePress::Spacing { .. }))
-            && matches!(
-                event,
-                canvas::Event::Mouse(
-                    mouse::Event::CursorMoved { .. }
-                        | mouse::Event::ButtonReleased(mouse::Button::Left)
-                )
-            )
-        {
-            return state.cancel_spacing();
-        }
         if !visible
             && matches!(
                 event,
@@ -2042,7 +1922,7 @@ impl canvas::Program<Message> for Scene {
                         | SequencePress::Reorder { start, moved, .. } => {
                             *moved |= position.distance(*start) >= 3.
                         }
-                        SequencePress::Occurrence { .. } | SequencePress::Spacing { .. } => {}
+                        SequencePress::Occurrence { .. } => {}
                     }
                 }
                 mouse::Cursor::Available(*position)
@@ -2051,9 +1931,9 @@ impl canvas::Program<Message> for Scene {
             | canvas::Event::Window(iced::window::Event::Resized(_))
             | canvas::Event::Mouse(mouse::Event::CursorLeft)
             | canvas::Event::Window(iced::window::Event::Unfocused) => {
-                let cancelled = state.cancel_spacing();
+                state.cancel();
                 state.pointer = None;
-                return cancelled.or_else(|| Some(Action::request_redraw()));
+                return Some(Action::request_redraw());
             }
             canvas::Event::Mouse(
                 mouse::Event::ButtonPressed(_) | mouse::Event::ButtonReleased(_),
@@ -2066,9 +1946,8 @@ impl canvas::Program<Message> for Scene {
                 key: iced::keyboard::Key::Named(iced::keyboard::key::Named::Escape),
                 ..
             }) if state.source.is_some() || state.press.is_some() => {
-                return state
-                    .cancel_spacing()
-                    .or_else(|| Some(Action::request_redraw().and_capture()));
+                state.cancel();
+                return Some(Action::request_redraw().and_capture());
             }
             _ => cursor,
         };
@@ -2122,48 +2001,6 @@ impl canvas::Program<Message> for Scene {
                         });
                         return Some(Action::request_redraw().and_capture());
                     }
-                    if matches!(
-                        context.representation,
-                        scenario_layout::Representation::Saved { .. }
-                    ) {
-                        let hit = self.hit_item(point)?;
-                        let target = match hit.role {
-                            SceneHitRole::LifelineHeader => {
-                                Some(scenario::spacing::Target::Lane(hit.id))
-                            }
-                            SceneHitRole::MessageBody | SceneHitRole::MessageLabel => {
-                                Some(scenario::spacing::Target::Message(hit.id))
-                            }
-                            _ => None,
-                        };
-                        if let Some((target, stamp)) = target.zip(self.spacing_stamp)
-                            && stamp.context == context
-                        {
-                            let token = Id::new_v4();
-                            state.press = Some(SequencePress::Spacing { stamp, token });
-                            return Some(
-                                Action::publish(Message::ScenarioCanvas(CanvasEvent::Spacing(
-                                    scenario::spacing::Event::Begin {
-                                        stamp,
-                                        token,
-                                        target,
-                                        press_screen: cursor.position()?,
-                                        canvas_bounds: bounds,
-                                        scale: self.scale,
-                                        pan: self.camera_pan,
-                                    },
-                                )))
-                                .and_capture(),
-                            );
-                        }
-                        // Saved spacing never silently changes the shared Scenario order.
-                        return Some(
-                            Action::publish(Message::ScenarioCanvas(CanvasEvent::Select(
-                                context, hit.id,
-                            )))
-                            .and_capture(),
-                        );
-                    }
                     if let Some(occurrence) = self
                         .hit(point)
                         .filter(|id| self.rows.contains_key(id))
@@ -2193,22 +2030,6 @@ impl canvas::Program<Message> for Scene {
                 let press = state.press.take()?;
                 let context = context?;
                 match press {
-                    SequencePress::Spacing { stamp, token } => {
-                        state.source = None;
-                        let event = if world.is_some() {
-                            scenario::spacing::Event::Finish {
-                                stamp,
-                                token,
-                                screen: cursor.position()?,
-                            }
-                        } else {
-                            scenario::spacing::Event::Cancel { stamp, token }
-                        };
-                        return Some(
-                            Action::publish(Message::ScenarioCanvas(CanvasEvent::Spacing(event)))
-                                .and_capture(),
-                        );
-                    }
                     SequencePress::Occurrence {
                         tool: captured,
                         slot,
@@ -2300,18 +2121,6 @@ impl canvas::Program<Message> for Scene {
                 Some(Action::request_redraw().and_capture())
             }
             canvas::Event::Mouse(mouse::Event::CursorMoved { .. }) if context.is_some() => {
-                if let Some(SequencePress::Spacing { stamp, token }) = state.press {
-                    return Some(
-                        Action::publish(Message::ScenarioCanvas(CanvasEvent::Spacing(
-                            scenario::spacing::Event::Move {
-                                stamp,
-                                token,
-                                screen: cursor.position()?,
-                            },
-                        )))
-                        .and_capture(),
-                    );
-                }
                 Some(Action::request_redraw())
             }
             _ => None,
@@ -2514,10 +2323,6 @@ impl canvas::Program<Message> for Scene {
             if editable
                 && self.coordinate_input
                 && tool == scenario::CanvasTool::Select
-                && matches!(
-                    context.representation,
-                    scenario_layout::Representation::Derived { .. }
-                )
                 && let Some(handle) = self.reorder_handle()
             {
                 f.fill_rectangle(handle.position(), handle.size(), style::TEAL);

crates/oa-desktop/src/behavior/scenario.rs

@@ -6,7 +6,6 @@ use iced::widget::{Column, column, text_input};
 use std::{cell::RefCell, collections::BTreeSet};
 mod camera;
 pub(crate) mod focus;
-pub(crate) mod spacing;
 use super::scenario_layout::{
     Representation,
     presentation::{self, ScenarioPresentation},
@@ -18,14 +17,6 @@ mod workspace;
 pub(crate) use workspace::NAME_INPUT;
 pub use workspace::{Shelf, view};
 
-// A picker may select the Saved diagram record itself. Another view of the
-// same Scenario is not the property target of this displayed representation.
-pub(crate) fn properties_target(p: &Project, context: Context, id: Id) -> bool {
-    super::selected_behavior(p, id) == Some(context.scenario)
-        || matches!(context.representation, Representation::Saved { diagram } if diagram == id)
-            && presentation::checked_owner(p, context.representation) == Some(context.scenario)
-}
-
 #[cfg(test)]
 #[path = "scenario_operation_tests.rs"]
 mod operation_tests;
@@ -115,7 +106,6 @@ impl std::fmt::Display for CanvasTool {
 }
 #[derive(Debug, Clone)]
 pub enum CanvasEvent {
-    Spacing(spacing::Event),
     Scrolled(Context, ScrollArea, iced::Vector),
     Restored(Context, Id, ScrollArea, iced::Vector),
     Viewport(Context, Size),
@@ -124,7 +114,6 @@ pub enum CanvasEvent {
     Camera(Context, u64, super::canvas_workspace::Event),
     Focus(Context),
     Shelf(Context, Shelf),
-    Properties(Context, Id),
     OpenUse(Context, Id),
     Back(Context),
     Choose(Context, CanvasTool),
@@ -157,7 +146,6 @@ pub enum ScrollArea {
 impl CanvasEvent {
     pub fn context(&self) -> Context {
         match self {
-            Self::Spacing(event) => event.stamp().context,
             Self::Scrolled(context, _, _)
             | Self::Restored(context, ..)
             | Self::Viewport(context, _)
@@ -166,7 +154,6 @@ impl CanvasEvent {
             | Self::Camera(context, ..)
             | Self::Focus(context)
             | Self::Shelf(context, _)
-            | Self::Properties(context, _)
             | Self::OpenUse(context, _)
             | Self::Back(context)
             | Self::Choose(context, _)
@@ -227,7 +214,6 @@ pub enum ValueSection {
 const VALUE_PAGE_SIZE: usize = 24;
 #[derive(Default)]
 pub struct State {
-    spacing: Option<spacing::controller::Session>,
     draft: Option<Draft>,
     form_session: Id,
     form_mount: Id,
@@ -384,7 +370,6 @@ impl State {
             self.canvas_tool = Some((owner, CanvasTool::Select));
         }
         if changed || self.presentation.visit.is_nil() {
-            self.spacing = None;
             self.presentation.visit = Id::new_v4();
             self.restore = None;
             return true;
@@ -393,12 +378,10 @@ impl State {
     }
     /// Suspend captured events while preserving this destination's camera state.
     pub(crate) fn leave(&mut self) {
-        self.spacing = None;
         self.presentation.visit = Id::nil();
         self.restore = None;
     }
     pub(crate) fn forget_view(&mut self) {
-        self.spacing = None;
         self.presentation.identity = None;
         self.presentation.representation = None;
         self.presentation.visit = Id::nil();
@@ -511,12 +494,6 @@ impl State {
     pub(crate) fn toggle_shelf(&mut self, shelf: Shelf) {
         self.presentation.shelf = (self.presentation.shelf != Some(shelf)).then_some(shelf);
     }
-    pub(crate) fn show_properties(&mut self) {
-        // Properties belong to the inspector. Restore that panel and dismiss
-        // the competing outline without replacing this view or its camera.
-        self.presentation.focused = false;
-        self.presentation.shelf = None;
-    }
     pub(crate) fn open_use(
         &mut self,
         p: &Project,

crates/oa-desktop/src/behavior/scenario/camera.rs

@@ -183,9 +183,8 @@ mod tests {
 
     #[test]
     fn tiny_fit_zoom_in_out_preserves_pointer_world_anchor_without_floor_jump() {
-        let size = Size::new(700., 500.);
-        let viewport = Some(size);
-        let start = fit(bounds(), size).unwrap();
+        let viewport = Some(Size::new(700., 500.));
+        let start = fit(bounds(), viewport.unwrap()).unwrap();
         let (mut pan, mut zoom, mut fitting) = (Vector::ZERO, None, true);
         let at = Point::new(210., 180.);
         let world = Point::new(
@@ -219,8 +218,7 @@ mod tests {
 
     #[test]
     fn pan_leaves_fit_from_displayed_position_and_zero_motion_preserves_fit() {
-        let size = Size::new(700., 500.);
-        let viewport = Some(size);
+        let viewport = Some(Size::new(700., 500.));
         let (mut pan, mut zoom, mut fitting) = (Vector::ZERO, None, true);
         for event in [
             Event::Pan(Vector::ZERO),
@@ -240,7 +238,7 @@ mod tests {
             ));
             assert_eq!((pan, zoom, fitting), (Vector::ZERO, None, true));
         }
-        let start = fit(bounds(), size).unwrap();
+        let start = fit(bounds(), viewport.unwrap()).unwrap();
         assert!(change(
             &mut pan,
             &mut zoom,

crates/oa-desktop/src/behavior/scenario/presentation_tests.rs

@@ -188,93 +188,28 @@ fn complete_fallback_scene_selects_but_cannot_capture_or_finish_coordinate_gestu
         );
         assert!(input.press.is_none() && input.source.is_none());
     }
-    // Capture from an actual Ready presentation, then revoke coordinate input
-    // with the complete fallback frame of the same Saved representation.
-    let Representation::Saved { diagram } = rep else {
-        unreachable!()
-    };
-    let mut ready_project = f.project.clone();
-    ready_project.diagrams.get_mut(&diagram).unwrap().layout =
-        Some(DiagramLayout::Scenario(ScenarioLayout::default()));
-    let ready_original = ready_project.clone();
-    let ready = state.display(&ready_project, f.owner, f.call).unwrap();
-    assert!(matches!(
-        ready.status(),
-        presentation::PresentationStatus::Ready
-    ));
-    let mut ready_scene = ready.into_scene().unwrap();
-    let line = ready_scene
-        .lines
-        .iter()
-        .find(|line| line.id == f.call)
-        .unwrap();
-    let ready_point = Point::new(
-        (line.points[0].x + line.points.last().unwrap().x) / 2.,
-        line.points[0].y,
-    );
-    let hit = ready_scene.hit_item(ready_point).unwrap();
-    assert_eq!(hit.id, f.call);
-    assert_eq!(hit.role, SceneHitRole::MessageBody);
-    let stamp = spacing::Stamp {
-        context,
-        camera_epoch: 17,
-    };
-    ready_scene.coordinate_input = true;
-    ready_scene.interaction = Some((context, CanvasTool::Select, true));
-    ready_scene.spacing_stamp = Some(stamp);
+    // A gesture already captured in a Ready frame is cancelled when capability is revoked.
+    scene.coordinate_input = true;
+    scene.interaction = Some((context, CanvasTool::Select, true));
     let mut input = SequenceInput::default();
-    let begin = canvas::Program::update(
-        &ready_scene,
+    let _ = canvas::Program::update(
+        &scene,
         &mut input,
         &canvas::Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
         bounds,
-        mouse::Cursor::Available(ready_point),
-    )
-    .and_then(|action| action.into_inner().0)
-    .unwrap();
-    let Message::ScenarioCanvas(CanvasEvent::Spacing(spacing::Event::Begin {
-        stamp: captured_stamp,
-        token,
-        target: spacing::Target::Message(target),
-        ..
-    })) = begin
-    else {
-        panic!("Ready Saved message must begin a stamped spacing gesture");
-    };
-    assert_eq!(captured_stamp, stamp);
-    assert_eq!(target, f.call);
-    assert!(matches!(input.press, Some(SequencePress::Spacing {
-        stamp: held_stamp, token: held_token
-    }) if held_stamp == stamp && held_token == token));
-    scene.interaction = Some((context, CanvasTool::Select, true));
-    assert!(!scene.coordinate_input && scene.spacing_stamp.is_none());
-    let release = canvas::Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left));
+        mouse::Cursor::Available(point),
+    );
+    assert!(input.press.is_some());
+    scene.coordinate_input = false;
     let result = canvas::Program::update(
         &scene,
         &mut input,
-        &release,
+        &canvas::Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left)),
         bounds,
-        mouse::Cursor::Available(ready_point),
-    )
-    .and_then(|action| action.into_inner().0);
-    assert!(
-        matches!(result, Some(Message::ScenarioCanvas(CanvasEvent::Spacing(
-        spacing::Event::Cancel { stamp: cancelled_stamp, token: cancelled_token }
-    ))) if cancelled_stamp == stamp && cancelled_token == token)
+        mouse::Cursor::Available(point),
     );
-    assert!(input.press.is_none() && input.source.is_none());
-    assert!(
-        canvas::Program::update(
-            &scene,
-            &mut input,
-            &release,
-            bounds,
-            mouse::Cursor::Available(ready_point),
-        )
-        .and_then(|action| action.into_inner().0)
-        .is_none()
-    );
-    assert_eq!(ready_project, ready_original);
+    assert!(result.and_then(|action| action.into_inner().0).is_none());
+    assert!(input.press.is_none());
     assert_eq!(f.project, original);
 }
 

crates/oa-desktop/src/behavior/scenario/spacing.rs

@@ -1,160 +0,0 @@
-//! Pure Saved-only spacing preparation. Delta is measured from the original
-//! pointer in the captured camera's world coordinates, never from the last
-//! preview. The controller must own document/revision/visit, camera and hit-role
-//! admission; this module neither dispatches commands nor changes selection.
-use crate::behavior::scenario_layout::{
-    GeometryIssue, Representation, ResolvedScenarioPlan, presentation::checked_owner, resolve,
-};
-use oa_core::{
-    Command, Id, Kind, OccurrenceBody, OccurrenceEndpoint, Project, ScenarioLanePosition,
-    ScenarioMessagePosition, SharedBody, execute_batch,
-};
-
-pub(crate) mod controller;
-#[cfg(test)]
-mod tests;
-pub(crate) use controller::{Event, Stamp};
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Target {
-    Lane(Id),
-    Message(Id),
-}
-impl Target {
-    pub(crate) fn id(self) -> Id {
-        match self {
-            Self::Lane(id) | Self::Message(id) => id,
-        }
-    }
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub(crate) enum Refusal {
-    InvalidSavedView(Id),
-    TargetNotRendered(Target),
-    InvalidDelta,
-    InvalidGesture,
-    CameraChanged,
-    TargetNotHit(Target),
-    Command(String),
-    Geometry(Vec<GeometryIssue>),
-}
-
-pub(super) struct Drag {
-    original: Project,
-    diagram: Id,
-    target: Target,
-    origin: f32,
-    original_geometry: ResolvedScenarioPlan,
-}
-
-pub(super) struct Preview {
-    pub(super) command: Command,
-    #[cfg(test)]
-    pub(super) project: Project,
-    pub(super) geometry: ResolvedScenarioPlan,
-}
-
-/// Capture an accepted, actually drawn target. A Saved view displaying automatic
-/// fallback is not an editable original, even if the target appears in fallback.
-pub(super) fn capture(project: &Project, diagram: Id, target: Target) -> Result<Drag, Refusal> {
-    let representation = Representation::Saved { diagram };
-    let owner = checked_owner(project, representation).ok_or(Refusal::InvalidSavedView(diagram))?;
-    let geometry = resolve(project, representation, target.id()).map_err(Refusal::Geometry)?;
-    let element = project.elements.get(&target.id());
-    let origin = match target {
-        Target::Lane(id)
-            if element.is_some_and(|e| e.kind() == Kind::Lifeline && e.parent == Some(owner)) =>
-        {
-            // Unassigned lifelines still have drawn headers. `scene.lanes`
-            // excludes them only from semantic message-endpoint hit testing.
-            geometry.scene.render_lanes.get(&id).copied()
-        }
-        Target::Message(id)
-            if element.is_some_and(|e| {
-                matches!(
-                    e.shared(),
-                    Some(SharedBody::Occurrence {
-                        body: OccurrenceBody::Exchange { .. },
-                        ..
-                    })
-                )
-            }) =>
-        {
-            // A lifecycle row can denote receive y; the public position means
-            // send y. Read the actual outgoing endpoint, including self calls.
-            geometry
-                .scene
-                .lines
-                .iter()
-                .find(|line| line.id == id)
-                .and_then(|line| line.points.first())
-                .map(|point| point.y)
-        }
-        _ => None,
-    }
-    .ok_or(Refusal::TargetNotRendered(target))?;
-    if !origin.is_finite() {
-        return Err(Refusal::TargetNotRendered(target));
-    }
-    Ok(Drag {
-        original: project.clone(),
-        diagram,
-        target,
-        origin,
-        original_geometry: geometry,
-    })
-}
-
-impl Drag {
-    /// None means there is no command to commit. In particular +0/-0, return to
-    /// start, and sub-precision motion never materialize a missing override or
-    /// normalize an existing explicit value. Document/redo are never touched.
-    pub(super) fn prepare(&self, original_delta: f32) -> Result<Option<Preview>, Refusal> {
-        if !original_delta.is_finite() {
-            return Err(Refusal::InvalidDelta);
-        }
-        if original_delta == 0. {
-            return Ok(None);
-        }
-        let position = (f64::from(self.origin) + f64::from(original_delta)) as f32;
-        if position == self.origin {
-            return Ok(None);
-        }
-        let command = match self.target {
-            Target::Lane(lifeline) => Command::SetScenarioLanePosition {
-                diagram: self.diagram,
-                position: ScenarioLanePosition {
-                    lifeline,
-                    x: position,
-                },
-            },
-            Target::Message(occurrence) => Command::SetScenarioMessagePosition {
-                diagram: self.diagram,
-                position: ScenarioMessagePosition {
-                    address: OccurrenceEndpoint {
-                        references: vec![],
-                        occurrence,
-                    },
-                    send_y: position,
-                },
-            },
-        };
-        let project = execute_batch(&self.original, std::slice::from_ref(&command))
-            .map_err(|error| Refusal::Command(error.to_string()))?;
-        let geometry = resolve(
-            &project,
-            Representation::Saved {
-                diagram: self.diagram,
-            },
-            self.target.id(),
-        )
-        .map_err(Refusal::Geometry)?;
-        Ok(Some(Preview {
-            command,
-            #[cfg(test)]
-            project,
-            geometry,
-        }))
-    }
-}

crates/oa-desktop/src/behavior/scenario/spacing/controller.rs

@@ -1,300 +0,0 @@
-//! One press owns one immutable accepted Project and one frozen display camera.
-use super::*;
-use crate::behavior::{
-    Scene, SceneHitRole,
-    scenario::{CanvasTool, Context, State},
-    scenario_layout::Diagnostic,
-};
-use iced::{Point, Rectangle, Vector};
-
-#[cfg(test)]
-pub(crate) mod tests;
-#[cfg(test)]
-mod timing_tests;
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct Stamp {
-    pub(crate) context: Context,
-    pub(crate) camera_epoch: u64,
-}
-
-#[derive(Clone, Copy, Debug)]
-pub enum Event {
-    Begin {
-        stamp: Stamp,
-        token: Id,
-        target: Target,
-        press_screen: Point,
-        canvas_bounds: Rectangle,
-        scale: f32,
-        pan: Vector,
-    },
-    Move {
-        stamp: Stamp,
-        token: Id,
-        screen: Point,
-    },
-    Finish {
-        stamp: Stamp,
-        token: Id,
-        screen: Point,
-    },
-    Cancel {
-        stamp: Stamp,
-        token: Id,
-    },
-}
-impl Event {
-    pub(crate) fn stamp(self) -> Stamp {
-        match self {
-            Self::Begin { stamp, .. }
-            | Self::Move { stamp, .. }
-            | Self::Finish { stamp, .. }
-            | Self::Cancel { stamp, .. } => stamp,
-        }
-    }
-    pub(crate) fn token(self) -> Id {
-        match self {
-            Self::Begin { token, .. }
-            | Self::Move { token, .. }
-            | Self::Finish { token, .. }
-            | Self::Cancel { token, .. } => token,
-        }
-    }
-}
-
-pub(crate) struct Session {
-    stamp: Stamp,
-    token: Id,
-    press_screen: Point,
-    scale: f32,
-    pan: Vector,
-    drag: Drag,
-    preview: Option<Preview>,
-    refusal: Option<Refusal>,
-    ever_crossed: bool,
-}
-
-pub(in crate::behavior) struct Paint<'a> {
-    pub(in crate::behavior) scene: &'a Scene,
-    #[cfg(test)]
-    pub(in crate::behavior) bounds: Rectangle,
-    pub(in crate::behavior) refusal: Option<&'a Refusal>,
-    pub(in crate::behavior) original_diagnostics: &'a [Diagnostic],
-    pub(in crate::behavior) original_latent: &'a [Id],
-    pub(in crate::behavior) diagnostics: &'a [Diagnostic],
-}
-
-pub(crate) enum Finish {
-    Click(Id),
-    Noop,
-    Commit {
-        command: Box<Command>,
-        selected: Id,
-        scale: f32,
-        pan: Vector,
-    },
-}
-
-impl Session {
-    fn configure(&self, scene: &mut Scene) {
-        scene.selected = self.drag.target.id();
-        scene.scale = self.scale;
-        scene.camera_pan = self.pan;
-        scene.interaction = Some((self.stamp.context, CanvasTool::Select, true));
-        scene.spacing_stamp = Some(self.stamp);
-        scene.coordinate_input = true;
-        scene.pending_placement = None;
-    }
-    fn update(&mut self, screen: Point) {
-        self.preview = None;
-        self.refusal = None;
-        if !screen.x.is_finite() || !screen.y.is_finite() {
-            self.refusal = Some(Refusal::InvalidDelta);
-            return;
-        }
-        let distance = match self.drag.target {
-            Target::Lane(_) => screen.x - self.press_screen.x,
-            Target::Message(_) => screen.y - self.press_screen.y,
-        };
-        self.ever_crossed |= distance.abs() >= 3.;
-        if !self.ever_crossed {
-            return;
-        }
-        match self.drag.prepare(distance / self.scale) {
-            Ok(Some(mut preview)) => {
-                self.configure(&mut preview.geometry.scene);
-                self.preview = Some(preview);
-            }
-            Ok(None) => {}
-            Err(error) => self.refusal = Some(error),
-        }
-    }
-}
-
-impl State {
-    pub(crate) fn spacing_token(&self) -> Option<Id> {
-        self.spacing.as_ref().map(|s| s.token)
-    }
-    pub(crate) fn spacing_stamp(&self) -> Option<Stamp> {
-        self.spacing.as_ref().map(|s| s.stamp)
-    }
-    pub(crate) fn cancel_spacing(&mut self) -> bool {
-        self.spacing.take().is_some()
-    }
-
-    pub(in crate::behavior) fn spacing_paint(
-        &self,
-        context: Context,
-        camera_epoch: u64,
-    ) -> Option<Paint<'_>> {
-        let session = self.spacing.as_ref()?;
-        if session.stamp
-            != (Stamp {
-                context,
-                camera_epoch,
-            })
-        {
-            return None;
-        }
-        let original = &session.drag.original_geometry;
-        let shown = session.preview.as_ref().map_or(original, |p| &p.geometry);
-        Some(Paint {
-            scene: &shown.scene,
-            #[cfg(test)]
-            bounds: shown.bounds,
-            refusal: session.refusal.as_ref(),
-            original_diagnostics: &original.plan.diagnostics,
-            original_latent: &original.latent_messages,
-            diagnostics: &shown.plan.diagnostics,
-        })
-    }
-
-    pub(crate) fn begin_spacing(&mut self, project: &Project, event: Event) -> Result<(), Refusal> {
-        let Event::Begin {
-            stamp,
-            token,
-            target,
-            press_screen,
-            canvas_bounds,
-            scale,
-            pan,
-        } = event
-        else {
-            return Err(Refusal::InvalidGesture);
-        };
-        let context = stamp.context;
-        if self.spacing.is_some()
-            || token.is_nil()
-            || self.context(
-                context.document,
-                context.scenario,
-                context.revision,
-                context.epoch,
-            ) != Some(context)
-            || self.canvas_tool(context.scenario) != CanvasTool::Select
-            || ![
-                press_screen.x,
-                press_screen.y,
-                canvas_bounds.x,
-                canvas_bounds.y,
-                canvas_bounds.width,
-                canvas_bounds.height,
-                scale,
-                pan.x,
-                pan.y,
-            ]
-            .into_iter()
-            .all(f32::is_finite)
-            || scale <= 0.
-            || canvas_bounds.width <= 0.
-            || canvas_bounds.height <= 0.
-            || !canvas_bounds.contains(press_screen)
-        {
-            return Err(Refusal::InvalidGesture);
-        }
-        let Representation::Saved { diagram } = context.representation else {
-            return Err(Refusal::InvalidGesture);
-        };
-        let mut drag = capture(project, diagram, target)?;
-        let camera = self.presentation.camera(drag.original_geometry.bounds);
-        if self.presentation.viewport != Some(canvas_bounds.size())
-            || camera.scale != scale
-            || camera.pan != pan
-        {
-            return Err(Refusal::CameraChanged);
-        }
-        let world = Point::new(
-            (press_screen.x - canvas_bounds.x - pan.x) / scale,
-            (press_screen.y - canvas_bounds.y - pan.y) / scale,
-        );
-        // Hit tolerance is measured in displayed pixels, just like the widget.
-        drag.original_geometry.scene.scale = scale;
-        drag.original_geometry.scene.camera_pan = pan;
-        let hit = drag.original_geometry.scene.hit_item(world);
-        if !hit.is_some_and(|hit| {
-            hit.id == target.id()
-                && match target {
-                    Target::Lane(_) => hit.role == SceneHitRole::LifelineHeader,
-                    Target::Message(_) => matches!(
-                        hit.role,
-                        SceneHitRole::MessageBody | SceneHitRole::MessageLabel
-                    ),
-                }
-        }) {
-            return Err(Refusal::TargetNotHit(target));
-        }
-        // Configure baseline without changing the persistent camera or selection.
-        let scene = &mut drag.original_geometry.scene;
-        scene.selected = target.id();
-        scene.scale = scale;
-        scene.camera_pan = pan;
-        scene.interaction = Some((context, CanvasTool::Select, true));
-        scene.spacing_stamp = Some(stamp);
-        scene.coordinate_input = true;
-        scene.pending_placement = None;
-        self.spacing = Some(Session {
-            stamp,
-            token,
-            press_screen,
-            scale,
-            pan,
-            drag,
-            preview: None,
-            refusal: None,
-            ever_crossed: false,
-        });
-        Ok(())
-    }
-    pub(crate) fn move_spacing(&mut self, screen: Point) {
-        if let Some(session) = &mut self.spacing {
-            session.update(screen);
-        }
-    }
-    pub(crate) fn finish_spacing(&mut self, screen: Point) -> Result<Finish, Refusal> {
-        let Some(mut session) = self.spacing.take() else {
-            return Err(Refusal::InvalidGesture);
-        };
-        session.update(screen);
-        if let Some(error) = session.refusal {
-            return Err(error);
-        }
-        if !session.ever_crossed {
-            return Ok(Finish::Click(session.drag.target.id()));
-        }
-        Ok(match session.preview {
-            None => Finish::Noop,
-            Some(preview) => Finish::Commit {
-                command: Box::new(preview.command),
-                selected: session.drag.target.id(),
-                scale: session.scale,
-                pan: session.pan,
-            },
-        })
-    }
-    pub(crate) fn accept_spacing_camera(&mut self, scale: f32, pan: Vector) {
-        self.presentation.zoom = Some(scale);
-        self.presentation.pan = pan;
-        self.presentation.fit = false;
-    }
-}

crates/oa-desktop/src/behavior/scenario/spacing/controller/tests.rs

@@ -1,421 +0,0 @@
-use super::*;
-use crate::document::Document;
-use iced::Size;
-use oa_core::{Diagram, Layer, ProjectionKind, language, source_project::ProjectLimits};
-
-pub(crate) fn fixture() -> (Document, Id, Id, Id, Id) {
-    let mut p = language::parse(r#"arcadia 7;
-project spacing "Spacing" {
- oa_activity work "Work" {}
- oa_activity response "Response" {}
- oa_scenario incident "Incident" { viewpoint OperationalActivity; steps [@first, @second]; }
- oa_lifeline reporter "Reporter" { parent @incident; represented @work; }
- oa_lifeline operator "Operator" { parent @incident; represented @response; }
- oa_occurrence first "First" { parent @incident; body { Exchange { exchange none; sender @reporter; receiver @operator; message_kind Asynchronous; }; }; }
- oa_occurrence second "Second" { parent @incident; body { Exchange { exchange none; sender @operator; receiver @reporter; message_kind Asynchronous; }; }; }
-}"#).unwrap();
-    let id = |name: &str| {
-        p.identities()
-            .into_iter()
-            .find(|(_, alias)| *alias == name)
-            .unwrap()
-            .0
-    };
-    let (owner, lane, message) = (id("incident"), id("reporter"), id("first"));
-    let diagram = Id::new_v4();
-    p.diagrams.insert(
-        diagram,
-        Diagram {
-            id: diagram,
-            alias: "saved".into(),
-            name: "Saved".into(),
-            description: String::new(),
-            layer: Layer::Oa,
-            projection: ProjectionKind::Scenario { scenario: owner },
-            nodes: Default::default(),
-            routes: vec![],
-            view_options: Default::default(),
-            layout: None,
-        },
-    );
-    (
-        Document::from_project(p, ProjectLimits::default()).unwrap(),
-        owner,
-        diagram,
-        lane,
-        message,
-    )
-}
-
-pub(crate) fn expected(p: &Project, diagram: Id, target: Target, delta: f32) -> Project {
-    capture(p, diagram, target)
-        .unwrap()
-        .prepare(delta)
-        .unwrap()
-        .unwrap()
-        .project
-}
-
-pub(crate) fn packet(
-    p: &Project,
-    state: &State,
-    context: Context,
-    camera_epoch: u64,
-    target: Target,
-) -> Event {
-    let geometry = resolve(p, context.representation, target.id()).unwrap();
-    let world = match target {
-        Target::Lane(id) => geometry
-            .scene
-            .boxes
-            .iter()
-            .find(|item| item.id == id && item.role == SceneHitRole::LifelineHeader)
-            .unwrap()
-            .rect
-            .center(),
-        Target::Message(id) => {
-            let line = geometry
-                .scene
-                .lines
-                .iter()
-                .find(|line| line.id == id)
-                .unwrap();
-            Point::new((line.points[0].x + line.points[1].x) / 2., line.points[0].y)
-        }
-    };
-    assert!(
-        geometry
-            .scene
-            .hit_item(world)
-            .is_some_and(|hit| hit.id == target.id())
-    );
-    let camera = state.presentation.camera(geometry.bounds);
-    let canvas_bounds = Rectangle::new(Point::new(17., 23.), state.presentation.viewport.unwrap());
-    Event::Begin {
-        stamp: Stamp {
-            context,
-            camera_epoch,
-        },
-        token: Id::new_v4(),
-        target,
-        press_screen: Point::new(
-            canvas_bounds.x + world.x * camera.scale + camera.pan.x,
-            canvas_bounds.y + world.y * camera.scale + camera.pan.y,
-        ),
-        canvas_bounds,
-        scale: camera.scale,
-        pan: camera.pan,
-    }
-}
-fn setup(target_message: bool) -> (Document, State, Event) {
-    let (doc, owner, diagram, lane, message) = fixture();
-    let mut state = State::default();
-    state.enter_representation(Id::new_v4(), owner, Representation::Saved { diagram });
-    state.presentation.viewport = Some(Size::new(900., 600.));
-    let context = state
-        .context(
-            state.presentation.identity.unwrap().0,
-            owner,
-            doc.revision(),
-            4,
-        )
-        .unwrap();
-    let target = if target_message {
-        Target::Message(message)
-    } else {
-        Target::Lane(lane)
-    };
-    let event = packet(doc.project(), &state, context, 9, target);
-    (doc, state, event)
-}
-fn press(event: Event) -> Point {
-    let Event::Begin { press_screen, .. } = event else {
-        unreachable!()
-    };
-    press_screen
-}
-
-#[test]
-fn real_preview_moves_only_active_axis_from_original_and_never_changes_document() {
-    for message in [false, true] {
-        let (doc, mut state, begin) = setup(message);
-        let original = doc.snapshot();
-        let camera = state.camera_boundary();
-        let start = press(begin);
-        state.begin_spacing(doc.project(), begin).unwrap();
-        let first = if message {
-            Vector::new(500., 30.)
-        } else {
-            Vector::new(30., 500.)
-        };
-        state.move_spacing(start + first);
-        let session = state.spacing.as_ref().unwrap();
-        let candidate = session.preview.as_ref().unwrap();
-        let delta = 30. / session.scale;
-        let actual_anchor = match session.drag.target {
-            Target::Lane(id) => candidate.geometry.scene.render_lanes[&id],
-            Target::Message(id) => {
-                candidate
-                    .geometry
-                    .scene
-                    .lines
-                    .iter()
-                    .find(|line| line.id == id)
-                    .unwrap()
-                    .points[0]
-                    .y
-            }
-        };
-        let wanted = (f64::from(session.drag.origin) + f64::from(delta)) as f32;
-        assert_eq!(actual_anchor.to_bits(), wanted.to_bits());
-        let expected = session.drag.prepare(delta).unwrap().unwrap();
-        assert_eq!(candidate.project, expected.project);
-        assert_eq!(candidate.geometry.scene.rows, expected.geometry.scene.rows);
-        assert_eq!(
-            candidate.geometry.scene.render_lanes,
-            expected.geometry.scene.render_lanes
-        );
-        state.move_spacing(start + first * 2.);
-        let session = state.spacing.as_ref().unwrap();
-        assert_eq!(
-            session.preview.as_ref().unwrap().project,
-            session.drag.prepare(delta * 2.).unwrap().unwrap().project
-        );
-        assert_eq!(doc.project(), &original.decoded.project);
-        assert_eq!(doc.compiled().bundle, original.bundle);
-        assert!(!doc.dirty() && !doc.can_undo() && !doc.can_redo());
-        assert!(camera == state.camera_boundary());
-    }
-}
-
-#[test]
-fn click_threshold_is_active_axis_and_return_to_zero_is_not_a_click() {
-    let (doc, mut state, begin) = setup(false);
-    let start = press(begin);
-    state.begin_spacing(doc.project(), begin).unwrap();
-    state.move_spacing(start + Vector::new(2., 100.));
-    assert!(matches!(
-        state.finish_spacing(start).unwrap(),
-        Finish::Click(_)
-    ));
-    state.begin_spacing(doc.project(), begin).unwrap();
-    state.move_spacing(start + Vector::new(4., 0.));
-    assert!(matches!(state.finish_spacing(start).unwrap(), Finish::Noop));
-    assert!(!doc.can_undo());
-}
-
-#[test]
-fn invalid_move_discards_prior_candidate_and_finish_rechecks_final_pointer() {
-    let (doc, mut state, begin) = setup(false);
-    let start = press(begin);
-    state.begin_spacing(doc.project(), begin).unwrap();
-    state.move_spacing(start + Vector::new(20., 0.));
-    state.move_spacing(Point::new(f32::NAN, start.y));
-    let paint = state.spacing_paint(begin.stamp().context, 9).unwrap();
-    assert!(matches!(paint.refusal, Some(Refusal::InvalidDelta)));
-    assert_eq!(
-        paint.scene.render_lanes,
-        state
-            .spacing
-            .as_ref()
-            .unwrap()
-            .drag
-            .original_geometry
-            .scene
-            .render_lanes
-    );
-    assert!(matches!(
-        state.finish_spacing(Point::new(f32::NAN, start.y)),
-        Err(Refusal::InvalidDelta)
-    ));
-    assert!(state.spacing_token().is_none());
-}
-
-#[test]
-fn forged_camera_hit_role_and_retired_visit_cannot_capture() {
-    let (doc, mut state, begin) = setup(false);
-    let Event::Begin {
-        stamp,
-        token,
-        target,
-        press_screen,
-        canvas_bounds,
-        scale,
-        pan,
-    } = begin
-    else {
-        unreachable!()
-    };
-    assert!(matches!(
-        state.begin_spacing(
-            doc.project(),
-            Event::Begin {
-                stamp,
-                token,
-                target,
-                press_screen,
-                canvas_bounds,
-                scale: scale * 2.,
-                pan
-            }
-        ),
-        Err(Refusal::CameraChanged)
-    ));
-    assert!(matches!(
-        state.begin_spacing(
-            doc.project(),
-            Event::Begin {
-                stamp,
-                token,
-                target,
-                press_screen: canvas_bounds.center(),
-                canvas_bounds,
-                scale,
-                pan
-            }
-        ),
-        Err(Refusal::TargetNotHit(_))
-    ));
-    state.leave();
-    assert!(matches!(
-        state.begin_spacing(doc.project(), begin),
-        Err(Refusal::InvalidGesture)
-    ));
-}
-
-#[test]
-fn zoomed_out_message_tolerance_matches_actual_canvas_hit() {
-    let (doc, mut state, _) = setup(true);
-    state.presentation.fit = false;
-    state.presentation.zoom = Some(0.25);
-    state.presentation.pan = Vector::ZERO;
-    let context = state
-        .context(
-            state.presentation.identity.unwrap().0,
-            state.owner().unwrap(),
-            doc.revision(),
-            4,
-        )
-        .unwrap();
-    let message = doc
-        .project()
-        .identities()
-        .into_iter()
-        .find(|(_, alias)| *alias == "first")
-        .map(|(id, _)| id)
-        .unwrap();
-    let Event::Begin {
-        stamp,
-        token,
-        target,
-        press_screen,
-        canvas_bounds,
-        scale,
-        pan,
-    } = packet(doc.project(), &state, context, 9, Target::Message(message))
-    else {
-        unreachable!()
-    };
-    let event = Event::Begin {
-        stamp,
-        token,
-        target,
-        press_screen: press_screen + Vector::new(0., 3.),
-        canvas_bounds,
-        scale,
-        pan,
-    };
-    state.begin_spacing(doc.project(), event).unwrap();
-    assert_eq!(state.spacing_token(), Some(token));
-}
-
-#[test]
-fn fractional_screen_packet_preserves_subpixel_motion_in_preview_and_finish() {
-    let (doc, owner, diagram, _, message) = fixture();
-    let original = doc.snapshot();
-    assert!(doc.project().diagrams[&diagram].layout.is_none());
-    let mut state = State::default();
-    let document = Id::new_v4();
-    state.enter_representation(document, owner, Representation::Saved { diagram });
-    state.presentation.viewport = Some(Size::new(900., 600.));
-    state.presentation.fit = false;
-    state.presentation.zoom = Some(0.5);
-    // 406 + 2^-15 puts the press just below the 512 screen-coordinate boundary.
-    state.presentation.pan = Vector::new(0., f32::from_bits(0x43cb_0001));
-    let camera = state.camera_boundary();
-    let context = state.context(document, owner, doc.revision(), 4).unwrap();
-    let baseline = resolve(doc.project(), context.representation, message).unwrap();
-    let line = baseline
-        .scene
-        .lines
-        .iter()
-        .find(|line| line.id == message)
-        .unwrap();
-    assert_eq!(line.points[0].y, 148.);
-    let begin = packet(doc.project(), &state, context, 9, Target::Message(message));
-    let Event::Begin {
-        press_screen,
-        canvas_bounds,
-        scale,
-        pan,
-        ..
-    } = begin
-    else {
-        unreachable!()
-    };
-    assert_eq!(canvas_bounds.y, 23.);
-    assert_eq!(scale, 0.5);
-    assert_eq!(pan.y.to_bits(), 0x43cb_0001);
-    assert_eq!(press_screen.y.to_bits(), 0x43fb_8001); // 503 + 2^-15.
-    let end = press_screen + Vector::new(0., 10.);
-    assert_eq!(end.y, 513.);
-    assert!(canvas_bounds.contains(press_screen) && canvas_bounds.contains(end));
-    // The submitted f32 displacement is 10 - 2^-15, not exactly 10.
-    assert_eq!((end.y - press_screen.y).to_bits(), 0x411f_ffe0);
-    assert_eq!(((end.y - press_screen.y) / scale).to_bits(), 0x419f_ffe0);
-    // Independent oracle: 148 + (10 - 2^-15) / .5 = 168 - 2^-14.
-    let expected_y = f32::from_bits(0x4327_fffc);
-    let mut expected = original.decoded.project.clone();
-    expected.diagrams.get_mut(&diagram).unwrap().layout =
-        Some(oa_core::DiagramLayout::Scenario(oa_core::ScenarioLayout {
-            lanes: vec![],
-            messages: vec![oa_core::ScenarioMessagePosition {
-                address: oa_core::OccurrenceEndpoint {
-                    references: vec![],
-                    occurrence: message,
-                },
-                send_y: expected_y,
-            }],
-        }));
-    state.begin_spacing(doc.project(), begin).unwrap();
-    state.move_spacing(end);
-    let preview = state.spacing.as_ref().unwrap().preview.as_ref().unwrap();
-    assert_eq!(preview.project, expected);
-    let line = preview
-        .geometry
-        .scene
-        .lines
-        .iter()
-        .find(|line| line.id == message)
-        .unwrap();
-    assert_eq!(line.points[0].y.to_bits(), expected_y.to_bits());
-    let Finish::Commit {
-        command,
-        selected,
-        scale,
-        pan,
-    } = state.finish_spacing(end).unwrap()
-    else {
-        panic!("fractional motion must remain a commit")
-    };
-    assert_eq!(selected, message);
-    assert_eq!(scale, 0.5);
-    assert_eq!(pan.y.to_bits(), 0x43cb_0001);
-    let committed = oa_core::execute_batch(doc.project(), &[*command]).unwrap();
-    assert_eq!(committed, expected);
-    assert!(state.spacing_token().is_none());
-    assert_eq!(doc.project(), &original.decoded.project);
-    assert_eq!(doc.compiled().bundle, original.bundle);
-    assert!(!doc.dirty() && !doc.can_undo() && !doc.can_redo());
-    assert!(camera == state.camera_boundary());
-}

crates/oa-desktop/src/behavior/scenario/spacing/controller/timing_tests.rs

@@ -1,304 +0,0 @@
-//! Diagnostic only: production capture/prepare, excluding fixture construction,
-//! oracle work, App source writes, widget rebuilds, text shaping and GPU paint.
-use super::*;
-use crate::document::Document;
-use oa_core::{
-    DiagramLayout, Layer, MessageKind, RelationKind, ScenarioLayout, source_project::ProjectLimits,
-};
-use serde_json::{Value, json};
-use std::{collections::BTreeSet, sync::Arc, time::Instant};
-
-const MESSAGE_COUNT: usize = 1000;
-const TARGET_INDEX: usize = 500;
-
-fn large_fixture() -> (Document, Id, [Id; 3], Vec<Id>, Vec<Id>) {
-    let (seed, owner, a, reporter, first) = super::tests::fixture();
-    let mut p = seed.project().clone();
-    let old_steps = p.elements[&owner].steps().unwrap().clone();
-    let template = p.elements[&first].clone();
-    let work = |alias: &str| {
-        p.identities()
-            .into_iter()
-            .find(|(_, name)| *name == alias)
-            .unwrap()
-            .0
-    };
-    let (source, target) = (work("work"), work("response"));
-    let operator = work("operator");
-    let relation = p.relate(
-        RelationKind::Interaction,
-        "Repeated incident report",
-        source,
-        target,
-    );
-    let mut lanes = vec![];
-    for index in 0..20 {
-        let original = if index < 10 { reporter } else { operator };
-        let mut lane = p.elements[&original].clone();
-        lane.id = Id::new_v4();
-        lane.alias = format!("timing_lane_{index:02}");
-        lane.name = format!("Review participant {index:02}");
-        lanes.push(lane.id);
-        p.elements.insert(lane.id, lane);
-    }
-    p.elements.remove(&reporter);
-    p.elements.remove(&operator);
-    for id in old_steps {
-        p.elements.remove(&id);
-    }
-    let mut messages = vec![];
-    for index in 0..MESSAGE_COUNT {
-        let mut occurrence = template.clone();
-        occurrence.id = Id::new_v4();
-        occurrence.alias = format!("timing_message_{index:04}");
-        occurrence.name = format!("Validate incident report {index:04}");
-        *occurrence.shared_mut().unwrap() = SharedBody::Occurrence {
-            body: OccurrenceBody::Exchange {
-                exchange: Some(relation),
-                sender: Some(lanes[index % 10]),
-                receiver: Some(lanes[10 + index % 10]),
-                message_kind: MessageKind::Asynchronous,
-                operation: None,
-                reply_to: None,
-                values: vec![],
-            },
-            precondition: String::new(),
-            postcondition: String::new(),
-        };
-        messages.push(occurrence.id);
-        p.elements.insert(occurrence.id, occurrence);
-    }
-    *p.elements.get_mut(&owner).unwrap().steps_mut().unwrap() = messages.clone();
-    p.diagrams.get_mut(&a).unwrap().layout = Some(DiagramLayout::Scenario(ScenarioLayout {
-        lanes: lanes
-            .iter()
-            .enumerate()
-            .map(|(i, &lifeline)| ScenarioLanePosition {
-                lifeline,
-                x: 160. + i as f32 * 240.,
-            })
-            .collect(),
-        messages: vec![],
-    }));
-    let mut views = [a, Id::nil(), Id::nil()];
-    for (index, x, offset) in [(1, -500., 12.), (2, 6500., -12.)] {
-        let mut view = p.diagrams[&a].clone();
-        view.id = Id::new_v4();
-        view.alias = format!("timing_saved_{index}");
-        view.name = format!("Review arrangement {index}");
-        view.layout = Some(DiagramLayout::Scenario(ScenarioLayout {
-            lanes: vec![ScenarioLanePosition {
-                lifeline: lanes[0],
-                x,
-            }],
-            messages: vec![ScenarioMessagePosition {
-                address: OccurrenceEndpoint {
-                    references: vec![],
-                    occurrence: messages[TARGET_INDEX],
-                },
-                send_y: 148. + TARGET_INDEX as f32 * 92. + offset,
-            }],
-        }));
-        views[index] = view.id;
-        p.diagrams.insert(view.id, view);
-    }
-    let document = Document::from_project(p, ProjectLimits::default()).unwrap();
-    assert_eq!(
-        document
-            .project()
-            .children(owner)
-            .filter(|e| e.kind() == Kind::Lifeline)
-            .count(),
-        20
-    );
-    assert_eq!(document.project().elements[&owner].layer(), Layer::Oa);
-    assert_eq!(document.project().diagrams.len(), 3);
-    (document, owner, views, lanes, messages)
-}
-
-fn assert_scene(
-    scene: &Scene,
-    lanes: &[Id],
-    messages: &[Id],
-    moved_message: Option<(Id, f32)>,
-    moved_lane: Option<(Id, f32)>,
-) {
-    assert_eq!(scene.render_lanes.len(), 20);
-    assert_eq!(
-        scene
-            .boxes
-            .iter()
-            .filter(|b| b.role == SceneHitRole::LifelineHeader)
-            .count(),
-        20
-    );
-    assert_eq!(scene.lines.len(), MESSAGE_COUNT);
-    assert_eq!(
-        scene
-            .lines
-            .iter()
-            .map(|line| line.id)
-            .collect::<BTreeSet<_>>(),
-        messages.iter().copied().collect::<BTreeSet<_>>()
-    );
-    assert!(scene.activations.is_empty() && scene.open_calls.is_empty());
-    let x = |index: usize| {
-        160. + index as f32 * 240.
-            + moved_lane
-                .filter(|(id, _)| *id == lanes[index])
-                .map_or(0., |(_, delta)| delta)
-    };
-    for (index, &lane) in lanes.iter().enumerate() {
-        assert_eq!(scene.render_lanes[&lane], x(index));
-    }
-    for (index, (line, &id)) in scene.lines.iter().zip(messages).enumerate() {
-        let y = 148.
-            + index as f32 * 92.
-            + moved_message
-                .filter(|(target, _)| *target == id)
-                .map_or(0., |(_, delta)| delta);
-        assert_eq!(line.id, id);
-        assert_eq!(
-            line.points,
-            vec![
-                Point::new(x(index % 10), y),
-                Point::new(x(10 + index % 10), y)
-            ]
-        );
-    }
-}
-
-fn summary(samples: &[Value], phase: &str) -> Value {
-    let mut times: Vec<u64> = samples
-        .iter()
-        .filter(|sample| sample["phase"] == phase)
-        .map(|sample| sample["elapsed_ns"].as_u64().unwrap())
-        .collect();
-    times.sort_unstable();
-    let n = times.len();
-    let median = if n.is_multiple_of(2) {
-        ((u128::from(times[n / 2 - 1]) + u128::from(times[n / 2])) / 2) as u64
-    } else {
-        times[n / 2]
-    };
-    json!({"samples": n, "min_ns": times[0], "median_ns": median, "max_ns": times[n-1]})
-}
-
-#[test]
-#[ignore = "Diagnostic timing only; run alone with --exact --ignored --nocapture after correctness gates; no latency acceptance threshold"]
-fn saved_spacing_capture_prepare_20_lanes_1000_messages_3_views() {
-    let (document, owner, views, lanes, messages) = large_fixture();
-    let original = document.snapshot();
-    let target = messages[TARGET_INDEX];
-    let mut samples = vec![];
-    let mut retained = None;
-    for iteration in 0..4 {
-        let start = Instant::now();
-        let result = capture(document.project(), views[0], Target::Message(target));
-        let elapsed_ns = u64::try_from(start.elapsed().as_nanos()).unwrap();
-        let drag = result.expect("complete asynchronous fixture must resolve");
-        samples.push(json!({"phase":"capture_message", "iteration":iteration,
-            "first_in_probe":iteration==0, "elapsed_ns":elapsed_ns, "outcome":"captured"}));
-        assert_scene(&drag.original_geometry.scene, &lanes, &messages, None, None);
-        if iteration == 0 {
-            retained = Some(drag);
-        }
-    }
-    let drag = retained.unwrap();
-    // Every sample is relative to the original press, including duplicate,
-    // reverse and return-to-start samples. Oracle work is outside each timer.
-    let deltas = [
-        4., 8., 12., 16., 20., 24., 28., 32., 32., 28., 24., 20., 16., 12., 8., 4., -4., -8., -4.,
-        0.,
-    ];
-    for (iteration, delta) in deltas.into_iter().enumerate() {
-        let start = Instant::now();
-        let result = drag.prepare(delta);
-        let elapsed_ns = u64::try_from(start.elapsed().as_nanos()).unwrap();
-        let candidate = result.expect("these isolated asynchronous offsets are feasible");
-        samples.push(json!({"phase":"prepare_message", "iteration":iteration,
-            "delta_world":delta, "elapsed_ns":elapsed_ns, "outcome":if candidate.is_some(){"preview"}else{"noop"}}));
-        if delta == 0. {
-            assert!(candidate.is_none());
-        } else {
-            let candidate = candidate.unwrap();
-            let mut expected = original.decoded.project.clone();
-            let Some(DiagramLayout::Scenario(layout)) =
-                &mut expected.diagrams.get_mut(&views[0]).unwrap().layout
-            else {
-                panic!()
-            };
-            layout.messages.push(ScenarioMessagePosition {
-                address: OccurrenceEndpoint {
-                    references: vec![],
-                    occurrence: target,
-                },
-                send_y: 148. + TARGET_INDEX as f32 * 92. + delta,
-            });
-            assert_eq!(candidate.project, expected);
-            assert_scene(
-                &candidate.geometry.scene,
-                &lanes,
-                &messages,
-                Some((target, delta)),
-                None,
-            );
-        }
-        assert_eq!(
-            document.project().elements[&owner].steps().unwrap(),
-            &messages
-        );
-        assert_eq!(document.project(), &original.decoded.project);
-        assert!(Arc::ptr_eq(&original, &document.snapshot()));
-    }
-    let lane = lanes[10];
-    let start = Instant::now();
-    let result = capture(document.project(), views[0], Target::Lane(lane));
-    let elapsed_ns = u64::try_from(start.elapsed().as_nanos()).unwrap();
-    let drag = result.unwrap();
-    samples.push(json!({"phase":"capture_lane", "iteration":0, "elapsed_ns":elapsed_ns, "outcome":"captured"}));
-    for (iteration, delta) in [20., 40., -20.].into_iter().enumerate() {
-        let start = Instant::now();
-        let result = drag.prepare(delta);
-        let elapsed_ns = u64::try_from(start.elapsed().as_nanos()).unwrap();
-        let candidate = result.unwrap().unwrap();
-        samples.push(json!({"phase":"prepare_lane", "iteration":iteration,
-            "delta_world":delta, "elapsed_ns":elapsed_ns, "outcome":"preview"}));
-        let mut expected = original.decoded.project.clone();
-        let Some(DiagramLayout::Scenario(layout)) =
-            &mut expected.diagrams.get_mut(&views[0]).unwrap().layout
-        else {
-            panic!()
-        };
-        layout.lanes[10].x = 2560. + delta;
-        assert_eq!(candidate.project, expected);
-        assert_scene(
-            &candidate.geometry.scene,
-            &lanes,
-            &messages,
-            None,
-            Some((lane, delta)),
-        );
-    }
-    assert_eq!(document.project(), &original.decoded.project);
-    assert_eq!(document.bundle(), &original.bundle);
-    for view in views {
-        assert_eq!(
-            document.project().diagrams[&view],
-            original.decoded.project.diagrams[&view]
-        );
-    }
-    assert_eq!(document.revision(), 0);
-    assert!(!document.dirty() && !document.can_undo() && !document.can_redo());
-    let report = json!({
-        "schema":"scenario_spacing_timing_v1",
-        "fixture":{"lanes":20,"messages":MESSAGE_COUNT,"saved_views":3,"target_index":TARGET_INDEX,"distinct_message_ids":messages.iter().copied().collect::<BTreeSet<_>>().len()},
-        "profile_context":{"debug_assertions":cfg!(debug_assertions),"os":std::env::consts::OS,"arch":std::env::consts::ARCH,
-            "source_pin_from_runner":std::env::var("SCENARIO_SPACING_SOURCE_PIN").ok(),"source_binary_toolchain_binding":"external gate receipt required"},
-        "summaries":{"capture_message":summary(&samples,"capture_message"),"prepare_message":summary(&samples,"prepare_message"),"capture_lane":summary(&samples,"capture_lane"),"prepare_lane":summary(&samples,"prepare_lane")},
-        "samples":samples,
-        "invariant_status":"passed",
-        "limits":"First capture is first in this probe, not cold OS caches. Timers exclude construction/oracles, prior-preview disposal, source write/history, widget rebuild, label shaping, GPU paint and queued input; no responsiveness acceptance or latency threshold. All messages asynchronous; no nested frame/lifecycle stress."
-    });
-    println!("SPACING_TIMING_JSON={report}");
-}

crates/oa-desktop/src/behavior/scenario/spacing/tests.rs

@@ -1,522 +0,0 @@
-use super::*;
-use crate::behavior::scenario_layout::Diagnostic;
-use crate::document::Document;
-use oa_core::{
-    Diagram, DiagramLayout, ProjectionKind, ScenarioLayout, language, source_project::ProjectLimits,
-};
-
-fn id(project: &Project, alias: &str) -> Id {
-    project
-        .identities()
-        .into_iter()
-        .find(|(_, name)| *name == alias)
-        .unwrap()
-        .0
-}
-
-fn fixture(layout: Option<ScenarioLayout>) -> (Document, Id, Id) {
-    let mut project = language::parse(FIXTURE).unwrap();
-    let owner = id(&project, "conversation");
-    let mut add = |alias: &str, layout: Option<ScenarioLayout>| {
-        let diagram = Id::new_v4();
-        project.diagrams.insert(
-            diagram,
-            Diagram {
-                id: diagram,
-                alias: alias.into(),
-                name: alias.into(),
-                description: String::new(),
-                layer: oa_core::Layer::Oa,
-                projection: ProjectionKind::Scenario { scenario: owner },
-                nodes: Default::default(),
-                routes: vec![],
-                view_options: Default::default(),
-                layout: layout.map(DiagramLayout::Scenario),
-            },
-        );
-        diagram
-    };
-    let a = add("saved_a", layout);
-    let b = add("saved_b", Some(ScenarioLayout::default()));
-    let document = Document::from_project(project, ProjectLimits::default()).unwrap();
-    (document, a, b)
-}
-
-fn resolved(project: &Project, diagram: Id, selected: Id) -> ResolvedScenarioPlan {
-    resolve(project, Representation::Saved { diagram }, selected).unwrap()
-}
-
-fn same_geometry(a: &ResolvedScenarioPlan, b: &ResolvedScenarioPlan) {
-    assert_eq!(a.bounds, b.bounds);
-    assert_eq!(a.lanes, b.lanes);
-    assert_eq!(a.plan.frames, b.plan.frames);
-    assert_eq!(a.plan.scopes, b.plan.scopes);
-    let (a, b) = (&a.scene, &b.scene);
-    assert_eq!(a.rows, b.rows);
-    assert_eq!(a.sequence_bounds, b.sequence_bounds);
-    assert_eq!(a.size, b.size);
-    assert_eq!(a.layout_origin, b.layout_origin);
-    assert_eq!(a.lanes, b.lanes);
-    assert_eq!(a.render_lanes, b.render_lanes);
-    assert_eq!(a.activations, b.activations);
-    assert_eq!(a.lifecycle, b.lifecycle);
-    assert_eq!(a.open_calls, b.open_calls);
-    let slots = |scene: &crate::behavior::Scene| {
-        scene
-            .slots
-            .iter()
-            .map(|item| {
-                (
-                    item.slot.parent,
-                    item.slot.before,
-                    item.y,
-                    item.label.clone(),
-                )
-            })
-            .collect::<Vec<_>>()
-    };
-    assert_eq!(slots(a), slots(b));
-    let lines = |scene: &crate::behavior::Scene| {
-        scene
-            .lines
-            .iter()
-            .map(|line| {
-                (
-                    line.id,
-                    line.points.clone(),
-                    line.label_at,
-                    line.label.clone(),
-                    line.dashed,
-                )
-            })
-            .collect::<Vec<_>>()
-    };
-    let boxes = |scene: &crate::behavior::Scene| {
-        scene
-            .boxes
-            .iter()
-            .map(|item| {
-                (
-                    item.id,
-                    item.rect,
-                    item.title.clone(),
-                    item.detail.clone(),
-                    item.marker,
-                )
-            })
-            .collect::<Vec<_>>()
-    };
-    assert_eq!(lines(a), lines(b));
-    assert_eq!(boxes(a), boxes(b));
-}
-
-fn expected_message(project: &Project, diagram: Id, occurrence: Id, y: f32) -> Project {
-    // Independent expected mutation: tests begin with no message overrides.
-    let mut expected = project.clone();
-    expected.diagrams.get_mut(&diagram).unwrap().layout =
-        Some(DiagramLayout::Scenario(ScenarioLayout {
-            lanes: vec![],
-            messages: vec![ScenarioMessagePosition {
-                address: OccurrenceEndpoint {
-                    references: vec![],
-                    occurrence,
-                },
-                send_y: y,
-            }],
-        }));
-    expected
-}
-
-#[test]
-fn one_repeated_message_moves_in_one_view_with_exact_document_undo_redo_and_reopen() {
-    let (mut document, a, b) = fixture(None);
-    let original = document.snapshot();
-    let before = document.project().clone();
-    let first = id(&before, "first");
-    let second = id(&before, "second");
-    let baseline = resolved(&before, a, second);
-    assert_eq!(baseline.scene.rows[&first].1, 148.);
-    assert_eq!(baseline.scene.rows[&second].1, 240.);
-    let untouched = resolved(&before, b, second);
-    let drag = capture(&before, a, Target::Message(second)).unwrap();
-    let preview = drag.prepare(-40.).unwrap().unwrap();
-    let expected = expected_message(&before, a, second, 200.);
-    assert_eq!(preview.project, expected);
-    assert_eq!(preview.geometry.scene.rows[&first].1, 148.);
-    assert_eq!(preview.geometry.scene.rows[&second].1, 200.);
-    let line = preview
-        .geometry
-        .scene
-        .lines
-        .iter()
-        .find(|line| line.id == second)
-        .unwrap();
-    assert_eq!(line.points.first().unwrap().y, 200.);
-    assert_eq!(line.points.last().unwrap().y, 200.);
-    assert_eq!(
-        preview.geometry.scene.activations,
-        baseline.scene.activations
-    );
-    assert_eq!(preview.geometry.scene.lifecycle, baseline.scene.lifecycle);
-    same_geometry(&resolved(&preview.project, b, second), &untouched);
-    assert_eq!(drag.original, before);
-    assert!(std::sync::Arc::ptr_eq(&original, &document.snapshot()));
-    assert!(!document.can_undo());
-
-    let returned_selection = document.execute(preview.command).unwrap();
-    assert_eq!(
-        returned_selection,
-        Some(a),
-        "controller must preserve the dragged semantic selection separately"
-    );
-    assert_eq!(document.project(), &expected);
-    assert_eq!(document.revision(), 1);
-    let accepted = document.bundle().clone();
-    same_geometry(&resolved(document.project(), a, second), &preview.geometry);
-    assert!(document.undo());
-    assert_eq!(document.project(), &before);
-    assert_eq!(document.bundle(), &original.bundle);
-    assert!(!document.can_undo());
-    assert!(document.redo());
-    assert_eq!(document.project(), &expected);
-    assert_eq!(document.bundle(), &accepted);
-    let reopened = Document::from_bundle(accepted, ProjectLimits::default()).unwrap();
-    assert_eq!(reopened.project(), &expected);
-    same_geometry(&resolved(reopened.project(), a, second), &preview.geometry);
-    assert!(!reopened.dirty() && !reopened.can_undo());
-}
-
-#[test]
-fn horizontal_lane_move_changes_actual_header_and_attached_endpoints_only_in_selected_view() {
-    let (document, a, b) = fixture(None);
-    let before = document.project();
-    let right = id(before, "right");
-    let first = id(before, "first");
-    let other = resolved(before, b, right);
-    let preview = capture(before, a, Target::Lane(right))
-        .unwrap()
-        .prepare(100.)
-        .unwrap()
-        .unwrap();
-    let mut expected = before.clone();
-    expected.diagrams.get_mut(&a).unwrap().layout = Some(DiagramLayout::Scenario(ScenarioLayout {
-        lanes: vec![ScenarioLanePosition {
-            lifeline: right,
-            x: 500.,
-        }],
-        messages: vec![],
-    }));
-    assert_eq!(preview.project, expected);
-    assert_eq!(preview.geometry.scene.lanes[&right], 500.);
-    let header = preview
-        .geometry
-        .scene
-        .boxes
-        .iter()
-        .find(|item| item.id == right)
-        .unwrap();
-    assert_eq!(header.rect.center_x(), 500.);
-    let line = preview
-        .geometry
-        .scene
-        .lines
-        .iter()
-        .find(|line| line.id == first)
-        .unwrap();
-    assert_eq!(line.points.first().unwrap().x, 160.);
-    assert_eq!(line.points.last().unwrap().x, 500.);
-    assert!(line.points.iter().all(|point| point.y == 148.));
-    same_geometry(&resolved(&preview.project, b, right), &other);
-    assert_eq!(document.project(), before);
-    assert!(!document.dirty() && !document.can_undo());
-}
-
-#[test]
-fn drawn_unassigned_lifeline_can_move_without_assigning_a_semantic_participant() {
-    let (document, a, _) = fixture(None);
-    let mut project = document.project().clone();
-    let owner = id(&project, "conversation");
-    let lane = project
-        .add_element(
-            Kind::Lifeline,
-            oa_core::Layer::Oa,
-            "Unassigned header",
-            Some(owner),
-        )
-        .unwrap();
-    let document = Document::from_project(project, ProjectLimits::default()).unwrap();
-    let baseline = resolved(document.project(), a, lane);
-    assert!(!baseline.scene.lanes.contains_key(&lane));
-    let before_header = baseline
-        .scene
-        .boxes
-        .iter()
-        .find(|item| item.id == lane)
-        .unwrap()
-        .rect;
-    let preview = capture(document.project(), a, Target::Lane(lane))
-        .unwrap()
-        .prepare(70.)
-        .unwrap()
-        .unwrap();
-    let after_header = preview
-        .geometry
-        .scene
-        .boxes
-        .iter()
-        .find(|item| item.id == lane)
-        .unwrap()
-        .rect;
-    assert_eq!(after_header.x, before_header.x + 70.);
-    assert_eq!(after_header.y, before_header.y);
-    assert_eq!(after_header.size(), before_header.size());
-    assert_eq!(preview.project.elements, document.project().elements);
-    assert_eq!(preview.project.relations, document.project().relations);
-    assert!(!document.can_undo());
-}
-
-#[test]
-fn self_call_spacing_uses_send_y_and_preserves_reply_and_actual_activation_finish() {
-    let (document, a, _) = fixture(None);
-    let before = document.project();
-    let call = id(before, "call");
-    let reply = id(before, "reply");
-    let baseline = resolved(before, a, call);
-    let preview = capture(before, a, Target::Message(call))
-        .unwrap()
-        .prepare(-22.)
-        .unwrap()
-        .unwrap();
-    assert_eq!(preview.project, expected_message(before, a, call, 310.));
-    let line = preview
-        .geometry
-        .scene
-        .lines
-        .iter()
-        .find(|line| line.id == call)
-        .unwrap();
-    assert_eq!(line.points.first().unwrap().y, 310.);
-    assert_eq!(line.points.last().unwrap().y, 334.);
-    assert_eq!(preview.geometry.scene.rows[&reply].1, 424.);
-    assert_eq!(preview.geometry.scene.activations.len(), 1);
-    let mut expected_activation = baseline.scene.activations.clone();
-    expected_activation[0].rect.y = 334.;
-    expected_activation[0].rect.height = 90.;
-    assert_eq!(preview.geometry.scene.activations, expected_activation);
-    assert_eq!(preview.geometry.scene.lifecycle, baseline.scene.lifecycle);
-}
-
-#[test]
-fn feasible_spacing_crossing_remains_authored_with_diagnostic_and_unchanged_steps() {
-    let (document, a, _) = fixture(None);
-    let before = document.project();
-    let first = id(before, "first");
-    let second = id(before, "second");
-    let owner = id(before, "conversation");
-    let preview = capture(before, a, Target::Message(second))
-        .unwrap()
-        .prepare(-120.)
-        .unwrap()
-        .unwrap();
-    assert_eq!(preview.project, expected_message(before, a, second, 120.));
-    assert_eq!(preview.geometry.scene.rows[&second].1, 120.);
-    assert_eq!(preview.geometry.scene.rows[&first].1, 148.);
-    assert_eq!(
-        preview.project.elements[&owner].steps(),
-        before.elements[&owner].steps()
-    );
-    let shown = crate::behavior::scenario_layout::presentation::present(
-        &preview.project,
-        Representation::Saved { diagram: a },
-        second,
-    );
-    assert!(shown.capabilities().coordinate_input);
-    assert!(
-        shown
-            .diagnostics()
-            .contains(&Diagnostic::SourceOrderCrossing {
-                scope: owner,
-                before: first,
-                after: second
-            })
-    );
-}
-
-#[test]
-fn unsupported_self_call_move_is_refused_and_automatic_fallback_is_not_editable_capture() {
-    let (document, a, _) = fixture(None);
-    let before = document.project();
-    let call = id(before, "call");
-    let drag = capture(before, a, Target::Message(call)).unwrap();
-    let Err(Refusal::Geometry(issues)) = drag.prepare(118.) else {
-        panic!("send450 / receive474 after reply424 must be refused")
-    };
-    assert!(issues.iter().any(|issue| matches!(issue, GeometryIssue::TypedActivationCrossingNotSupported { call: id, .. } if *id == call)));
-    assert_eq!(&drag.original, before);
-    let invalid_geometry = expected_message(before, a, call, 450.);
-    let shown = crate::behavior::scenario_layout::presentation::present(
-        &invalid_geometry,
-        Representation::Saved { diagram: a },
-        call,
-    );
-    assert!(shown.capabilities().geometry_navigation && !shown.capabilities().coordinate_input);
-    assert!(matches!(
-        capture(&invalid_geometry, a, Target::Message(call)),
-        Err(Refusal::Geometry(_))
-    ));
-    assert!(!document.dirty() && !document.can_undo());
-}
-
-#[test]
-fn invalid_view_foreign_identity_and_latent_message_are_not_spacing_targets() {
-    let (document, a, b) = fixture(None);
-    let p = document.project();
-    let unfinished = id(p, "unfinished");
-    let source = id(p, "source");
-    assert!(matches!(
-        capture(p, Id::nil(), Target::Lane(source)),
-        Err(Refusal::InvalidSavedView(_))
-    ));
-    for target in [
-        Target::Lane(source),
-        Target::Lane(b),
-        Target::Message(source),
-        Target::Message(unfinished),
-    ] {
-        assert!(
-            matches!(capture(p, a, target), Err(Refusal::TargetNotRendered(found)) if found == target)
-        );
-    }
-    // A stored latent coordinate is not permission to fabricate a painted arrow.
-    let mut latent = expected_message(p, a, unfinished, 2000.);
-    let foreign_owner = latent
-        .add_element(Kind::Scenario, oa_core::Layer::Oa, "Foreign", None)
-        .unwrap();
-    let foreign_lane = latent
-        .add_element(
-            Kind::Lifeline,
-            oa_core::Layer::Oa,
-            "Foreign lane",
-            Some(foreign_owner),
-        )
-        .unwrap();
-    *latent
-        .elements
-        .get_mut(&foreign_lane)
-        .unwrap()
-        .shared_mut()
-        .unwrap() = SharedBody::Lifeline {
-        represented: Some(source),
-    };
-    let latent_document = Document::from_project(latent, ProjectLimits::default()).unwrap();
-    assert!(matches!(
-        capture(latent_document.project(), a, Target::Message(unfinished)),
-        Err(Refusal::TargetNotRendered(_))
-    ));
-    assert!(matches!(
-        capture(latent_document.project(), a, Target::Lane(foreign_lane)),
-        Err(Refusal::TargetNotRendered(_))
-    ));
-}
-
-#[test]
-fn zero_motion_return_to_start_and_subprecision_preserve_sparse_intent_and_real_redo() {
-    let parsed = language::parse(FIXTURE).unwrap();
-    let left = id(&parsed, "left");
-    let second = id(&parsed, "second");
-    let layouts = [
-        None,
-        Some(ScenarioLayout::default()),
-        Some(ScenarioLayout {
-            lanes: vec![],
-            messages: vec![ScenarioMessagePosition {
-                address: OccurrenceEndpoint {
-                    references: vec![],
-                    occurrence: second,
-                },
-                send_y: 240.,
-            }],
-        }),
-        Some(ScenarioLayout {
-            lanes: vec![ScenarioLanePosition {
-                lifeline: left,
-                x: -0.,
-            }],
-            messages: vec![],
-        }),
-    ];
-    for (index, layout) in layouts.into_iter().enumerate() {
-        let (mut document, a, _) = fixture(layout);
-        let owner = id(document.project(), "conversation");
-        document
-            .execute(Command::Rename(owner, "A real redo entry".into()))
-            .unwrap();
-        let redo = document.snapshot();
-        assert!(document.undo());
-        let before = document.snapshot();
-        let revision = document.revision();
-        let target = if index == 3 {
-            Target::Lane(left)
-        } else {
-            Target::Message(second)
-        };
-        let drag = capture(document.project(), a, target).unwrap();
-        if index == 3 {
-            let Some(DiagramLayout::Scenario(layout)) = &drag.original.diagrams[&a].layout else {
-                panic!()
-            };
-            assert_eq!(layout.lanes[0].x.to_bits(), (-0_f32).to_bits());
-        }
-        assert!(drag.prepare(10.).unwrap().is_some());
-        for delta in [0., -0.] {
-            assert!(drag.prepare(delta).unwrap().is_none());
-        }
-        if index != 3 {
-            assert!(drag.prepare(f32::from_bits(1)).unwrap().is_none());
-        }
-        assert_eq!(
-            serde_json::to_vec(&drag.original).unwrap(),
-            serde_json::to_vec(document.project()).unwrap()
-        );
-        assert!(std::sync::Arc::ptr_eq(&before, &document.snapshot()));
-        assert_eq!(document.bundle(), &before.bundle);
-        assert_eq!(document.revision(), revision);
-        assert!(document.can_redo());
-        assert!(document.redo());
-        assert_eq!(document.project(), &redo.decoded.project);
-        assert_eq!(document.bundle(), &redo.bundle);
-    }
-}
-
-#[test]
-fn malformed_or_out_of_range_motion_cannot_mutate_original() {
-    let (document, a, _) = fixture(None);
-    let drag = capture(
-        document.project(),
-        a,
-        Target::Message(id(document.project(), "second")),
-    )
-    .unwrap();
-    for delta in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY] {
-        assert!(matches!(drag.prepare(delta), Err(Refusal::InvalidDelta)));
-    }
-    assert!(matches!(drag.prepare(f32::MAX), Err(Refusal::Command(_))));
-    assert_eq!(&drag.original, document.project());
-    assert!(!document.dirty() && !document.can_undo());
-}
-
-const FIXTURE: &str = r#"arcadia 7;
-project spacing_probe "Saved spacing probe" id "71000000-0000-4000-8000-000000000001" {
- oa_activity source "Source" id "71000000-0000-4000-8000-000000000002" {}
- oa_activity target "Target" id "71000000-0000-4000-8000-000000000003" {}
- interaction exchange "Repeated exchange" id "71000000-0000-4000-8000-000000000004" { source @source; target @target; }
- oa_scenario conversation "Conversation" id "71000000-0000-4000-8000-000000000005" { viewpoint OperationalActivity; steps [@first, @second, @call, @reply, @unfinished]; }
- oa_lifeline left "Left" id "71000000-0000-4000-8000-000000000006" { parent @conversation; represented @source; }
- oa_lifeline right "Right" id "71000000-0000-4000-8000-000000000007" { parent @conversation; represented @target; }
- oa_occurrence first "First" id "71000000-0000-4000-8000-000000000008" { parent @conversation; body { Exchange { exchange @exchange; sender @left; receiver @right; message_kind Asynchronous; }; }; }
- oa_occurrence second "Second" id "71000000-0000-4000-8000-000000000009" { parent @conversation; body { Exchange { exchange @exchange; sender @left; receiver @right; message_kind Asynchronous; }; }; }
- oa_occurrence call "Call" id "71000000-0000-4000-8000-00000000000a" { parent @conversation; body { Exchange { exchange none; sender @right; receiver @right; message_kind Call; }; }; }
- oa_occurrence reply "Reply" id "71000000-0000-4000-8000-00000000000b" { parent @conversation; body { Exchange { exchange none; sender @right; receiver @right; message_kind Reply; reply_to @call; }; }; }
- oa_occurrence unfinished "Unfinished" id "71000000-0000-4000-8000-00000000000c" { parent @conversation; body { Exchange { exchange @exchange; sender @left; receiver none; message_kind Asynchronous; }; }; }
-}
-"#;

crates/oa-desktop/src/behavior/scenario/usage/tests.rs

@@ -10,10 +10,10 @@ fn add_occurrence(p: &mut Project, owner: Id, name: &str, body: OccurrenceBody)
         precondition: String::new(),
         postcondition: String::new(),
     };
-    if let Some(steps) = p.elements.get_mut(&owner).unwrap().steps_mut()
-        && !steps.contains(&id)
-    {
-        steps.push(id);
+    if let Some(steps) = p.elements.get_mut(&owner).unwrap().steps_mut() {
+        if !steps.contains(&id) {
+            steps.push(id);
+        }
     }
     id
 }

crates/oa-desktop/src/behavior/scenario/workspace.rs

@@ -78,43 +78,11 @@ pub fn view<'a>(app: &'a App, owner: Id, out: Column<'a, Message>) -> Element<'a
     };
     let tool = state.canvas_tool(owner);
     let clean = !app.behavior.has_pending() && !app.draft_dirty() && !app.source_dirty();
-    // Resolve once per accepted view. An active spacing session owns its exact
-    // prepared geometry; borrowing it also retains the canvas input state.
-    let preview = state.spacing_paint(context, app.camera_epoch);
-    let shown = preview
-        .is_none()
-        .then(|| presentation::present(p, context.representation, app.selected));
-    let capabilities = shown.as_ref().map_or(
-        presentation::PresentationCapabilities {
-            geometry_navigation: true,
-            coordinate_input: true,
-        },
-        ScenarioPresentation::capabilities,
-    );
+    let shown = presentation::present(p, context.representation, app.selected);
+    let capabilities = shown.capabilities();
     let coordinate_input = clean && capabilities.coordinate_input;
-    let notice = if let Some(paint) = &preview {
-        display_notice_parts(
-            p,
-            context.representation,
-            &presentation::PresentationStatus::Ready,
-            paint.original_diagnostics,
-            paint.original_latent,
-        )
-    } else {
-        display_notice(p, shown.as_ref().expect("normal presentation"))
-    };
-    let camera_state = preview
-        .as_ref()
-        .map(|paint| camera::Camera {
-            scale: paint.scene.scale,
-            pan: paint.scene.camera_pan,
-        })
-        .or_else(|| {
-            shown
-                .as_ref()
-                .and_then(ScenarioPresentation::bounds)
-                .map(|bounds| presentation.camera(bounds))
-        });
+    let notice = display_notice(p, &shown);
+    let camera_state = shown.bounds().map(|bounds| presentation.camera(bounds));
     let scale = camera_state.map_or(1., |camera| camera.scale);
     let scope = super::super::canvas_workspace::Scope {
         document: context.document,
@@ -127,56 +95,23 @@ pub fn view<'a>(app: &'a App, owner: Id, out: Column<'a, Message>) -> Element<'a
         && capabilities.geometry_navigation
         && super::super::canvas_workspace::keyboard_enabled(app);
     let camera = move |e| Message::ScenarioCanvas(CanvasEvent::Camera(context, scope.epoch, e));
-    let raw_canvas: Option<Element<'a, Message>> = if let Some(paint) = &preview {
-        Some(
-            canvas::Canvas::new(paint.scene)
-                .width(Fill)
-                .height(Fill)
-                .into(),
-        )
-    } else if let Some(mut scene) = shown.and_then(ScenarioPresentation::into_scene) {
+    let canvas: Element<'a, Message> = if let Some(mut scene) = shown.into_scene() {
         let camera_state = camera_state.expect("displayed Scene has complete bounds");
         scene.scale = camera_state.scale;
         scene.camera_pan = camera_state.pan;
         scene.interaction = Some((context, tool, clean));
-        scene.spacing_stamp = (coordinate_input
-            && !app.source_rename.open()
-            && keyboard
-            && matches!(context.representation, Representation::Saved { .. }))
-        .then_some(spacing::Stamp {
-            context,
-            camera_epoch: app.camera_epoch,
-        });
         scene.coordinate_input = capabilities.coordinate_input;
         scene.pending_placement = coordinate_input
             .then(|| state.pending_placement(owner))
             .flatten();
-        Some(canvas::Canvas::new(scene).width(Fill).height(Fill).into())
-    } else {
-        None
-    };
-    let canvas: Element<'a, Message> = if let Some(raw_canvas) = raw_canvas {
-        // Keep this Stack in both branches: replacing the Canvas with a wrapper
-        // on Begin would discard its pointer capture before Move/Finish.
-        let mut layers = iced::widget::stack![raw_canvas];
-        if let Some(paint) = &preview {
-            let feedback = spacing_feedback(p, paint.refusal, paint.diagnostics);
-            layers = layers.push(
-                container(
-                    container(text(feedback).size(12))
-                        .padding(6)
-                        .width(Fill)
-                        .style(style::card),
-                )
-                .width(Fill)
-                .align_bottom(Fill)
-                .padding(8),
-            );
-        }
         container(
             sensor(
                 super::super::canvas_workspace::Viewport::new(
-                    layers, scope, scale, keyboard, camera,
+                    canvas::Canvas::new(scene).width(Fill).height(Fill),
+                    scope,
+                    scale,
+                    keyboard,
+                    camera,
                 )
                 .pan_background(tool == CanvasTool::Select || !capabilities.coordinate_input),
             )
@@ -262,20 +197,13 @@ pub fn view<'a>(app: &'a App, owner: Id, out: Column<'a, Message>) -> Element<'a
             .find(|choice| choice.representation == context.representation)
             .cloned();
         header = header.push(
-            container(
-                pick_list(choices, selected, move |choice: ArrangementChoice| {
-                    Message::ScenarioCanvas(CanvasEvent::Representation(
-                        context,
-                        choice.representation,
-                    ))
-                })
-                .placeholder("Choose arrangement")
-                .text_size(12)
-                .padding(5)
-                .width(Fill),
-            )
-            .width(Fill)
-            .id("scenario-arrangement-picker"),
+            pick_list(choices, selected, move |choice: ArrangementChoice| {
+                Message::ScenarioCanvas(CanvasEvent::Representation(context, choice.representation))
+            })
+            .placeholder("Choose arrangement")
+            .text_size(12)
+            .padding(5)
+            .width(Fill),
         );
     }
     if capabilities.geometry_navigation {
@@ -294,15 +222,7 @@ pub fn view<'a>(app: &'a App, owner: Id, out: Column<'a, Message>) -> Element<'a
         ));
     }
     let entries = [
-        (
-            "S",
-            if matches!(context.representation, Representation::Saved { .. }) {
-                "Select / move messages and lifelines"
-            } else {
-                "Select / reorder occurrences"
-            },
-            CanvasTool::Select,
-        ),
+        ("S", "Select / reorder occurrences", CanvasTool::Select),
         (
             "L",
             "Lifeline: click to choose represented work or participant",
@@ -378,12 +298,8 @@ pub fn view<'a>(app: &'a App, owner: Id, out: Column<'a, Message>) -> Element<'a
     );
     let mut details = column![
         text(format!("Selected: {}", p.named(app.selected))).size(12),
-        container(button(text("Properties").size(12)).on_press_maybe(
-            (clean && properties_target(p, context, app.selected)).then_some(
-                Message::ScenarioCanvas(CanvasEvent::Properties(context, app.selected)),
-            ),
-        ))
-        .id("scenario-properties")
+        button(text("Properties").size(12))
+            .on_press_maybe(clean.then_some(Message::EditProperties(app.selected)))
     ]
     .spacing(6);
     if referenced_scenario(p, owner, app.selected).is_some() {
@@ -394,10 +310,6 @@ pub fn view<'a>(app: &'a App, owner: Id, out: Column<'a, Message>) -> Element<'a
             ))),
         ));
     }
-    details = details.push(text("Scenario order").size(13));
-    if matches!(context.representation, Representation::Saved { .. }) {
-        details = details.push(text("↑ and ↓ change the shared Scenario order. Saved message positions are retained; automatically placed items may move.").size(11));
-    }
     let details = details_pane(
         context,
         state.scroll_restore(context, ScrollArea::Page),
@@ -728,24 +640,8 @@ pub fn view<'a>(app: &'a App, owner: Id, out: Column<'a, Message>) -> Element<'a
 }
 
 fn display_notice<'a>(p: &Project, shown: &ScenarioPresentation) -> Element<'a, Message> {
-    display_notice_parts(
-        p,
-        shown.requested(),
-        shown.status(),
-        shown.diagnostics(),
-        shown.latent_messages(),
-    )
-}
-
-fn display_notice_parts<'a>(
-    p: &Project,
-    requested: Representation,
-    status: &presentation::PresentationStatus,
-    diagnostics: &[super::super::scenario_layout::Diagnostic],
-    latent_messages: &[Id],
-) -> Element<'a, Message> {
     use super::super::scenario_layout::{Diagnostic, presentation::PresentationStatus};
-    let title = match requested {
+    let title = match shown.requested() {
         Representation::Saved { diagram } => p.diagrams.get(&diagram).map_or_else(
             || "Unavailable saved Scenario view".into(),
             |view| format!("Saved view · {}", view.name),
@@ -753,9 +649,9 @@ fn display_notice_parts<'a>(
         Representation::Derived { owner } => format!("Automatic view · {}", p.named(owner)),
     };
     let mut notice = column![text(title).size(14)].spacing(4);
-    match status {
+    match shown.status() {
         PresentationStatus::Ready => {
-            for diagnostic in diagnostics.iter().take(3) {
+            for diagnostic in shown.diagnostics().iter().take(3) {
                 let explanation = match diagnostic {
                     Diagnostic::SourceOrderCrossing { before, after, .. } => format!(
                         "Saved spacing places '{}' below '{}'. The Scenario order is unchanged.",
@@ -770,11 +666,11 @@ fn display_notice_parts<'a>(
                 };
                 notice = notice.push(text(explanation).size(12));
             }
-            if diagnostics.len() > 3 {
+            if shown.diagnostics().len() > 3 {
                 notice = notice.push(
                     text(format!(
                         "{} additional spacing notices are retained.",
-                        diagnostics.len() - 3
+                        shown.diagnostics().len() - 3
                     ))
                     .size(12),
                 );
@@ -791,8 +687,8 @@ fn display_notice_parts<'a>(
             notice = notice.push(text("This view is unavailable. Its identity or automatic geometry cannot be resolved; the model and source remain available for inspection and repair.").size(12));
         }
     }
-    if !latent_messages.is_empty() {
-        notice = notice.push(text(format!("{} unfinished message position(s) are retained until their endpoints are complete.", latent_messages.len())).size(12));
+    if !shown.latent_messages().is_empty() {
+        notice = notice.push(text(format!("{} unfinished message position(s) are retained until their endpoints are complete.", shown.latent_messages().len())).size(12));
     }
     notice = notice.push(button("Open selected source").on_press(Message::SourceForSelection));
     container(notice)
@@ -802,43 +698,6 @@ fn display_notice_parts<'a>(
         .into()
 }
 
-fn spacing_feedback(
-    p: &Project,
-    refusal: Option<&spacing::Refusal>,
-    diagnostics: &[super::super::scenario_layout::Diagnostic],
-) -> String {
-    if let Some(refusal) = refusal {
-        let reason = match refusal {
-            spacing::Refusal::Geometry(issues) => issues
-                .first()
-                .map(|issue| geometry_problem(p, issue))
-                .unwrap_or_else(|| "This position cannot be displayed.".into()),
-            spacing::Refusal::Command(error) => error.clone(),
-            _ => "This position is unavailable in the current view.".into(),
-        };
-        return format!(
-            "Position unavailable · {reason} Move back to a supported position, or release to cancel."
-        );
-    }
-    let explanation = match diagnostics.first() {
-        Some(super::super::scenario_layout::Diagnostic::SourceOrderCrossing {
-            before,
-            after,
-            ..
-        }) => format!(
-            " '{}' is below '{}'; Scenario order stays unchanged.",
-            p.named(*before),
-            p.named(*after)
-        ),
-        Some(super::super::scenario_layout::Diagnostic::FrameExtendsPastFollowingAnchor {
-            frame,
-            following,
-        }) => format!(" '{}' overlaps '{}'.", p.named(*frame), p.named(*following)),
-        None => " Scenario order stays unchanged.".into(),
-    };
-    format!("Spacing preview · Release to finish; Escape cancels.{explanation}")
-}
-
 fn geometry_problem(p: &Project, issue: &super::super::scenario_layout::GeometryIssue) -> String {
     use super::super::scenario_layout::GeometryIssue;
     match issue {
@@ -930,12 +789,6 @@ fn editor_panel<'a, R: iced::advanced::text::Renderer + 'a>(
 #[cfg(all(test, debug_assertions))]
 mod tests;
 
-#[cfg(all(test, debug_assertions))]
-mod spacing_tests;
-
-#[cfg(all(test, debug_assertions))]
-mod details_tests;
-
 fn sequence_rows<'a>(
     p: &'a Project,
     context: Context,

crates/oa-desktop/src/behavior/scenario/workspace/details_tests.rs

@@ -1,443 +0,0 @@
-//! Mounted Scenario Details → inspector regression and retained-intent guards.
-use super::*;
-use crate::behavior::canvas_workspace::tests::Mounted;
-use crate::behavior::scenario_layout::resolve;
-use iced::advanced::widget;
-use iced::{Vector, keyboard};
-use std::sync::Arc;
-
-const FIXTURE: &str = include_str!("../../../app/diagram_usages/tests/saved_scenario.arcadia");
-
-fn id(app: &App, alias: &str) -> Id {
-    app.project()
-        .identities()
-        .into_iter()
-        .find(|(_, name)| *name == alias)
-        .unwrap()
-        .0
-}
-fn send(app: &mut App, event: impl FnOnce(Context) -> CanvasEvent) {
-    let context = app.scenario_context().unwrap();
-    let _ = app.update(Message::ScenarioCanvas(event(context)));
-}
-fn setup() -> (App, Id, Id) {
-    let mut app = App::with_project(oa_core::language::parse(FIXTURE).unwrap());
-    let owner = id(&app, "incident_response");
-    let diagram = id(&app, "incident_readable");
-    let message = id(&app, "initial_report");
-    let _ = app.update(Message::Select(owner));
-    let _ = app.update(Message::Diagram(crate::app::Choice {
-        id: diagram,
-        label: "A".into(),
-    }));
-    send(&mut app, |c| CanvasEvent::Select(c, message));
-    app.window_size = Size::new(1440., 1000.);
-    (app, diagram, message)
-}
-fn open_focused_details(app: &mut App) {
-    if !app.behavior.scenario.focused() {
-        send(app, CanvasEvent::Focus);
-    }
-    if app.behavior.scenario.presentation.shelf.is_none() {
-        send(app, |c| CanvasEvent::Shelf(c, Shelf::Selection));
-    }
-}
-fn stored_camera(app: &App) -> (Vector, Option<f32>, bool) {
-    let p = &app.behavior.scenario.presentation;
-    (p.pan, p.zoom, p.fit)
-}
-
-#[tokio::test]
-async fn focused_saved_details_opens_real_editable_inspector_and_returns_to_same_view() {
-    let (mut app, diagram, message) = setup();
-    let _ = app.update(Message::InspectorTab(
-        crate::navigation::InspectorTab::Connections,
-    ));
-    let mut mounted = Mounted::new(&mut app).await;
-    open_focused_details(&mut app);
-    mounted.settle(&mut app).await;
-    let before = mounted.geometry(&app);
-    assert!(!before.scrolls.contains_key(&widget::Id::new("inspector")));
-    let (details, offset) = before.scrolls[&widget::Id::new("scenario-details")];
-    let button = before.bounds("scenario-properties").center() - offset;
-    assert!(
-        details.contains(button),
-        "Properties must be actually visible"
-    );
-    let context = app.scenario_context().unwrap();
-    let camera = stored_camera(&app);
-    let original = app.document.snapshot();
-    let bundle = app.document.bundle().clone();
-    let messages = mounted.click(&mut app, button).await;
-    assert!(messages.iter().any(|event| matches!(event,
-        Message::ScenarioCanvas(CanvasEvent::Properties(c, selected))
-        if *c == context && *selected == message)));
-    mounted.settle(&mut app).await;
-    assert!(!app.behavior.scenario.focused());
-    assert!(app.behavior.scenario.presentation.shelf.is_none());
-    assert_eq!(
-        app.inspector_tab,
-        crate::navigation::InspectorTab::Properties
-    );
-    assert_eq!(app.selected, message);
-    assert_eq!(app.active_diagram, Some(diagram));
-    assert_eq!(app.page, crate::app::Page::Behavior);
-    let current = app.scenario_context().unwrap();
-    assert_eq!(current.representation, context.representation);
-    assert_eq!(current.visit, context.visit);
-    assert_eq!(
-        stored_camera(&app),
-        camera,
-        "restoring panels retains camera intent"
-    );
-    assert!(Arc::ptr_eq(&original, &app.document.snapshot()));
-    assert_eq!(app.document.bundle(), &bundle);
-    assert!(!app.document.can_undo() && !app.document.can_redo());
-
-    let shown = mounted.geometry(&app);
-    assert!(
-        !shown
-            .scrolls
-            .contains_key(&widget::Id::new("scenario-details"))
-    );
-    let (inspector, offset) = shown.scrolls[&widget::Id::new("inspector")];
-    assert!(inspector.width > 250. && inspector.height > 500.);
-    // Production Properties places Name before the other scalar text inputs.
-    // Account for the retained inspector scroll, rather than clicking content coordinates.
-    let input = shown
-        .text_inputs
-        .iter()
-        .map(|bounds| bounds.center() - offset)
-        .filter(|point| inspector.contains(*point))
-        .min_by(|a, b| a.y.total_cmp(&b.y))
-        .expect("visible editable property");
-    mounted.click(&mut app, input).await;
-    let typed = mounted
-        .batch(
-            &mut app,
-            &[iced::Event::Keyboard(keyboard::Event::KeyPressed {
-                key: keyboard::Key::Character("x".into()),
-                modified_key: keyboard::Key::Character("x".into()),
-                physical_key: keyboard::key::Physical::Unidentified(
-                    keyboard::key::NativeCode::Unidentified,
-                ),
-                location: keyboard::Location::Standard,
-                modifiers: keyboard::Modifiers::empty(),
-                text: Some("x".into()),
-                repeat: false,
-            })],
-            mouse::Cursor::Available(input),
-        )
-        .await;
-    assert!(
-        typed
-            .iter()
-            .any(|message| matches!(message, Message::Field(path, _) if path == "/name")),
-        "real Name editor must publish its edit: {typed:?}"
-    );
-    assert!(app.draft_dirty());
-    assert!(
-        Arc::ptr_eq(&original, &app.document.snapshot()),
-        "typing is only a draft"
-    );
-    let _ = app.update(Message::RevertProperties);
-    assert!(!app.draft_dirty());
-    send(&mut app, CanvasEvent::Focus);
-    mounted.settle(&mut app).await;
-    let returned = mounted.geometry(&app);
-    assert!(!returned.scrolls.contains_key(&widget::Id::new("inspector")));
-    let viewport = returned.bounds("scenario-viewport");
-    assert_eq!(app.selected, message);
-    assert_eq!(app.scenario_context().unwrap().visit, context.visit);
-    assert_eq!(
-        app.scenario_context().unwrap().representation,
-        context.representation
-    );
-    assert_eq!(stored_camera(&app), camera);
-    let geometry = resolve(app.project(), context.representation, message).unwrap();
-    let line = geometry
-        .scene
-        .lines
-        .iter()
-        .find(|line| line.id == message)
-        .unwrap();
-    let effective = app.behavior.scenario.presentation.camera(geometry.bounds);
-    let point = viewport.position()
-        + effective.pan
-        + Vector::new(line.points[0].x, line.points[0].y) * effective.scale;
-    assert!(
-        viewport.contains(point),
-        "the same selected message remains in fitted view"
-    );
-    assert!(Arc::ptr_eq(&original, &app.document.snapshot()));
-    assert_eq!(app.document.bundle(), &bundle);
-    assert!(!app.document.can_undo() && !app.document.can_redo());
-}
-
-#[test]
-fn details_properties_refuses_pending_property_source_and_behavior_drafts_without_apply() {
-    for kind in 0..3 {
-        let (mut app, _, message) = setup();
-        open_focused_details(&mut app);
-        match kind {
-            0 => {
-                let _ = app.update(Message::Field(
-                    "/name".into(),
-                    "Retained property draft".into(),
-                ));
-                assert!(app.draft_dirty());
-            }
-            1 => {
-                let _ = app.update(Message::SourceEdit(
-                    iced::widget::text_editor::Action::Edit(
-                        iced::widget::text_editor::Edit::Insert('x'),
-                    ),
-                ));
-                assert!(app.source_dirty());
-            }
-            _ => {
-                let owner = app.scenario_context().unwrap().scenario;
-                let _ = app.update(Message::Behavior(super::super::super::Event::Scenario(
-                    Event::Start(owner, Tool::Lifeline),
-                )));
-                assert!(app.behavior.has_pending());
-            }
-        }
-        let snapshot = app.document.snapshot();
-        let bundle = app.document.bundle().clone();
-        let property = app.draft.as_ref().unwrap().materialize();
-        let source = app.source_editor.text();
-        let behavior = app.behavior.recovery_snapshot();
-        let camera = app.behavior.scenario.camera_boundary();
-        let context = app.scenario_context().unwrap();
-        let epochs = (app.canvas_epoch, app.camera_epoch);
-        let _ = app.update(Message::ScenarioCanvas(CanvasEvent::Properties(
-            context, message,
-        )));
-        assert!(app.behavior.scenario.camera_boundary() == camera);
-        assert_eq!(app.scenario_context(), Some(context));
-        assert_eq!((app.canvas_epoch, app.camera_epoch), epochs);
-        assert_eq!(app.draft.as_ref().unwrap().materialize(), property);
-        assert_eq!(app.source_editor.text(), source);
-        assert_eq!(app.behavior.recovery_snapshot(), behavior);
-        assert_eq!(app.selected, message);
-        assert!(Arc::ptr_eq(&snapshot, &app.document.snapshot()));
-        assert_eq!(app.document.bundle(), &bundle);
-        assert!(!app.document.can_undo() && !app.document.can_redo());
-    }
-}
-
-#[tokio::test]
-async fn focused_details_opens_current_saved_view_properties_after_following_diagram_picker() {
-    let (mut app, a, _) = setup();
-    let b = id(&app, "incident_wide");
-    // Selecting the current view record makes the real picker follow that
-    // record selection to B. Do not seed selected=B or its property draft.
-    let _ = app.update(Message::Select(a));
-    assert_eq!(app.selected, a);
-    let _ = app.update(Message::Diagram(crate::app::Choice {
-        id: b,
-        label: "B".into(),
-    }));
-    assert_eq!(app.selected, b);
-    assert_eq!(app.draft.as_ref().unwrap().original, b);
-    assert_eq!(
-        app.scenario_context().unwrap().representation,
-        Representation::Saved { diagram: b }
-    );
-    let _ = app.update(Message::InspectorTab(
-        crate::navigation::InspectorTab::Connections,
-    ));
-    let mut mounted = Mounted::new(&mut app).await;
-    open_focused_details(&mut app);
-    mounted.settle(&mut app).await;
-    let context = app.scenario_context().unwrap();
-    let camera = stored_camera(&app);
-    let snapshot = app.document.snapshot();
-    let bundle = app.document.bundle().clone();
-    let before = mounted.geometry(&app);
-    assert!(!before.scrolls.contains_key(&widget::Id::new("inspector")));
-    let (details, offset) = before.scrolls[&widget::Id::new("scenario-details")];
-    let point = before.bounds("scenario-properties").center() - offset;
-    assert!(details.contains(point));
-    let events = mounted.click(&mut app, point).await;
-    assert!(events.iter().any(|event| matches!(event,
-        Message::ScenarioCanvas(CanvasEvent::Properties(c, selected))
-        if *c == context && *selected == b)));
-    mounted.settle(&mut app).await;
-    let shown = mounted.geometry(&app);
-    assert!(
-        !shown
-            .scrolls
-            .contains_key(&widget::Id::new("scenario-details"))
-    );
-    let (inspector, offset) = shown.scrolls[&widget::Id::new("inspector")];
-    assert!(
-        shown
-            .text_inputs
-            .iter()
-            .any(|bounds| inspector.contains(bounds.center() - offset)),
-        "current Saved diagram has a visible editable inspector"
-    );
-    assert!(!app.behavior.scenario.focused());
-    assert_eq!(
-        app.inspector_tab,
-        crate::navigation::InspectorTab::Properties
-    );
-    assert_eq!(app.selected, b);
-    assert_eq!(app.draft.as_ref().unwrap().original, b);
-    assert_eq!(app.active_diagram, Some(b));
-    assert_eq!(app.page, crate::app::Page::Behavior);
-    assert_eq!(
-        app.scenario_context().unwrap().representation,
-        context.representation
-    );
-    assert_eq!(app.scenario_context().unwrap().visit, context.visit);
-    assert_eq!(stored_camera(&app), camera);
-    assert!(Arc::ptr_eq(&snapshot, &app.document.snapshot()));
-    assert_eq!(app.document.bundle(), &bundle);
-    assert!(!app.document.can_undo() && !app.document.can_redo());
-}
-
-#[test]
-fn details_properties_refuses_another_saved_view_even_with_the_same_scenario_owner() {
-    let (mut app, a, _) = setup();
-    let b = id(&app, "incident_wide");
-    let _ = app.update(Message::Diagram(crate::app::Choice {
-        id: b,
-        label: "B".into(),
-    }));
-    let _ = app.update(Message::Select(a));
-    assert_eq!(app.selected, a);
-    open_focused_details(&mut app);
-    let context = app.scenario_context().unwrap();
-    assert_eq!(context.representation, Representation::Saved { diagram: b });
-    assert_eq!(
-        presentation::checked_owner(app.project(), Representation::Saved { diagram: a }),
-        Some(context.scenario)
-    );
-    assert!(!properties_target(app.project(), context, a));
-    let camera = app.behavior.scenario.camera_boundary();
-    let epochs = (app.canvas_epoch, app.camera_epoch);
-    let snapshot = app.document.snapshot();
-    let bundle = app.document.bundle().clone();
-    let _ = app.update(Message::ScenarioCanvas(CanvasEvent::Properties(context, a)));
-    assert!(app.behavior.scenario.camera_boundary() == camera);
-    assert_eq!((app.canvas_epoch, app.camera_epoch), epochs);
-    assert_eq!(app.scenario_context(), Some(context));
-    assert_eq!(app.selected, a);
-    assert_eq!(app.draft.as_ref().unwrap().original, a);
-    assert!(Arc::ptr_eq(&snapshot, &app.document.snapshot()));
-    assert_eq!(app.document.bundle(), &bundle);
-    assert!(!app.document.can_undo() && !app.document.can_redo());
-}
-
-#[test]
-fn details_properties_rejects_retired_view_selection_and_epoch_without_changing_panels() {
-    for kind in 0..3 {
-        let (mut app, diagram, message) = setup();
-        open_focused_details(&mut app);
-        let captured = app.scenario_context().unwrap();
-        match kind {
-            0 => {
-                let other = id(&app, "incident_wide");
-                for view in [other, diagram] {
-                    let _ = app.update(Message::Diagram(crate::app::Choice {
-                        id: view,
-                        label: "view".into(),
-                    }));
-                }
-                open_focused_details(&mut app);
-                assert_ne!(app.scenario_context().unwrap().visit, captured.visit);
-            }
-            1 => {
-                let other = id(&app, "updated_report");
-                send(&mut app, |c| CanvasEvent::Select(c, other));
-            }
-            _ => {
-                send(&mut app, |c| CanvasEvent::Zoom(c, Some(0.5)));
-            }
-        }
-        let camera = app.behavior.scenario.camera_boundary();
-        let context = app.scenario_context();
-        let selected = app.selected;
-        let tab = app.inspector_tab;
-        let epochs = (app.canvas_epoch, app.camera_epoch);
-        let snapshot = app.document.snapshot();
-        let bundle = app.document.bundle().clone();
-        let _ = app.update(Message::ScenarioCanvas(CanvasEvent::Properties(
-            captured, message,
-        )));
-        assert!(app.behavior.scenario.camera_boundary() == camera);
-        assert_eq!(app.scenario_context(), context);
-        assert_eq!(app.selected, selected);
-        assert_eq!(app.inspector_tab, tab);
-        assert_eq!((app.canvas_epoch, app.camera_epoch), epochs);
-        assert!(Arc::ptr_eq(&snapshot, &app.document.snapshot()));
-        assert_eq!(app.document.bundle(), &bundle);
-    }
-}
-
-#[test]
-fn opening_scenario_properties_cancels_held_spacing_and_rejects_its_late_finish() {
-    use super::super::spacing::{Event as Spacing, Target, controller::tests::packet};
-    let (mut app, _, message) = setup();
-    send(&mut app, |c| {
-        CanvasEvent::Viewport(c, Size::new(900., 600.))
-    });
-    open_focused_details(&mut app);
-    let begin = packet(
-        app.project(),
-        &app.behavior.scenario,
-        app.scenario_context().unwrap(),
-        app.camera_epoch,
-        Target::Message(message),
-    );
-    let Spacing::Begin { press_screen, .. } = begin else {
-        panic!()
-    };
-    let _ = app.update(Message::ScenarioCanvas(CanvasEvent::Spacing(begin)));
-    assert_eq!(app.behavior.scenario.spacing_token(), Some(begin.token()));
-    let snapshot = app.document.snapshot();
-    let end = press_screen + Vector::new(0., 12.);
-    let _ = app.update(Message::ScenarioCanvas(CanvasEvent::Spacing(
-        Spacing::Move {
-            stamp: begin.stamp(),
-            token: begin.token(),
-            screen: end,
-        },
-    )));
-    let paint = app
-        .behavior
-        .scenario
-        .spacing_paint(begin.stamp().context, begin.stamp().camera_epoch)
-        .unwrap();
-    assert!(paint.refusal.is_none());
-    let line = paint
-        .scene
-        .lines
-        .iter()
-        .find(|line| line.id == message)
-        .unwrap();
-    assert!(
-        line.points[0].y > 160.,
-        "a real proposed scene moved the first message"
-    );
-    assert!(
-        Arc::ptr_eq(&snapshot, &app.document.snapshot()),
-        "preview is not authored"
-    );
-    let camera = stored_camera(&app);
-    send(&mut app, |c| CanvasEvent::Properties(c, message));
-    assert!(app.behavior.scenario.spacing_token().is_none());
-    assert_eq!(stored_camera(&app), camera);
-    let _ = app.update(Message::ScenarioCanvas(CanvasEvent::Spacing(
-        Spacing::Finish {
-            stamp: begin.stamp(),
-            token: begin.token(),
-            screen: end,
-        },
-    )));
-    assert!(Arc::ptr_eq(&snapshot, &app.document.snapshot()));
-    assert!(!app.document.can_undo() && !app.document.can_redo());
-}

crates/oa-desktop/src/behavior/scenario/workspace/spacing_tests.rs

@@ -1,438 +0,0 @@
-//! Real mounted widgets dispatch the gesture; expectations name authored fields
-//! and actual displayed anchors independently of controller command results.
-use super::*;
-use crate::behavior::canvas_workspace::tests::{Mounted, key};
-use crate::behavior::scenario_layout::{ResolvedScenarioPlan, resolve};
-use crate::document::Document;
-use iced::Vector;
-use std::sync::Arc;
-
-const FIXTURE: &str = include_str!("../../../app/diagram_usages/tests/saved_scenario.arcadia");
-
-fn id(app: &App, alias: &str) -> Id {
-    app.project()
-        .identities()
-        .into_iter()
-        .find(|(_, name)| *name == alias)
-        .unwrap()
-        .0
-}
-
-async fn setup(fit: bool) -> (App, Mounted, Id) {
-    let mut app = App::with_project(oa_core::language::parse(FIXTURE).unwrap());
-    let owner = id(&app, "incident_response");
-    let diagram = id(&app, "incident_readable");
-    let _ = app.update(Message::Select(owner));
-    let _ = app.update(Message::Diagram(crate::app::Choice {
-        id: diagram,
-        label: "A - Incident review readable".into(),
-    }));
-    app.window_size = Size::new(1440., 900.);
-    let mut mounted = Mounted::new(&mut app).await;
-    if !fit {
-        let context = app.scenario_context().unwrap();
-        let task = app.update(Message::ScenarioCanvas(CanvasEvent::Zoom(
-            context,
-            Some(0.5),
-        )));
-        mounted.perform(&mut app, task).await;
-        mounted.settle(&mut app).await;
-    }
-    assert_eq!(
-        app.scenario_context().unwrap().representation,
-        Representation::Saved { diagram }
-    );
-    assert!(!app.document.can_undo() && !app.document.can_redo());
-    (app, mounted, diagram)
-}
-
-fn resolved(app: &App) -> ResolvedScenarioPlan {
-    resolve(
-        app.project(),
-        app.scenario_context().unwrap().representation,
-        app.selected,
-    )
-    .unwrap()
-}
-
-fn stored_camera(app: &App) -> (Vector, Option<f32>, bool) {
-    let p = &app.behavior.scenario.presentation;
-    (p.pan, p.zoom, p.fit)
-}
-
-fn screen(mounted: &mut Mounted, app: &App, world: Point) -> Point {
-    let bounds = mounted.geometry(app).bounds("scenario-viewport");
-    let geometry = resolved(app);
-    let camera = app.behavior.scenario.presentation.camera(geometry.bounds);
-    let point = bounds.position() + camera.pan + Vector::new(world.x, world.y) * camera.scale;
-    assert!(
-        bounds.contains(point),
-        "actual visible world {world:?}: {point:?} in {bounds:?}"
-    );
-    point
-}
-
-fn mouse_event(event: mouse::Event) -> iced::Event {
-    iced::Event::Mouse(event)
-}
-
-async fn press(mounted: &mut Mounted, app: &mut App, point: Point) -> Vec<Message> {
-    mounted
-        .batch(
-            app,
-            &[
-                mouse_event(mouse::Event::CursorMoved { position: point }),
-                mouse_event(mouse::Event::ButtonPressed(mouse::Button::Left)),
-            ],
-            mouse::Cursor::Available(point),
-        )
-        .await
-}
-
-async fn move_to(mounted: &mut Mounted, app: &mut App, point: Point) -> Vec<Message> {
-    mounted
-        .batch(
-            app,
-            &[mouse_event(mouse::Event::CursorMoved { position: point })],
-            mouse::Cursor::Available(point),
-        )
-        .await
-}
-
-async fn release(mounted: &mut Mounted, app: &mut App, point: Point) -> Vec<Message> {
-    mounted
-        .batch(
-            app,
-            &[mouse_event(mouse::Event::ButtonReleased(
-                mouse::Button::Left,
-            ))],
-            mouse::Cursor::Available(point),
-        )
-        .await
-}
-
-fn set_expected_message(project: &mut oa_core::Project, diagram: Id, occurrence: Id, y: f32) {
-    let Some(oa_core::DiagramLayout::Scenario(layout)) =
-        &mut project.diagrams.get_mut(&diagram).unwrap().layout
-    else {
-        panic!()
-    };
-    layout
-        .messages
-        .iter_mut()
-        .find(|m| m.address.occurrence == occurrence)
-        .unwrap()
-        .send_y = y;
-}
-
-fn set_expected_lane(project: &mut oa_core::Project, diagram: Id, lifeline: Id, x: f32) {
-    let Some(oa_core::DiagramLayout::Scenario(layout)) =
-        &mut project.diagrams.get_mut(&diagram).unwrap().layout
-    else {
-        panic!()
-    };
-    layout
-        .lanes
-        .iter_mut()
-        .find(|lane| lane.lifeline == lifeline)
-        .unwrap()
-        .x = x;
-}
-
-fn assert_reopens_exactly(app: &App) {
-    let reopened = Document::from_bundle(
-        app.document.bundle().clone(),
-        oa_core::source_project::ProjectLimits::default(),
-    )
-    .unwrap();
-    assert_eq!(reopened.project(), app.project());
-    assert_eq!(reopened.bundle(), app.document.bundle());
-}
-
-#[tokio::test]
-async fn saved_message_same_batch_pointer_events_commit_once_and_one_undo_redo_restores_exact_source()
- {
-    let (mut app, mut mounted, diagram) = setup(false).await;
-    let target = id(&app, "updated_report");
-    let before = app.document.snapshot();
-    let revision = app.document.revision();
-    let projected = screen(&mut mounted, &app, Point::new(400., 252.));
-    // This fixture asks for exactly +20 world units. A fractional start near a
-    // screen-coordinate exponent boundary need not retain an exact +10 delta.
-    let start = Point::new(projected.x.round(), projected.y.round());
-    let mut geometry = resolved(&app);
-    let camera = app.behavior.scenario.presentation.camera(geometry.bounds);
-    assert_eq!(camera.scale, 0.5);
-    let bounds = mounted.geometry(&app).bounds("scenario-viewport");
-    let world = Point::new(
-        (start.x - bounds.x - camera.pan.x) / camera.scale,
-        (start.y - bounds.y - camera.pan.y) / camera.scale,
-    );
-    geometry.scene.scale = camera.scale;
-    geometry.scene.camera_pan = camera.pan;
-    let hit = geometry.scene.hit_item(world).unwrap();
-    assert_eq!(hit.id, target);
-    assert_eq!(hit.role, crate::behavior::SceneHitRole::MessageBody);
-    let end = start + Vector::new(0., 10.); // .5 display scale: +20 authored y.
-    assert_eq!(end.y - start.y, 10.);
-    assert!(bounds.contains(start) && bounds.contains(end));
-    let messages = mounted
-        .batch(
-            &mut app,
-            &[
-                mouse_event(mouse::Event::CursorMoved { position: start }),
-                mouse_event(mouse::Event::ButtonPressed(mouse::Button::Left)),
-                mouse_event(mouse::Event::CursorMoved { position: end }),
-                mouse_event(mouse::Event::ButtonReleased(mouse::Button::Left)),
-            ],
-            mouse::Cursor::Available(end),
-        )
-        .await;
-    assert_eq!(
-        messages
-            .iter()
-            .filter(|m| matches!(
-                m,
-                Message::ScenarioCanvas(CanvasEvent::Spacing(spacing::Event::Begin { .. }))
-            ))
-            .count(),
-        1
-    );
-    assert_eq!(
-        messages
-            .iter()
-            .filter(|m| matches!(
-                m,
-                Message::ScenarioCanvas(CanvasEvent::Spacing(spacing::Event::Finish { .. }))
-            ))
-            .count(),
-        1
-    );
-    let mut expected = before.decoded.project.clone();
-    set_expected_message(&mut expected, diagram, target, 272.);
-    assert_eq!(
-        app.project(),
-        &expected,
-        "Only Saved A's addressed y changes; steps, other occurrences and B/C are exact"
-    );
-    assert_eq!(app.document.revision(), revision + 1);
-    assert_eq!(app.selected, target);
-    assert!(app.behavior.scenario.spacing_token().is_none());
-    assert_reopens_exactly(&app);
-    let after = app.document.snapshot();
-    let task = app.update(Message::Undo);
-    mounted.perform(&mut app, task).await;
-    assert_eq!(app.project(), &before.decoded.project);
-    assert_eq!(app.document.bundle(), &before.bundle);
-    assert!(!app.document.can_undo() && app.document.can_redo());
-    let task = app.update(Message::Redo);
-    mounted.perform(&mut app, task).await;
-    assert_eq!(app.project(), &after.decoded.project);
-    assert_eq!(app.document.bundle(), &after.bundle);
-}
-
-#[tokio::test]
-async fn saved_header_preview_survives_frames_and_freezes_fit_while_actual_bounds_expand() {
-    let (mut app, mut mounted, diagram) = setup(true).await;
-    let assessor = id(&app, "assessor");
-    let before = app.document.snapshot();
-    let original = resolved(&app);
-    let original_camera = app.behavior.scenario.presentation.camera(original.bounds);
-    let stored = stored_camera(&app);
-    assert!(stored.2, "test must exercise original Fit");
-    let start = screen(&mut mounted, &app, Point::new(640., 45.));
-    press(&mut mounted, &mut app, start).await;
-    let token = app
-        .behavior
-        .scenario
-        .spacing_token()
-        .expect("actual header press begins");
-    for x in [670., 700.] {
-        let end = start + Vector::new((x - 640.) * original_camera.scale, 0.);
-        move_to(&mut mounted, &mut app, end).await;
-        mounted.settle(&mut app).await; // Actual borrowed Scene/Stack tree is rebuilt.
-        assert_eq!(app.behavior.scenario.spacing_token(), Some(token));
-        assert!(Arc::ptr_eq(&before, &app.document.snapshot()));
-        assert_eq!(stored_camera(&app), stored);
-        let paint = app
-            .behavior
-            .scenario
-            .spacing_paint(app.scenario_context().unwrap(), app.camera_epoch)
-            .unwrap();
-        assert!(paint.refusal.is_none());
-        assert!((paint.scene.render_lanes[&assessor] - x).abs() < 0.001);
-        assert!(paint.bounds.width > original.bounds.width);
-        assert_eq!(paint.scene.scale, original_camera.scale);
-        assert_eq!(paint.scene.camera_pan, original_camera.pan);
-        let header = paint.scene.boxes.iter().find(|b| b.id == assessor).unwrap();
-        let displayed = Vector::new(header.rect.center().x, header.rect.center().y)
-            * paint.scene.scale
-            + paint.scene.camera_pan;
-        let baseline = Vector::new(640., 50.) * original_camera.scale + original_camera.pan;
-        assert!((displayed.x - baseline.x - (x - 640.) * original_camera.scale).abs() < 0.001);
-        assert_eq!(displayed.y, baseline.y);
-    }
-    let end = start + Vector::new(60. * original_camera.scale, 0.);
-    release(&mut mounted, &mut app, end).await;
-    let final_geometry = resolved(&app);
-    let actual_x = final_geometry.scene.render_lanes[&assessor];
-    assert!((actual_x - 700.).abs() < 0.001);
-    let mut expected = before.decoded.project.clone();
-    set_expected_lane(&mut expected, diagram, assessor, actual_x);
-    assert_eq!(app.project(), &expected);
-    let final_camera = app
-        .behavior
-        .scenario
-        .presentation
-        .camera(final_geometry.bounds);
-    assert_eq!(
-        final_camera, original_camera,
-        "commit must not refit underneath pointer"
-    );
-    assert!(!app.behavior.scenario.presentation.fit);
-    assert_eq!(app.selected, assessor);
-    assert_reopens_exactly(&app);
-}
-
-#[tokio::test]
-async fn saved_body_and_header_clicks_select_without_materializing_spacing() {
-    let (mut app, mut mounted, _) = setup(false).await;
-    let before = app.document.snapshot();
-    let original_camera = stored_camera(&app);
-    for (alias, world) in [
-        ("updated_report", Point::new(400., 252.)),
-        ("assessor", Point::new(640., 45.)),
-    ] {
-        let target = id(&app, alias);
-        let point = screen(&mut mounted, &app, world);
-        mounted.click(&mut app, point).await;
-        assert_eq!(app.selected, target);
-        assert!(app.behavior.scenario.spacing_token().is_none());
-        assert!(Arc::ptr_eq(&before, &app.document.snapshot()));
-        assert_eq!(stored_camera(&app), original_camera);
-    }
-    assert!(!app.document.can_undo() && !app.document.can_redo());
-}
-
-#[tokio::test]
-async fn saved_valid_preview_then_refused_self_call_never_commits_last_valid_candidate() {
-    let (mut app, mut mounted, _) = setup(false).await;
-    let target = id(&app, "assess_call");
-    let before = app.document.snapshot();
-    let camera = stored_camera(&app);
-    let start = screen(&mut mounted, &app, Point::new(680., 344.));
-    press(&mut mounted, &mut app, start).await;
-    let valid = start + Vector::new(0., -10.); // send324, receive348, reply436 unchanged.
-    move_to(&mut mounted, &mut app, valid).await;
-    mounted.settle(&mut app).await;
-    let paint = app
-        .behavior
-        .scenario
-        .spacing_paint(app.scenario_context().unwrap(), app.camera_epoch)
-        .unwrap();
-    assert!(paint.refusal.is_none());
-    let line = paint.scene.lines.iter().find(|l| l.id == target).unwrap();
-    assert_eq!(line.points[0].y, 324.);
-    assert_eq!(line.points.last().unwrap().y, 348.);
-    let refused = start + Vector::new(0., 53.); // send450, receive474 would follow reply436.
-    move_to(&mut mounted, &mut app, refused).await;
-    mounted.settle(&mut app).await;
-    let paint = app
-        .behavior
-        .scenario
-        .spacing_paint(app.scenario_context().unwrap(), app.camera_epoch)
-        .unwrap();
-    assert!(paint.refusal.is_some());
-    assert_eq!(
-        paint
-            .scene
-            .lines
-            .iter()
-            .find(|l| l.id == target)
-            .unwrap()
-            .points[0]
-            .y,
-        344.
-    );
-    assert!(Arc::ptr_eq(&before, &app.document.snapshot()));
-    release(&mut mounted, &mut app, refused).await;
-    assert!(app.behavior.scenario.spacing_token().is_none());
-    assert!(Arc::ptr_eq(&before, &app.document.snapshot()));
-    assert_eq!(stored_camera(&app), camera);
-    assert!(!app.document.can_undo() && !app.document.can_redo());
-}
-
-#[tokio::test]
-async fn saved_escape_and_outside_pointer_cancel_actual_held_preview() {
-    for escape in [true, false] {
-        let (mut app, mut mounted, _) = setup(false).await;
-        let before = app.document.snapshot();
-        let camera = stored_camera(&app);
-        let start = screen(&mut mounted, &app, Point::new(400., 252.));
-        let end = start + Vector::new(0., 10.);
-        press(&mut mounted, &mut app, start).await;
-        move_to(&mut mounted, &mut app, end).await;
-        mounted.settle(&mut app).await;
-        assert!(app.behavior.scenario.spacing_token().is_some());
-        let release_at = if escape {
-            mounted
-                .batch(
-                    &mut app,
-                    &[key(iced::keyboard::key::Named::Escape)],
-                    mouse::Cursor::Available(end),
-                )
-                .await;
-            end
-        } else {
-            let bounds = mounted.geometry(&app).bounds("scenario-viewport");
-            let outside = Point::new(bounds.x - 5., bounds.y + 100.);
-            move_to(&mut mounted, &mut app, outside).await;
-            outside
-        };
-        assert!(app.behavior.scenario.spacing_token().is_none());
-        release(&mut mounted, &mut app, release_at).await;
-        assert!(Arc::ptr_eq(&before, &app.document.snapshot()));
-        assert_eq!(stored_camera(&app), camera);
-        assert!(!app.document.can_undo() && !app.document.can_redo());
-    }
-}
-
-#[tokio::test]
-async fn saved_drag_return_to_origin_preserves_redo_selection_and_original_fit_camera() {
-    let (mut app, mut mounted, _) = setup(true).await;
-    let owner = id(&app, "incident_response");
-    app.document
-        .execute(oa_core::Command::Rename(
-            owner,
-            "Previously edited owner".into(),
-        ))
-        .unwrap();
-    let redo = app.document.snapshot();
-    let task = app.update(Message::Undo);
-    mounted.perform(&mut app, task).await;
-    mounted.settle(&mut app).await;
-    assert!(app.document.can_redo());
-    let before = app.document.snapshot();
-    let camera = stored_camera(&app);
-    let selected = app.selected;
-    let revision = app.document.revision();
-    let start = screen(&mut mounted, &app, Point::new(400., 252.));
-    press(&mut mounted, &mut app, start).await;
-    move_to(&mut mounted, &mut app, start + Vector::new(0., 12.)).await;
-    mounted.settle(&mut app).await;
-    assert!(app.behavior.scenario.spacing_token().is_some());
-    move_to(&mut mounted, &mut app, start).await;
-    mounted.settle(&mut app).await;
-    release(&mut mounted, &mut app, start).await;
-    assert!(app.behavior.scenario.spacing_token().is_none());
-    assert!(Arc::ptr_eq(&before, &app.document.snapshot()));
-    assert_eq!(app.document.bundle(), &before.bundle);
-    assert_eq!(app.document.revision(), revision);
-    assert_eq!(stored_camera(&app), camera);
-    assert_eq!(app.selected, selected);
-    assert!(app.document.can_redo());
-    let task = app.update(Message::Redo);
-    mounted.perform(&mut app, task).await;
-    assert_eq!(app.project(), &redo.decoded.project);
-    assert_eq!(app.document.bundle(), &redo.bundle);
-}

crates/oa-desktop/src/behavior/scenario_hit_tests.rs

@@ -1,386 +0,0 @@
-//! Actual Scene primitives, with independently chosen points and semantic IDs.
-//! These preserve the existing label hit band; they do not establish ink bounds
-//! or authoring eligibility, and do not dispatch a spacing gesture.
-use super::*;
-use crate::document::Document;
-
-struct Fixture {
-    project: Project,
-    owner: Id,
-    sender: Id,
-    receiver: Id,
-    call: Id,
-    reply: Id,
-    exchange: Id,
-}
-
-fn fixture() -> Fixture {
-    let project = language::parse(r#"arcadia 7;
-project hits "Hit roles" {
- oa_activity source "Source" {}
- oa_activity target "Target" {}
- interaction exchange "Contract" { source @source; target @target; }
- oa_scenario conversation "Conversation" { viewpoint OperationalActivity; steps [@call, @reply]; }
- oa_lifeline left "Left" { parent @conversation; represented @source; }
- oa_lifeline right "Right" { parent @conversation; represented @target; }
- oa_occurrence call "Call" { parent @conversation; body { Exchange { exchange @exchange; sender @left; receiver @right; message_kind Call; }; }; }
- oa_occurrence reply "Reply" { parent @conversation; body { Exchange { exchange @exchange; sender @right; receiver @left; message_kind Reply; reply_to @call; }; }; }
-}
-"#).unwrap();
-    let id = |alias: &str| {
-        project
-            .identities()
-            .into_iter()
-            .find(|(_, name)| *name == alias)
-            .unwrap()
-            .0
-    };
-    Fixture {
-        owner: id("conversation"),
-        sender: id("left"),
-        receiver: id("right"),
-        call: id("call"),
-        reply: id("reply"),
-        exchange: id("exchange"),
-        project,
-    }
-}
-
-fn scene(f: &Fixture) -> Scene {
-    let document =
-        Document::from_project(f.project.clone(), source_project::ProjectLimits::default())
-            .unwrap();
-    let before = document.snapshot();
-    let result = Scene::sequence_geometry(
-        document.project(),
-        f.owner,
-        f.call,
-        Some(&BTreeMap::from([(f.sender, 160.), (f.receiver, 400.)])),
-        None,
-    );
-    assert_eq!(document.project(), &before.decoded.project);
-    assert_eq!(document.bundle(), &before.bundle);
-    assert_eq!(document.revision(), 0);
-    assert!(!document.can_undo() && !document.can_redo() && !document.dirty());
-    result
-}
-
-fn hit(scene: &Scene, point: Point, id: Id, role: SceneHitRole) {
-    assert_eq!(scene.hit_item(point), Some(SceneHit { id, role }));
-    assert_eq!(scene.hit(point), Some(id));
-}
-
-fn occurrence(p: &mut Project, parent: Id, body: OccurrenceBody) -> Id {
-    let mut element = p
-        .make_element(Kind::Occurrence, Layer::Oa, "Hit target", Some(parent))
-        .unwrap();
-    let id = element.id;
-    *element.shared_mut().unwrap() = SharedBody::Occurrence {
-        body,
-        precondition: String::new(),
-        postcondition: String::new(),
-    };
-    p.elements.insert(id, element);
-    p.elements
-        .get_mut(&parent)
-        .unwrap()
-        .steps_mut()
-        .unwrap()
-        .push(id);
-    id
-}
-
-fn exchange_mut(p: &mut Project, id: Id) -> &mut OccurrenceBody {
-    let SharedBody::Occurrence { body, .. } =
-        p.elements.get_mut(&id).unwrap().shared_mut().unwrap()
-    else {
-        panic!("expected occurrence")
-    };
-    body
-}
-
-#[test]
-fn exact_headers_include_unassigned_lifelines_but_guides_are_not_headers() {
-    let mut f = fixture();
-    *f.project
-        .elements
-        .get_mut(&f.receiver)
-        .unwrap()
-        .shared_mut()
-        .unwrap() = SharedBody::Lifeline { represented: None };
-    let s = scene(&f);
-    assert!(!s.lanes.contains_key(&f.receiver));
-    assert_eq!(s.render_lanes[&f.receiver], 400.);
-    for (id, x) in [(f.sender, 160.), (f.receiver, 400.)] {
-        // The actual header is x-102..x+102, y15..85, including its padding.
-        for point in [Point::new(x - 101., 16.), Point::new(x + 101., 84.)] {
-            hit(&s, point, id, SceneHitRole::LifelineHeader);
-        }
-        hit(&s, Point::new(x, 95.), id, SceneHitRole::LifelineGuide);
-    }
-}
-
-#[test]
-fn repeated_exchange_occurrences_keep_distinct_message_body_and_label_hits() {
-    let f = fixture();
-    let s = scene(&f);
-    assert_eq!(s.rows[&f.call].1, 148.);
-    assert_eq!(s.rows[&f.reply].1, 240.);
-    for (id, y) in [(f.call, 148.), (f.reply, 240.)] {
-        hit(&s, Point::new(280., y), id, SceneHitRole::MessageBody);
-        hit(
-            &s,
-            Point::new(180., y - 16.),
-            id,
-            SceneHitRole::MessageLabel,
-        );
-        assert_ne!(id, f.exchange);
-    }
-}
-
-#[test]
-fn self_call_elbow_and_receive_endpoint_are_messages_not_execution_hits() {
-    let mut f = fixture();
-    for id in [f.call, f.reply] {
-        let OccurrenceBody::Exchange {
-            sender,
-            receiver,
-            exchange,
-            ..
-        } = exchange_mut(&mut f.project, id)
-        else {
-            unreachable!()
-        };
-        *sender = Some(f.sender);
-        *receiver = Some(f.sender);
-        *exchange = None;
-    }
-    let s = scene(&f);
-    let call = s.lines.iter().find(|l| l.id == f.call).unwrap();
-    assert_eq!(call.points.len(), 4);
-    assert_eq!(call.points[0].y, 148.);
-    assert_eq!(call.points[3].y, 172.);
-    hit(
-        &s,
-        Point::new(call.points[1].x, 160.),
-        f.call,
-        SceneHitRole::MessageBody,
-    );
-    hit(&s, call.points[3], f.call, SceneHitRole::MessageBody);
-    hit(
-        &s,
-        Point::new(180., 132.),
-        f.call,
-        SceneHitRole::MessageLabel,
-    );
-    let bar = s.activations.iter().find(|a| a.call == f.call).unwrap();
-    hit(
-        &s,
-        Point::new(bar.rect.x + 2., 190.),
-        f.call,
-        SceneHitRole::Activation,
-    );
-}
-
-#[test]
-fn activation_shoulder_beats_another_calls_label_and_broad_message_tolerance() {
-    let mut f = fixture();
-    let mut inner = f.project.elements[&f.call].clone();
-    inner.id = Id::new_v4();
-    inner.alias = "inner_call_hit".into();
-    inner.name = "Pressure verification with a descriptive operation label".into();
-    let inner_id = inner.id;
-    f.project.elements.insert(inner_id, inner);
-    let mut inner_reply = f.project.elements[&f.reply].clone();
-    inner_reply.id = Id::new_v4();
-    inner_reply.alias = "inner_reply_hit".into();
-    let reply_id = inner_reply.id;
-    f.project.elements.insert(reply_id, inner_reply);
-    let OccurrenceBody::Exchange { reply_to, .. } = exchange_mut(&mut f.project, reply_id) else {
-        unreachable!()
-    };
-    *reply_to = Some(inner_id);
-    *f.project
-        .elements
-        .get_mut(&f.owner)
-        .unwrap()
-        .steps_mut()
-        .unwrap() = vec![f.call, inner_id, reply_id, f.reply];
-    let mut s = scene(&f);
-    let inner = s.lines.iter().find(|l| l.id == inner_id).unwrap();
-    let outer = s.activations.iter().find(|a| a.call == f.call).unwrap();
-    let shoulder = Point::new(outer.rect.x + 1., 225.);
-    assert!(outer.rect.contains(shoulder));
-    assert!(inner.label_bounds().contains(shoulder));
-    let endpoint = *inner.points.last().unwrap();
-    for scale in [1., 0.05, 0.0003] {
-        s.scale = scale;
-        hit(&s, shoulder, f.call, SceneHitRole::Activation);
-        hit(&s, endpoint, inner_id, SceneHitRole::MessageBody);
-        hit(
-            &s,
-            Point::new(180., 225.),
-            inner_id,
-            SceneHitRole::MessageLabel,
-        );
-    }
-}
-
-#[test]
-fn create_delete_markers_are_distinct_from_their_own_message_body_and_label() {
-    let mut f = fixture();
-    for (id, kind) in [
-        (f.call, MessageKind::Create),
-        (f.reply, MessageKind::Delete),
-    ] {
-        let OccurrenceBody::Exchange {
-            sender,
-            receiver,
-            message_kind,
-            reply_to,
-            ..
-        } = exchange_mut(&mut f.project, id)
-        else {
-            unreachable!()
-        };
-        *sender = Some(f.sender);
-        *receiver = Some(f.receiver);
-        *message_kind = kind;
-        *reply_to = None;
-    }
-    let s = scene(&f);
-    for (id, y, label_y) in [(f.call, 148., 118.), (f.reply, 240., 224.)] {
-        hit(&s, Point::new(400., y), id, SceneHitRole::LifecycleMarker);
-        hit(&s, Point::new(280., y), id, SceneHitRole::MessageBody);
-        hit(
-            &s,
-            Point::new(180., label_y),
-            id,
-            SceneHitRole::MessageLabel,
-        );
-    }
-    // Capsule boundary owns its contact with the incoming Create arrow.
-    hit(
-        &s,
-        Point::new(330., 148.),
-        f.call,
-        SceneHitRole::LifecycleMarker,
-    );
-}
-
-#[test]
-fn tiny_scale_nearest_hit_retains_the_winning_marker_or_message_role() {
-    let mut f = fixture();
-    let OccurrenceBody::Exchange {
-        sender,
-        receiver,
-        message_kind,
-        reply_to,
-        ..
-    } = exchange_mut(&mut f.project, f.reply)
-    else {
-        unreachable!()
-    };
-    *sender = Some(f.sender);
-    *receiver = Some(f.receiver);
-    *message_kind = MessageKind::Delete;
-    *reply_to = None;
-    let mut s = scene(&f);
-    s.scale = 0.0003;
-    // Both are outside exact strokes/labels. Comparing all broad candidates
-    // chooses the actual nearer shape, even when their UUID is identical.
-    hit(
-        &s,
-        Point::new(280., 246.),
-        f.reply,
-        SceneHitRole::MessageBody,
-    );
-    hit(
-        &s,
-        Point::new(400., 265.),
-        f.reply,
-        SceneHitRole::LifecycleMarker,
-    );
-    hit(
-        &s,
-        Point::new(280., 154.),
-        f.call,
-        SceneHitRole::MessageBody,
-    );
-}
-
-#[test]
-fn action_frame_and_use_boxes_do_not_advertise_message_or_header_roles() {
-    for body in [
-        OccurrenceBody::Action {
-            action: None,
-            lifeline: None,
-        },
-        OccurrenceBody::Fragment {
-            operator: FragmentOperator::Alternative,
-            branches: vec![],
-        },
-        OccurrenceBody::ScenarioUse {
-            scenario: None,
-            bindings: vec![],
-        },
-        OccurrenceBody::Exchange {
-            exchange: None,
-            sender: None,
-            receiver: None,
-            message_kind: MessageKind::Asynchronous,
-            operation: None,
-            reply_to: None,
-            values: vec![],
-        },
-    ] {
-        let mut f = fixture();
-        let id = occurrence(&mut f.project, f.owner, body);
-        let s = scene(&f);
-        let item = s.boxes.iter().find(|b| b.id == id).unwrap();
-        hit(
-            &s,
-            item.rect.position() + iced::Vector::new(15., 15.),
-            id,
-            SceneHitRole::Box,
-        );
-    }
-}
-
-#[test]
-fn winning_primitive_role_does_not_come_from_its_shared_uuid() {
-    let f = fixture();
-    let mut s = scene(&f);
-    // A controlled overlapping primitive verifies reverse box order without
-    // inventing a core alias. Its ID intentionally equals a real header's ID.
-    s.boxes.push(BoxItem {
-        id: f.sender,
-        role: SceneHitRole::Box,
-        rect: Rectangle::new(Point::new(150., 20.), Size::new(20., 20.)),
-        title: "Overlay control".into(),
-        detail: String::new(),
-        marker: None,
-    });
-    hit(&s, Point::new(160., 30.), f.sender, SceneHitRole::Box);
-    hit(
-        &s,
-        Point::new(180., 30.),
-        f.sender,
-        SceneHitRole::LifelineHeader,
-    );
-}
-
-#[test]
-fn invalid_points_never_produce_a_semantic_or_spacing_hit() {
-    let f = fixture();
-    let s = scene(&f);
-    for point in [
-        Point::new(f32::NAN, 148.),
-        Point::new(280., f32::NAN),
-        Point::new(f32::INFINITY, 148.),
-        Point::new(280., f32::NEG_INFINITY),
-    ] {
-        assert_eq!(s.hit_item(point), None);
-        assert_eq!(s.hit(point), None);
-    }
-}

crates/oa-desktop/src/behavior/scenario_layout.rs

@@ -64,7 +64,7 @@ pub(super) struct Plan {
     pub(super) frames: BTreeMap<Id, Rectangle>,
     pub(super) scopes: BTreeMap<Id, (f32, f32)>,
     pub(super) height: f32,
-    pub(super) diagnostics: Vec<Diagnostic>,
+    diagnostics: Vec<Diagnostic>,
 }
 
 pub(super) fn occurrence(p: &Project, id: Id) -> Option<&OccurrenceBody> {

crates/oa-desktop/src/behavior/scenario_lifecycle/union_tests.rs

@@ -458,7 +458,8 @@ fn test_only_upstream_row_offsets_update_lifetime_segments_and_endpoints_without
             assert_eq!(scene.activations.len(), 2);
             for (call, reply) in [(c1, r1), (c2, r2)] {
                 assert!(scene.activations.iter().any(|segment| {
-                    segment.call == call && segment.finish == Finish::Reply(reply)
+                    segment.call == call
+                        && segment.finish == Finish::Reply(reply)
                 }));
             }
         }

crates/oa-server/tests/http.rs

@@ -14,14 +14,14 @@ mod communication_limits;
 mod data_contracts;
 #[path = "http/port_anchors.rs"]
 mod port_anchors;
-#[path = "http/scenario_layout.rs"]
-mod scenario_layout;
 #[path = "http/semantic_transitions.rs"]
 mod semantic_transitions;
 #[path = "http/source6_views.rs"]
 mod source6_views;
 #[path = "http/source7_contracts.rs"]
 mod source7_contracts;
+#[path = "http/scenario_layout.rs"]
+mod scenario_layout;
 #[path = "http/source_projects.rs"]
 mod source_projects;
 

harness/scenario-arrangement-selection.md

@@ -1,9 +0,0 @@
-# Scenario arrangement selection
-
-An explicit arrangement change follows an inspector that is showing the current Saved Diagram record. Switching from Saved A to Saved B selects B and refreshes its Properties draft. Switching that view inspection to Automatic selects the Scenario owner, since Automatic has no Diagram record. An occurrence, lifeline, Scenario owner or independently selected foreign view keeps its selection. Returning from Automatic to a Saved view therefore preserves an already selected Scenario owner.
-
-The follow intention is captured before the existing property Apply. The destination must pass the existing owner/context checks; a rejected draft or stale event cannot change selection. A same-view UUID edit follows the resulting Diagram identity. Successful entry refreshes the selected view's draft without a second Apply or a new document transaction. Passive page navigation and Back retain their existing behavior.
-
-This corrects the actual Scenario picker (`CanvasEvent::Representation`). Previously, selecting A's whole-view usage and then choosing B left A selected, so the exact-current-view Details guard disabled Properties. Preserving that foreign view selection would make the inspector disagree with an explicit view change. Broadly selecting B after every arrangement change was rejected because it would discard an engineer's independent model-element inspection. The separate `Message::Diagram` handler already follows the current view, but its global UI picker excludes Scenario diagrams and cannot substitute for this workflow.
-
-The regression module `app::scenario_details_tests` exercises the real picker overlay and Properties button, independent selections, Automatic, valid draft application and exact Undo/Redo, same-view UUID edits, and invalid/stale refusals. A container ID exposes the unchanged picker's bounds to the mounted evaluator. Native acceptance must retain the original A-record → Scenario arrangement B → Details → Properties workflow. Compilation and actual execution status belong to the linked review and [Gitea issue #24](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/24).