feat(ui): D.5.3/B.1 — UiItemSlot drag source + drop target + accept/reject overlay

- UiElement: two new virtuals GetDragPayload()/GetDragGhost() (default null)
  keep UiRoot item-agnostic; any leaf can opt into drag by overriding these.
- UiItemSlot: SlotIndex + SourceKind properties for payload identity; two
  overrides return ItemDragPayload / icon ghost when the slot is occupied.
  FindList() walks the parent chain to locate the owning UiItemList and its
  registered IItemListDragHandler.
- UiItemSlot.OnEvent: MouseDown now just consumes the press; use-item fires
  on Click (mouse-up) so a drag doesn't also trigger the use-item callback.
  DragEnter → ask handler, set Accept/Reject overlay. DragOver → reset to
  None (fires on leave). DropReleased → clear overlay + dispatch to handler
  when Data0 == 1 (accepted). DragBegin consumed (source).
- OnDraw: accept/reject sprite overlay drawn last, guarded on id != 0 to
  avoid the resolve(0)-→-magenta footgun.
- ToolbarControllerTests: Click_emitsUseForBoundItem changed from MouseDown
  to Click to match the new dispatch.
- 12 new DragDropSpineTests pass; full suite 481/483 (2 pre-existing skips).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

src/AcDream.App/UI/UiElement.cs

@@ -203,6 +203,16 @@ public abstract class UiElement
     /// </summary>
     public virtual bool OnEvent(in UiEvent e) => false;
 
+    /// <summary>The data this element carries when a drag begins. <see cref="UiRoot"/>
+    /// pulls this on drag-promote; a NULL return CANCELS the drag (retail:
+    /// ItemList_BeginDrag only arms an occupied cell). Default null = not draggable.</summary>
+    public virtual object? GetDragPayload() => null;
+
+    /// <summary>The texture <see cref="UiRoot"/> paints at the cursor while this element
+    /// is the drag source: (GL handle, width, height). Null = no ghost. Keeps
+    /// <see cref="UiRoot"/> item-agnostic. Retail analog: m_dragIcon (decomp 229738).</summary>
+    public virtual (uint tex, int w, int h)? GetDragGhost() => null;
+
     /// <summary>
     /// Tooltip text for this widget. Retail fires event 0x07 after
     /// ~1000ms hover, then queries the widget's virtual "GetString"

src/AcDream.App/UI/UiItemSlot.cs

@@ -21,6 +21,29 @@ public sealed class UiItemSlot : UiElement
     /// <summary>Pre-composited icon GL texture for the bound item (0 = none).</summary>
     public uint IconTexture { get; private set; }
 
+    /// <summary>This cell's own index within its panel (0..17 toolbar; container slot
+    /// for inventory). Distinct from <see cref="ShortcutNum"/> (the 1–9 label, -1 on the
+    /// bottom row). Set by the controller; used as the drag payload's SourceSlot and to
+    /// identify the drop TARGET slot.</summary>
+    public int SlotIndex { get; set; } = -1;
+
+    /// <summary>What kind of slot this is, for the drag payload (retail InqDropIconInfo
+    /// flags). Controller overrides; default Inventory.</summary>
+    public ItemDragSource SourceKind { get; set; } = ItemDragSource.Inventory;
+
+    /// <summary>Drag-rollover accept frame (retail ItemSlot_DragOver_Accept 0x060011F9,
+    /// state id 0x10000041). Configurable; guard id != 0 before resolving.</summary>
+    public uint DragAcceptSprite { get; set; } = 0x060011F9u;
+    /// <summary>Drag-rollover reject frame (retail ItemSlot_DragOver_Reject 0x060011F8,
+    /// state id 0x10000040).</summary>
+    public uint DragRejectSprite { get; set; } = 0x060011F8u;
+
+    /// <summary>Accept/reject overlay state while a drag hovers this cell.</summary>
+    public enum DragAcceptState { None, Accept, Reject }
+    private DragAcceptState _dragAccept = DragAcceptState.None;
+    /// <summary>Current overlay state — internal so unit tests can assert it (InternalsVisibleTo).</summary>
+    internal DragAcceptState DragAcceptVisual => _dragAccept;
+
     /// <summary>Empty-slot sprite. Default = the generic toolbar empty-slot border
     /// 0x060074CF (uiitem template 0x21000037, state ItemSlot_Empty). Configurable so
     /// paperdoll equip slots can use their per-slot silhouettes later.</summary>
