feat: align collection move and reorder semantics

Author: Roy Lin

README.md

@@ -72,7 +72,10 @@ versioned [component matrix](docs/react-aria-component-matrix.json) pins
   wildcard, multi-item, and per-format payload negotiation plus layout-driven
   collection `root` and keyed `before`/`on`/`after` targets. Selected
   collection items drag as one session, and ListBox, GridList, Tree, and Table
-  share the same RSX contract; external transfer, reorder/move policy, pixels,
+  share the same RSX contract. External `onInsert`/`onRootDrop`, internal
+  `onMove`, same-parent `onReorder`, multi-callback routing, equivalent adjacent
+  boundaries, and self/descendant guards now follow the React Aria collection
+  policy; dynamic acceptance, OS/cross-application transfer, previews, pixels,
   accessibility, and real hosts still keep every affected family below
   conformance;
 - Checkbox, Radio, and Switch Field/Button parts plus ToastList and
@@ -308,10 +311,13 @@ independently.
   and every MIME/custom representation, filter compatible target items,
   negotiate wildcards plus copy/move/link/cancel operations, aggregate stable
   selected collection keys, and resolve root/item/insertion targets from
-  self-drawn layout geometry. A collection is one keyboard Tab stop during a
-  drag, with arrow/Home/End navigation inside it; all paths share event-loop
-  deadlines, stable action bubbling, keyed reconciliation, and reducer
-  rollback in one staged interaction session
+  self-drawn layout geometry. Collection policy distinguishes external insert
+  and root drops from internal move/reorder, rejects self and descendant
+  targets, and preserves one logical boundary between adjacent items. A
+  collection is one keyboard Tab stop during a drag, with arrow/Home/End
+  navigation inside it; all paths share event-loop deadlines, stable action
+  bubbling, keyed reconciliation, and reducer rollback in one staged
+  interaction session
 - an identical-frame fast path that performs no layout, scene, host, or
   presentation work, plus semantic-only commits that skip pixel presentation
 - a software Graphics presenter and interactive shared

docs/platform-hosts.md

@@ -392,11 +392,14 @@ Landed evidence:
   wildcard types, and negotiates copy/move/link/cancel operations; pointer
   drags report target-local coordinates, keyboard Enter/Tab/Escape provides the
   same accessible source/compatible-target lifecycle, and keyed frames plus
-  reducer errors preserve or roll back the entire session atomically
+  reducer errors preserve or roll back the entire session atomically. Collection
+  targets additionally distinguish external insertion/root drops from internal
+  move and same-parent reorder, reject self/descendant drops, and coalesce
+  adjacent insertion boundaries
 - reducer errors restore the staged interaction state and sequence before the
   event is exposed as successful; successful frame reconciliation preserves
   focused stable ids, while rejected frames do not touch them
-- 53 focused runtime/software tests and four recursive feature/source
+- 59 focused runtime/software tests and four recursive feature/source
   firewall tests pass without any legacy renderer or OS toolkit dependency
 - `self_drawn_calculator` reproduces layout fingerprint
   `16529597026056060935`, scene fingerprint `2100550662756266801`, and

docs/react-aria-native.md

@@ -155,16 +155,22 @@ The first shared interaction milestone is available in the portable runtime:
   filters every target item by accepted type, and exposes `draggingKeys`,
   `target`, and `isInternal` in the shared context. During keyboard drag, each
   collection is one Tab stop and Arrow/Home/End keys navigate its internal
-  targets.
+  targets. Opposite `after A`/`before B` descriptors for adjacent items remain
+  one logical target without spurious exit/enter transitions.
 - `use_drag`, `use_drop`, `UiDraggable`, `UiDroppable`, and `UiDropZone` lower
   their source/target metadata and focusable keyboard affordances into that
   shared runtime. ListBox, GridList, Tree, and Table roots additionally lower
-  `onRootDrop`, `onItemDrop`, `onInsert`, and low-level `onDrop` precedence;
-  their items/rows and explicit DropIndicator parts use the same self-drawn
-  target model. Reorder/move policy, dynamic acceptance, external files and
-  directories, cross-application transfer, drag previews, and conformance
-  evidence remain separate M7 work, so no affected family is marked
-  conformant.
+  `onRootDrop`, `onItemDrop`, `onInsert`, `onReorder`, `onMove`, and low-level
+  `onDrop` precedence; their items/rows and explicit DropIndicator parts use
+  the same self-drawn target model. Insert and root callbacks accept external
+  sessions, move accepts internal item/on-or-between targets, and reorder is
+  limited to internal same-parent boundaries. Valid combined callbacks retain
+  React Aria order, while low-level `onDrop` overrides high-level dispatch.
+  Selected descendants are removed when their selected ancestor is dragged,
+  and internal self/descendant targets are rejected. Dynamic item acceptance
+  and operation callbacks, external files/directories and cross-application
+  transfer, drag previews, and conformance evidence remain separate M7 work,
+  so no affected family is marked conformant.
 
 - `NativeInputModality` represents keyboard, mouse, touch, pen, virtual, and
   unknown input.
