[priard]

What and why

Builds on #69 (the lifted drag). Two things were still weak:

1. Icons jumped during a drag. Each neighbour had three zones: an insert edge, a group middle (76% of it) and the other edge. Dragging across one opened a gap before it, closed it over its middle (that is "make a group") and opened it again after it, so the icons went back and forth under the copy, and a quick drag could make a group by accident.
2. Group changes did not move well:
   • a group made on an app grew beside that app while the app shrank, on opposite curves, so the dock's width overshot;
   • an app dropped into a group faded where it was let go;
   • an app dragged out of an opened group had no copy and the old narrow gap;
   • Ungroup shrank the group while its apps grew in the same place;
   • the last app of a group it left jumped to the end of the pins.

What it does

Neighbours move once. The gap stays where it is until the pointer has gone three quarters of the way over the next element (or back over the previous one). That element then moves once, into the place the gap leaves and away from the pointer, so it does not flicker at the boundary. Pinned apps, group tiles, apps out of a group popup and folders all move this way.

Groups form on a held hover. Over the middle half of an app or a group nothing moves. Held there for half a second, it becomes the target and its halo shows; only then does a drop make or fill a group. Let go before, the element lands where its gap stands, which is what the dock shows.

Group changes hand slots over. An element that takes others' place starts as wide as the room they leave and eases to its own width, so the dock's width moves one way:

• a group made on an app swaps in whole in that app's slot;
• Ungroup's apps share the group's room and open out of it;
• the last app of a group takes the group's place (also a fix: it used to go to the end of the pins, by a drag or the menu alike).

Into a group. Dropped on an app or a group, the copy flies into the group's tile, shrinking to a member's size, and the tile pulses as it takes it.

Out of a group. Dragged out of an opened group, the popup fades but stays as the drag's surface until the button is let go. The app's icon follows the pointer, drawn in the dock and over the popup at the same place, so it crosses the edge between the two surfaces whole. The gap opens one tile wide, and on the drop the room it holds goes to the app's new slot. Let go over its own group, the icon flies back in.

How

• Hand-over (DockLift.handOff(fromKeys, room) / handOn(toKeys), RowSlot): a slot leaving under handOff adds its width to the open batch and snaps out; the slots named by handOn stand at an equal share of that room until they settle, then ease to their own width (_base). A single one swaps in whole, without the fade and scale. Batches nest (an app dragged out of a group that dissolves), and each slot takes its own share once it has read it. DockGroupsLogic.handOver(root, keys, change) wraps group creation, Ungroup and the dissolve.
• One curve. The empty room a dropped element leaves closes on OutCubic, the curve the slots taking its room open on; with opposite curves the width overshot. Without layout motion (Reduced) it goes at once.
• Sticky drop places: DockDragLogic.stickyIndex keeps the insert index until the pointer passes 75% of the next element or 25% of the previous one. Held hover: DockLift.dwell(key) sets dropTargetAppId / dropTargetGroupId after 500 ms on the same candidate. While a target is set the gap stays where it was (DockCard.dropLineRow).
• Flying in: DockLift.settle(key, fade, into) heads the copy's icon for the group's icon and scales it around its centre; absorbed(key) makes the slot pulse.
• Out of a popup: DockLift.beginIcon draws the app's icon (LiftIcon, the dock's DockIconArt settings) instead of a ShaderEffectSource. AppGroupPopup mirrors it on the popup's surface through DockPopupWindow.fromDockWindow (the inverse of toDockWindow). The popup's close frame follows the faded body, so it does not flash back.

Depends on #69

This is cut from feat/drag-lift (#69); the diff includes it until it merges. The commits of this PR are the two after it, from "feat(drag): group changes move as one" on. I'll rebase onto experimental once #69 is in.

Verification

• node --check of the model files and node --test tests/unit/*.test.mjs tests/unit/*.test.js (252 pass)
• python3 -m unittest discover -s tests/unit -p 'test_*.py'
• qmllint (no new error kinds)
• security-grep.py, structure-check.py, shaders-in-sync.sh
• ./tests/manifest-check.sh . and omarchy plugin validate .
• ./tests/smoke-test.sh against a running dock
• Live, with a temporary IPC that drives the drag handlers and samples the card's width and each slot's width every ~16 ms:
  • group made on an app: the width moves one way (it overshot by ~22 px with labels before);
  • Ungroup: one smooth move, no frame with a hole;
  • an app out of a group popup into the run, the group dissolving: the width stays constant on the drop;
  • into an existing group, reorder: one way / constant;
  • Reduced and Off: the widths change at once;
  • a pointer swept slowly across the neighbours: each moves once, at 75%, the index holds on the way back until 25%, and the halo shows only after the hold.

[thepathless]

Thank you @priard — merged into v4.7.0! The three-quarter steady-drop threshold plus the 500ms single-shot dwell halo (groups form on held hover, never by accident) resolves the back-and-forth icon dance elegantly, and both timers are single-shot so the zero-CPU invariant holds. Verified on experimental: 254 Node + 116 Python tests, qmllint 0 errors, structure-check PASSED.