@@ -37,6 +60,22 @@ public sealed class UiItemSlot : UiElement
 
     public void Clear() { ItemId = 0; IconTexture = 0; }
 
+    /// <inheritdoc/>
+    public override object? GetDragPayload()
+        => ItemId != 0 ? new ItemDragPayload(ItemId, SourceKind, SlotIndex, this) : null;
+
+    /// <inheritdoc/>
+    public override (uint tex, int w, int h)? GetDragGhost()
+        => ItemId != 0 && IconTexture != 0 ? (IconTexture, (int)Width, (int)Height) : null;
+
+    /// <summary>Walk up to the containing <see cref="UiItemList"/> (the drop handler owner).</summary>
+    private UiItemList? FindList()
+    {
+        UiElement? e = Parent;
+        while (e is not null) { if (e is UiItemList l) return l; e = e.Parent; }
+        return null;
+    }
+
     // ── Shortcut number (slot label) ─────────────────────────────────────────
     // Port of UIElement_UIItem::SetShortcutNum (acclient_2013_pseudo_c.txt:229465).
     // Retail draws the digit on the cell's ShortcutNum sub-element, picking the
@@ -100,7 +139,38 @@ public sealed class UiItemSlot : UiElement
     /// <inheritdoc/>
     public override bool OnEvent(in UiEvent e)
     {
-        if (e.Type == UiEventType.MouseDown) { Clicked?.Invoke(); return true; }
+        switch (e.Type)
+        {
+            // Use fires on CLICK (mouse-up over the same cell), not MouseDown — so a
+            // drag (press + >3px move) does NOT also use the item. UiRoot suppresses the
+            // post-drag Click (UiRoot.cs FinishDrag returns before the Click emit).
+            case UiEventType.MouseDown:
+                return true;                       // consume the press; no use here
+            case UiEventType.Click:
+                Clicked?.Invoke();
+                return true;
+
+            case UiEventType.DragBegin:
+                return true;                       // we're the source; payload already pulled by UiRoot
+
+            case UiEventType.DragEnter:            // pointer entered me mid-drag → ask the list's handler
+                _dragAccept = (FindList() is { DragHandler: { } h } list
+                               && e.Payload is ItemDragPayload p && h.OnDragOver(list, this, p))
+                              ? DragAcceptState.Accept : DragAcceptState.Reject;
+                return true;
+
+            case UiEventType.DragOver:             // UiRoot fires this on LEAVE → neutral
+                _dragAccept = DragAcceptState.None;
+                return true;
+
+            case UiEventType.DropReleased:
+                _dragAccept = DragAcceptState.None;
+                if (e.Data0 == 1                   // accepted = dropped on a DIFFERENT element (skips self/empty)
+                    && FindList() is { DragHandler: { } dh } dl
+                    && e.Payload is ItemDragPayload dp)
+                    dh.HandleDropRelease(dl, this, dp);
+                return true;
+        }
         return false;
     }
 
@@ -139,5 +209,19 @@ public sealed class UiItemSlot : UiElement
                 }
             }
         }
+
+        // Drag-rollover accept/reject frame (retail SetDragAcceptState 0x10000041/40).
+        // Guard id != 0 BEFORE resolving — resolve(0) returns the 1×1 magenta placeholder
+        // with a non-zero GL handle (feedback_ui_resolve_zero_magenta).
+        if (_dragAccept != DragAcceptState.None && SpriteResolve is not null)
+        {
+            uint id = _dragAccept == DragAcceptState.Accept ? DragAcceptSprite : DragRejectSprite;
+            if (id != 0)
+            {
+                var (tex, _, _) = SpriteResolve(id);
+                if (tex != 0)
+                    ctx.DrawSprite(tex, 0f, 0f, Width, Height, 0f, 0f, 1f, 1f, Vector4.One);
+            }
+        }
     }
 }