@@ -598,7 +604,7 @@ props:
 | Priority | Area | Required outcome |
 | --- | --- | --- |
 | P0 | Self-drawn component accounting | Keep all 51 React Aria 1.19.0 families in the executable matrix, implement the eight recorded public-part gaps, and require every upstream catalog delta to update code, matrix, tests, and milestones together. |
-| P0 | Shared self-drawn interaction | Extend the landed stable-id pointer, keyboard, Tab-focus, hover, press, scheduled generic long press, incremental captured move, typed source/target drag negotiation, collection item/between/root delegates, cancellation, wheel, bubbling, and reducer path with reorder/move policy, dynamic item acceptance, external file/directory transfer, drag previews, collection long-press selection mode, focus-scope restoration, overlay gestures, text editing/IME, and accessibility activation. |
+| P0 | Shared self-drawn interaction | Extend the landed stable-id pointer, keyboard, Tab-focus, hover, press, scheduled generic long press, incremental captured move, typed source/target drag negotiation, collection item/between/root delegates plus reorder/move policy, cancellation, wheel, bubbling, and reducer path with dynamic item/operation acceptance, external file/directory transfer, drag previews, collection long-press selection mode, focus-scope restoration, overlay gestures, text editing/IME, and accessibility activation. |
 | P0 | Native input conformance | WinUI's complete 98-case V1 manifest passes real OS automation. Populate the AppKit and GTK4 manifests with platform-run mouse, pen, touch where applicable, keyboard, assistive activation, disabled, cancellation, and keyed-rerender fixtures for every role currently marked native; then close or retain evidence-backed menu/item exceptions. |
 | P1 | Event propagation | Add platform-run conformance fixtures for conditional `Stop`/`Continue` across nested native controls. |
 | P1 | Focus management | Add platform-run conformance fixtures for post-mount `autoFocus`, nested containment, and restoration. |

docs/roadmap.md

@@ -513,14 +513,17 @@ Landed evidence:
 - collection drag sources aggregate the stable keys, payloads, and visual
   dragging state of selected draggable items. The layout-backed delegate emits
   React Aria-shaped root and keyed before/on/after targets, routes
-  `onRootDrop`/`onItemDrop`/`onInsert` with low-level `onDrop` precedence, and
-  treats a collection as one Tab target with arrow/Home/End navigation inside
-  it. ListBox, GridList, Tree, Table, and explicit DropIndicator authoring all
-  lower to this shared self-drawn path
+  external `onRootDrop`/`onInsert`, item `onItemDrop`, internal `onMove`, and
+  same-parent `onReorder` with ordered multi-callback dispatch and low-level
+  `onDrop` precedence. It filters selected descendants, rejects internal
+  self/descendant targets, treats adjacent insertion descriptors as one target,
+  and exposes each collection as one Tab stop with arrow/Home/End navigation.
+  ListBox, GridList, Tree, Table, and explicit DropIndicator authoring all lower
+  to this shared self-drawn path
 - the shared 410x620 calculator preserves its reviewed layout and scene
   fingerprints, routes eight fake-host events through four reducer actions,
   commits the resulting frames, and reaches display value `10`
-- 53 focused runtime/software tests plus four recursive H1 firewall tests are
+- 59 focused runtime/software tests plus four recursive H1 firewall tests are
   included in `just verify`
 
 Remaining H1 work:
@@ -529,10 +532,10 @@ Remaining H1 work:
   pinned Graphics commit `8748fab` owns only a surface-independent texture and
   readback today, so its safe host-owned surface attachment/recovery contract
   must land before GUI can implement this edge without duplicating `wgpu`
-- collection reorder/move policy and acceptance callbacks, native
-  file/directory and cross-application transfer, drag previews, text editing,
-  IME, overlay gestures, and component-specific pixel/accessibility/real-host
-  conformance remain explicit M4 and M6-M8 work
+- dynamic collection item/operation acceptance callbacks, native file/directory
+  and cross-application transfer, drag previews, text editing, IME, overlay
+  gestures, and component-specific pixel/accessibility/real-host conformance
+  remain explicit M4 and M6-M8 work
 
 Gates:
 
@@ -742,9 +745,9 @@ self-drawn conformance.
 - close the executable 1.19.0 behavior deltas: embedded-control keyboard
   navigation for GridList/Tree, Menu action key plus value, arbitrary Popover
   target rectangles, and multi-MIME/wildcard drag type negotiation
-- build on the landed shared collection root/item/insertion delegate with
-  reorder, cross-collection move, dynamic item acceptance, drag previews, and
-  software/accessibility/three-host conformance stories
+- build on the landed shared collection root/item/insertion delegate and
+  reorder/move policies with dynamic item/operation acceptance, OS transfer,
+  drag previews, and software/accessibility/three-host conformance stories
 
 ### M8 - Date, color, tables, and advanced data
 

docs/rsx.md

@@ -601,10 +601,12 @@ the same typed transfer context.
 
 `UiListBox`, `UiGridList`, `UiTree`, and `UiTable` also expose the shared
 collection contract. Their roots accept `onRootDrop`, `onItemDrop`, `onInsert`,
-the low-level overriding `onDrop`, lifecycle handlers, `acceptedDragTypes`,
-`dropOperation`, `allowedDropOperations`, and `dropOrientation`. Item/row
-components accept a stable `id` plus `isDraggable`, `dragType`, `dragValue`,
-and `dragItems`; `UiDropIndicator.targetKey` references that `id`.
+`onReorder`, `onMove`, the low-level overriding `onDrop`, lifecycle handlers,
+`acceptedDragTypes`, `dropOperation`, `allowedDropOperations`, and
+`dropOrientation`. Collection `onMove` lowers to a dedicated native event so
+it does not collide with the generic move-gesture callback. Item/row components
+accept a stable `id` plus `isDraggable`, `dragType`, `dragValue`, and
+`dragItems`; `UiDropIndicator.targetKey` references that `id`.
 Dragging a selected item aggregates all selected draggable item keys and
 payloads; dragging an unselected item keeps a single-item session.
 
@@ -614,9 +616,15 @@ descriptor shaped as `{type: "root"}` or
 delegation derives targets from the committed self-drawn boxes. During a
 keyboard drag, Tab visits the collection once and Arrow/Home/End keys navigate
 inside it. `UiDropIndicator targetKey="..." dropPosition="before|after"`
-provides a stable explicit insertion visual. External OS files/directories,
-cross-application transfer, drag previews, reorder/move policy, and final
-accessibility/host conformance remain separate work.
+provides a stable explicit insertion visual. `onInsert` and `onRootDrop` accept
+external collection sessions; internal `onMove` accepts item/on-or-between
+targets, while `onReorder` accepts same-parent boundaries. `onItemDrop` plus
+`onMove`, or `onMove` plus `onReorder`, may both run in React Aria order;
+low-level `onDrop` replaces this routing. Self and descendant targets are
+rejected, and adjacent `after`/`before` boundaries are equivalent. Dynamic
+acceptance/operation callbacks, external OS files/directories,
+cross-application transfer, drag previews, and final accessibility/host
+conformance remain separate work.
 
 Runtime lifecycle and effects:
 

src/platform_runtime/drag_drop.rs

@@ -208,6 +208,8 @@ impl SelfDrawnDropTarget {
             "onRootDrop",
             "onItemDrop",
             "onInsert",
+            "onReorder",
+            "onCollectionMove",
             "onDropEnter",
             "onDropMove",
             "onDropExit",

src/platform_runtime/drag_drop_collection.rs

@@ -47,10 +47,12 @@ impl SelfDrawnCollectionDropTarget {
 pub(super) struct SelfDrawnCollectionDropConfig {
     pub(super) target: SelfDrawnDropTarget,
     pub(super) orientation: Orientation,
-    low_level_drop: bool,
-    allows_root: bool,
-    allows_item: bool,
-    allows_insert: bool,
+    low_level_drop: Option<String>,
+    root_drop: Option<String>,
+    item_drop: Option<String>,
+    insert: Option<String>,
+    reorder: Option<String>,
+    move_within: Option<String>,
 }
 
 impl SelfDrawnCollectionDropConfig {
@@ -62,47 +64,93 @@ impl SelfDrawnCollectionDropConfig {
             return None;
         }
         let target = target?;
-        let low_level_drop = has_event(props, "onDrop");
-        let allows_root = low_level_drop || has_event(props, "onRootDrop");
-        let allows_item = low_level_drop || has_event(props, "onItemDrop");
-        let allows_insert = low_level_drop || has_event(props, "onInsert");
-        if !allows_root && !allows_item && !allows_insert {
+        let low_level_drop = event_action(props, "onDrop");
+        let root_drop = event_action(props, "onRootDrop");
+        let item_drop = event_action(props, "onItemDrop");
+        let insert = event_action(props, "onInsert");
+        let reorder = event_action(props, "onReorder");
+        let move_within = event_action(props, "onCollectionMove");
+        if low_level_drop.is_none()
+            && root_drop.is_none()
+            && item_drop.is_none()
+            && insert.is_none()
+            && reorder.is_none()
+            && move_within.is_none()
+        {
             return None;
         }
         Some(Self {
             target,
             orientation: drop_orientation(props),
             low_level_drop,
-            allows_root,
-            allows_item,
-            allows_insert,
+            root_drop,
+            item_drop,
+            insert,
+            reorder,
+            move_within,
         })
     }
 
-    pub(super) fn allows_root(&self) -> bool {
-        self.allows_root
+    pub(super) fn has_low_level_drop(&self) -> bool {
+        self.low_level_drop.is_some()
     }
 
-    pub(super) fn allows_item(&self) -> bool {
-        self.allows_item
+    pub(super) fn has_root_drop(&self) -> bool {
+        self.root_drop.is_some()
     }
 
-    pub(super) fn allows_insert(&self) -> bool {
-        self.allows_insert
+    pub(super) fn has_item_drop(&self) -> bool {
+        self.item_drop.is_some()
     }
 
-    pub(super) fn drop_event_name(&self, target: &SelfDrawnCollectionDropTarget) -> &'static str {
-        if self.low_level_drop {
-            return "onDrop";
-        }
-        match target {
-            SelfDrawnCollectionDropTarget::Root => "onRootDrop",
-            SelfDrawnCollectionDropTarget::Item {
-                drop_position: SelfDrawnDropPosition::On,
-                ..
-            } => "onItemDrop",
-            SelfDrawnCollectionDropTarget::Item { .. } => "onInsert",
-        }
+    pub(super) fn has_insert(&self) -> bool {
+        self.insert.is_some()
+    }
+
+    pub(super) fn has_reorder(&self) -> bool {
+        self.reorder.is_some()
+    }
+
+    pub(super) fn has_move(&self) -> bool {
+        self.move_within.is_some()
+    }
+
+    pub(super) fn allows_root(&self, is_internal: bool) -> bool {
+        self.has_low_level_drop() || (!is_internal && self.has_root_drop())
+    }
+
+    pub(super) fn allows_item(&self, is_internal: bool) -> bool {
+        self.has_low_level_drop() || self.has_item_drop() || (is_internal && self.has_move())
+    }
+
+    pub(super) fn allows_insert(&self, is_internal: bool) -> bool {
+        self.has_low_level_drop()
+            || (!is_internal && self.has_insert())
+            || (is_internal && (self.has_reorder() || self.has_move()))
+    }
+
+    pub(super) fn low_level_action(&self) -> Option<&str> {
+        self.low_level_drop.as_deref()
+    }
+
+    pub(super) fn root_action(&self) -> Option<&str> {
+        self.root_drop.as_deref()
+    }
+
+    pub(super) fn item_action(&self) -> Option<&str> {
+        self.item_drop.as_deref()
+    }
+
+    pub(super) fn insert_action(&self) -> Option<&str> {
+        self.insert.as_deref()
+    }
+
+    pub(super) fn reorder_action(&self) -> Option<&str> {
+        self.reorder.as_deref()
+    }
+
+    pub(super) fn move_action(&self) -> Option<&str> {
+        self.move_within.as_deref()
     }
 }
 
@@ -163,12 +211,14 @@ fn drop_orientation(props: &NativeProps) -> Orientation {
     }
 }
 
-fn has_event(props: &NativeProps, name: &str) -> bool {
+fn event_action(props: &NativeProps, name: &str) -> Option<String> {
     props
         .web
         .events
         .get(name)
-        .is_some_and(|action| !action.trim().is_empty())
+        .map(|action| action.trim())
+        .filter(|action| !action.is_empty())
+        .map(str::to_string)
 }
 
 fn bool_attribute(props: &NativeProps, name: &str) -> bool {