@grafloria/element 0.4.31 → 0.4.33

package/src/lib/dashboard-kit/grid-binder.js

@@ -156,6 +156,38 @@ export function pressOnDragHandle(sel, target, hostEl, clientX, clientY) {
 export const CAPTION_BAND = 28;
 /** A torn-out page never arrives shorter than this: a strip with no room under it is not a group. */
 export const TEAR_OUT_MIN_ROWS = 2;
+/**
+ * Steps that depend on each other's RESULT — create a group, then move a page
+ * into it, then place the group on the board; or remove a member and then the
+ * group it emptied — run as one history step. A batch checks every member's
+ * `canExecute` before running any of them and every member's `canUndo` before
+ * undoing any, and a membership command's precondition (its group exists) is
+ * exactly what a neighbouring step creates or removes. This runs the chain in
+ * order and reverses it on undo, judging nothing up front.
+ */
+export class SequenceCommand extends Command {
+    constructor(name, steps) {
+        super(name);
+        this.steps = steps;
+    }
+    execute(context) {
+        for (const c of this.steps)
+            c.execute(context);
+    }
+    undo(context) {
+        for (let i = this.steps.length - 1; i >= 0; i--)
+            this.steps[i].undo(context);
+    }
+    canExecute() {
+        return true;
+    }
+    canUndo() {
+        return true;
+    }
+    serialize() {
+        return { id: this.id, name: this.name, timestamp: this.timestamp, data: { steps: this.steps.map((c) => c.serialize()) } };
+    }
+}
 /**
  * Binders on the same canvas find each other here. A WeakMap: a canvas that
  * is gone takes its (empty) peer set with it — the strong Map it replaced kept
@@ -1257,6 +1289,8 @@ export function bindDashboardGrid(api, group, options = {}) {
         return false;
     };
     let slabGesture = null;
+    /** The slab gesture as it is NOW — read through a call so a guard's narrowing does not stick. */
+    const currentSlab = () => slabGesture;
     /** The PARENT running a resize of OUR section from a press this tool claimed. */
     let forwardSlab = null;
     const frameOfGroup = (grp) => ({ x: grp.position.x, y: grp.position.y, width: sizeOf(grp).width, height: sizeOf(grp).height });
@@ -1281,10 +1315,48 @@ export function bindDashboardGrid(api, group, options = {}) {
                 dx: edges.e ? grp.position.x + sizeOf(grp).width - ev.world.x : edges.w ? grp.position.x - ev.world.x : 0,
                 dy: edges.s ? grp.position.y + sizeOf(grp).height - ev.world.y : edges.n ? grp.position.y - ev.world.y : 0,
             },
+            move: false,
         };
         capturePointer(slabGesture.pointerId);
         api.container.style.cursor = cursorFor(edges);
     };
+    /**
+     * MOVE a section by its caption band or its strip's empty space. A section
+     * is a LOCKED tile so that nothing pushes it; for the gesture's duration the
+     * tile is unlocked (it is the one moving), other sections stay locked and
+     * still refuse it (E4b), and every unlocked tile gets pushed the way a
+     * widget pushes it. Its children ride along: the frame moves, the nested
+     * board re-projects.
+     */
+    const beginSlabMove = (id, ev) => {
+        const grp = diagram.getGroup(id);
+        const it = engine.getItem(id);
+        if (!grp || !it || gesture || slabGesture || isStatic)
+            return;
+        engine.beginGesture();
+        const snap = snapshotAll();
+        it.locked = false;
+        slabGesture = {
+            id,
+            edges: NO_EDGES,
+            pointerId: typeof PointerEvent !== 'undefined' && ev.source instanceof PointerEvent ? ev.source.pointerId : null,
+            started: false,
+            downScreen: { x: ev.screen.x, y: ev.screen.y },
+            startCells: snap.cells,
+            startGeom: snap.geoms,
+            cellBefore: { x: it.x, y: it.y, w: it.w, h: it.h },
+            frameBefore: frameOfGroup(grp),
+            grab: { dx: grp.position.x - ev.world.x, dy: grp.position.y - ev.world.y },
+            move: true,
+        };
+        capturePointer(slabGesture.pointerId);
+        api.container.style.cursor = 'grabbing';
+    };
+    const relockSlab = (id) => {
+        const it = engine.getItem(id);
+        if (it)
+            it.locked = true;
+    };
     const slabMove = (ev) => {
         const g = slabGesture;
         if (!g)
@@ -1300,6 +1372,14 @@ export function bindDashboardGrid(api, group, options = {}) {
             return;
         const f = frame();
         const gg = geom();
+        if (g.move) {
+            // The section's top-left follows the pointer by the offset it was grabbed at.
+            const cell = pointToCell(ev.world.x + g.grab.dx, ev.world.y + g.grab.dy, f, gg, rows(), it.w);
+            if ((cell.x !== it.x || cell.y !== it.y) && engine.moveCheck(g.id, cell.x, cell.y, { gate: false }).changed)
+                project();
+            syncPlaceholder();
+            return;
+        }
         const cu = columnUnitFor(gg, f.width);
         const rh = rowHeightFor(gg, rows());
         // The grid line nearest the pointer, in cells (mirrored on RTL).
@@ -1346,6 +1426,8 @@ export function bindDashboardGrid(api, group, options = {}) {
         slabGesture = null;
         releasePointer(g.pointerId);
         api.container.style.cursor = '';
+        if (g.move)
+            relockSlab(g.id);
         if (!g.started) {
             engine.endGesture();
             return;
@@ -1359,11 +1441,11 @@ export function bindDashboardGrid(api, group, options = {}) {
         if (it && grp && (b.x !== it.x || b.y !== it.y || b.w !== it.w || b.h !== it.h)) {
             commands.push(new SetGroupCellCommand(g.id, b, { x: it.x, y: it.y, w: it.w, h: it.h }, g.frameBefore, frameOfGroup(grp)));
         }
-        const changed = execute('Resize section', commands);
+        const changed = execute(g.move ? 'Move section' : 'Resize section', commands);
         disarmGlideSoon();
         syncHandles();
         api.renderNow();
-        (_a = options.onGesture) === null || _a === void 0 ? void 0 : _a.call(options, { type: 'commit', kind: 'resize', nodeId: g.id, changed });
+        (_a = options.onGesture) === null || _a === void 0 ? void 0 : _a.call(options, { type: 'commit', kind: g.move ? 'move' : 'resize', nodeId: g.id, changed });
     };
     const slabCancel = () => {
         var _a;
@@ -1373,6 +1455,8 @@ export function bindDashboardGrid(api, group, options = {}) {
         slabGesture = null;
         releasePointer(g.pointerId);
         api.container.style.cursor = '';
+        if (g.move)
+            relockSlab(g.id);
         if (g.started)
             engine.cancelGesture();
         else
@@ -1487,9 +1571,13 @@ export function bindDashboardGrid(api, group, options = {}) {
         (_a = options.onGesture) === null || _a === void 0 ? void 0 : _a.call(options, { type: 'commit', kind: g.kind, nodeId: g.id, changed });
     };
     const cancelActiveGesture = (notify = true) => {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
+        if (gesture === null || gesture === void 0 ? void 0 : gesture.strip) {
+            (_a = options.tabDrop) === null || _a === void 0 ? void 0 : _a.markDrop(null, null);
+            gesture.strip = null;
+        }
         if (forwardSlab) {
-            (_a = forwardSlab.slabCancel) === null || _a === void 0 ? void 0 : _a.call(forwardSlab);
+            (_b = forwardSlab.slabCancel) === null || _b === void 0 ? void 0 : _b.call(forwardSlab);
             forwardSlab = null;
         }
         if (slabGesture)
@@ -1514,7 +1602,7 @@ export function bindDashboardGrid(api, group, options = {}) {
                 engine.endGesture();
                 const items = [];
                 for (const [id, c] of g.startCells) {
-                    const lockedNode = ((_c = (_b = diagram.getNode(id)) === null || _b === void 0 ? void 0 : _b.state) === null || _c === void 0 ? void 0 : _c.locked) === true;
+                    const lockedNode = ((_d = (_c = diagram.getNode(id)) === null || _c === void 0 ? void 0 : _c.state) === null || _d === void 0 ? void 0 : _d.locked) === true;
                     items.push(Object.assign(Object.assign({ id }, c), { locked: lockedNode || isGroupMember(id) }));
                 }
                 engine = engineFrom(items);
@@ -1562,7 +1650,7 @@ export function bindDashboardGrid(api, group, options = {}) {
         enforceBoardHeight();
         api.renderNow();
         if (notify) {
-            (_d = options.onGesture) === null || _d === void 0 ? void 0 : _d.call(options, { type: 'cancel', kind: g.kind, nodeId: g.id, changed: false });
+            (_e = options.onGesture) === null || _e === void 0 ? void 0 : _e.call(options, { type: 'cancel', kind: g.kind, nodeId: g.id, changed: false });
         }
     };
     /** Centre a w×h-span tile's top-left under the cursor, in world px. */
@@ -1577,7 +1665,7 @@ export function bindDashboardGrid(api, group, options = {}) {
         };
     };
     const onToolMove = (ev) => {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         const g = gesture;
         if (!g || g.kind === 'palette')
             return;
@@ -1594,6 +1682,36 @@ export function bindDashboardGrid(api, group, options = {}) {
             ghostStyleFastPath(g, desired);
             g.lastWorld = { x: ev.world.x, y: ev.world.y };
             g.lastScreen = { x: ev.screen.x, y: ev.screen.y };
+            // A TAB STRIP under the pointer wins over every board: the widget will
+            // become a new tab there, so it leaves this board (survivors settle
+            // home) and the strip marks the slot.
+            if (options.tabDrop && !isStatic) {
+                const crect = api.container.getBoundingClientRect();
+                const hitStrip = options.tabDrop.stripAt(crect.left + ev.screen.x, crect.top + ev.screen.y);
+                if (hitStrip) {
+                    if (g.leg) {
+                        g.leg.adopted.abort();
+                        g.leg = null;
+                    }
+                    if (!g.removedFromBoard) {
+                        g.removedFromBoard = true;
+                        engine.remove(g.id);
+                        project();
+                    }
+                    (_a = hostOf(g.id)) === null || _a === void 0 ? void 0 : _a.classList.remove('axdb-out');
+                    if (!g.strip || g.strip.containerId !== hitStrip.containerId || g.strip.index !== hitStrip.index) {
+                        options.tabDrop.markDrop(hitStrip.containerId, hitStrip.index);
+                    }
+                    g.strip = hitStrip;
+                    syncPlaceholder();
+                    api.render();
+                    return;
+                }
+                if (g.strip) {
+                    options.tabDrop.markDrop(null, null);
+                    g.strip = null;
+                }
+            }
             // Deepest board under the pointer wins: the nested KPI strip beats the
             // tab that contains it; a foreign board beats "outside". Strict frames
             // first; the one-row grace band below each board (gridstack's extra
@@ -1633,13 +1751,13 @@ export function bindDashboardGrid(api, group, options = {}) {
                         height: g.node.size.height,
                     });
                     if (adopted) {
-                        (_a = hostOf(g.id)) === null || _a === void 0 ? void 0 : _a.classList.remove('axdb-out');
+                        (_b = hostOf(g.id)) === null || _b === void 0 ? void 0 : _b.classList.remove('axdb-out');
                         g.leg = { peer, adopted };
                         g.leg.adopted.move(ev.world);
                     }
                     else {
                         // Bounded/full board refused the adoption: dim = will snap home.
-                        (_b = hostOf(g.id)) === null || _b === void 0 ? void 0 : _b.classList.add('axdb-out');
+                        (_c = hostOf(g.id)) === null || _c === void 0 ? void 0 : _c.classList.add('axdb-out');
                     }
                 }
             }
@@ -1651,7 +1769,7 @@ export function bindDashboardGrid(api, group, options = {}) {
                 }
                 if (g.removedFromBoard) {
                     g.removedFromBoard = false;
-                    (_c = hostOf(g.id)) === null || _c === void 0 ? void 0 : _c.classList.remove('axdb-out');
+                    (_d = hostOf(g.id)) === null || _d === void 0 ? void 0 : _d.classList.remove('axdb-out');
                     const cell = pointToCell(desired.x, desired.y, frame(), geom(), rows(), g.spans.w);
                     // Re-enter at the bottom edge (collision-free), then take the cursor
                     // cell GATELESSLY — a first placement skips the anti-jitter gate.
@@ -1660,7 +1778,7 @@ export function bindDashboardGrid(api, group, options = {}) {
                     project();
                 }
                 else {
-                    const spanW = (_e = (_d = engine.getItem(g.id)) === null || _d === void 0 ? void 0 : _d.w) !== null && _e !== void 0 ? _e : g.spans.w;
+                    const spanW = (_f = (_e = engine.getItem(g.id)) === null || _e === void 0 ? void 0 : _e.w) !== null && _f !== void 0 ? _f : g.spans.w;
                     const cell = pointToCell(desired.x, desired.y, frame(), geom(), rows(), spanW);
                     if (engine.moveCheck(g.id, cell.x, cell.y).changed)
                         project();
@@ -1675,7 +1793,7 @@ export function bindDashboardGrid(api, group, options = {}) {
                 if (!g.removedFromBoard) {
                     g.removedFromBoard = true;
                     engine.remove(g.id); // survivors settle home; cells minted nowhere
-                    (_f = hostOf(g.id)) === null || _f === void 0 ? void 0 : _f.classList.add('axdb-out');
+                    (_g = hostOf(g.id)) === null || _g === void 0 ? void 0 : _g.classList.add('axdb-out');
                     project();
                 }
             }
@@ -1785,7 +1903,7 @@ export function bindDashboardGrid(api, group, options = {}) {
                     maxRows = n;
                     engine.maxRows = n;
                 };
-                const slabRows = (_h = (_g = parent.memberCell(group.id)) === null || _g === void 0 ? void 0 : _g.h) !== null && _h !== void 0 ? _h : maxRows;
+                const slabRows = (_j = (_h = parent.memberCell(group.id)) === null || _h === void 0 ? void 0 : _h.h) !== null && _j !== void 0 ? _j : maxRows;
                 const inner = maxRows;
                 const rhNow = rowHeightFor(geom(), rows());
                 const rowPx = rhNow + gap;
@@ -1949,7 +2067,7 @@ export function bindDashboardGrid(api, group, options = {}) {
         const anchorBottom = liveRect ? liveRect.y + liveRect.height : bottom;
         const px = E.w ? anchorRight - w : anchorLeft;
         const py = E.n ? anchorBottom - h : anchorTop;
-        g.node.setSize(w, h, (_j = g.node.size.depth) !== null && _j !== void 0 ? _j : 0);
+        g.node.setSize(w, h, (_k = g.node.size.depth) !== null && _k !== void 0 ? _k : 0);
         g.node.setPosition(px, py);
         ghostStyleFastPath(g, { x: px, y: py, width: w, height: h });
         const spanF = bound() !== undefined ? frame() : f;
@@ -1990,7 +2108,7 @@ export function bindDashboardGrid(api, group, options = {}) {
         syncPlaceholder();
     };
     const onToolUp = () => {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         const g = gesture;
         if (!g || g.kind === 'palette')
             return;
@@ -1998,6 +2116,36 @@ export function bindDashboardGrid(api, group, options = {}) {
             gesture = null; // a plain click — the page's own click-to-focus handles it
             return;
         }
+        if (g.strip && options.tabDrop) {
+            // -- INTO A STRIP: the widget becomes a new tab of that container ------
+            const target = g.strip;
+            g.strip = null;
+            options.tabDrop.markDrop(null, null);
+            if (g.leg) {
+                g.leg.adopted.abort();
+                g.leg = null;
+            }
+            const displaced = buildCommitCommands(deltasSince(g.startCells, g.startGeom, g.id));
+            const snap = g.startGeom.get(g.id);
+            if (snap) {
+                g.node.setPosition(snap.pos.x, snap.pos.y);
+                g.node.setSize(snap.size.width, snap.size.height, (_a = snap.size.depth) !== null && _a !== void 0 ? _a : 0);
+            }
+            const cmds = options.tabDrop.dropIntoStrip(g.id, target.containerId, target.index, group.id, displaced);
+            if (cmds.length === 0) {
+                cancelActiveGesture();
+                return;
+            }
+            engine.endGesture();
+            cleanupGestureVisuals(g);
+            gesture = null;
+            execute('Move widget into a new tab', cmds);
+            enforceBoardHeight();
+            persistLayouts();
+            api.renderNow();
+            (_b = options.onGesture) === null || _b === void 0 ? void 0 : _b.call(options, { type: 'commit', kind: g.kind, nodeId: g.id, changed: true });
+            return;
+        }
         if (g.leg) {
             // -- CROSS-CONTAINER COMMIT: one batch across both boards -----------
             const fin = g.leg.adopted.finalize();
@@ -2040,21 +2188,25 @@ export function bindDashboardGrid(api, group, options = {}) {
                         isGroup: false,
                         cellBefore: before !== null && before !== void 0 ? before : fin.cell,
                         cellAfter: fin.cell,
-                        posBefore: (_a = geomBefore === null || geomBefore === void 0 ? void 0 : geomBefore.pos) !== null && _a !== void 0 ? _a : { x: fin.rect.x, y: fin.rect.y },
+                        posBefore: (_c = geomBefore === null || geomBefore === void 0 ? void 0 : geomBefore.pos) !== null && _c !== void 0 ? _c : { x: fin.rect.x, y: fin.rect.y },
                         posAfter: { x: fin.rect.x, y: fin.rect.y },
-                        sizeBefore: (_b = geomBefore === null || geomBefore === void 0 ? void 0 : geomBefore.size) !== null && _b !== void 0 ? _b : { width: fin.rect.width, height: fin.rect.height },
+                        sizeBefore: (_d = geomBefore === null || geomBefore === void 0 ? void 0 : geomBefore.size) !== null && _d !== void 0 ? _d : { width: fin.rect.width, height: fin.rect.height },
                         sizeAfter: { width: fin.rect.width, height: fin.rect.height },
                     },
                 ]),
             ];
-            execute('Move widget', crossing);
+            // …and whatever follows a member out of this board: an emptied page
+            // closes — in which case the membership commands ride INSIDE one
+            // sequence with it, or the batch could never undo (its group is gone).
+            const leaving = (_f = (_e = options.onMemberLeaving) === null || _e === void 0 ? void 0 : _e.call(options, g.id)) !== null && _f !== void 0 ? _f : [];
+            execute('Move widget', leaving.length > 0 ? [new SequenceCommand('Move widget', [...crossing, ...leaving])] : crossing);
             engine.endGesture();
             cleanupGestureVisuals(g);
             gesture = null;
             enforceBoardHeight();
             persistLayouts();
             api.renderNow();
-            (_c = options.onGesture) === null || _c === void 0 ? void 0 : _c.call(options, { type: 'commit', kind: g.kind, nodeId: g.id, changed: true });
+            (_g = options.onGesture) === null || _g === void 0 ? void 0 : _g.call(options, { type: 'commit', kind: g.kind, nodeId: g.id, changed: true });
             return;
         }
         if (g.removedFromBoard && dragOut === 'cancel') {
@@ -2085,15 +2237,15 @@ export function bindDashboardGrid(api, group, options = {}) {
                 // Park the node on its start rect so the page's RemoveNodeCommand
                 // captures sane geometry for undo.
                 g.node.setPosition(snap.pos.x, snap.pos.y);
-                g.node.setSize(snap.size.width, snap.size.height, (_d = snap.size.depth) !== null && _d !== void 0 ? _d : 0);
+                g.node.setSize(snap.size.width, snap.size.height, (_h = snap.size.depth) !== null && _h !== void 0 ? _h : 0);
             }
             engine.endGesture();
             cleanupGestureVisuals(g);
             gesture = null;
             enforceBoardHeight();
             api.renderNow();
-            void ((_e = options.onRemoveRequest) === null || _e === void 0 ? void 0 : _e.call(options, g.id, displaced));
-            (_f = options.onGesture) === null || _f === void 0 ? void 0 : _f.call(options, { type: 'remove', kind: g.kind, nodeId: g.id, changed: true });
+            void ((_j = options.onRemoveRequest) === null || _j === void 0 ? void 0 : _j.call(options, g.id, displaced));
+            (_k = options.onGesture) === null || _k === void 0 ? void 0 : _k.call(options, { type: 'remove', kind: g.kind, nodeId: g.id, changed: true });
             return;
         }
         commitGesture(g);
@@ -2301,6 +2453,34 @@ export function bindDashboardGrid(api, group, options = {}) {
         syncPlaceholder();
         return {
             groupId: group.id,
+            baseline: () => startCells,
+            place: (cell) => {
+                if (!engine.getItem(node.id) && !engine.add({ id: node.id, x: 0, y: engine.rows(), w: cell.w, h: cell.h }))
+                    return false;
+                const it = engine.getItem(node.id);
+                if (!it)
+                    return false;
+                // Shrink, move, then grow. A resize is clamped at the board's edge
+                // where the ghost SITS, so a cell wider than fits there (a full-width
+                // dock from a ghost parked mid-board) is reached by moving first —
+                // and a cell narrower than the ghost by shrinking first, so the move
+                // itself fits.
+                const w0 = Math.min(it.w, cell.w);
+                const h0 = Math.min(it.h, cell.h);
+                if (w0 !== it.w || h0 !== it.h)
+                    engine.resizeCheck(node.id, w0, h0);
+                const moved = engine.getItem(node.id);
+                if (moved && (moved.x !== cell.x || moved.y !== cell.y))
+                    engine.moveCheck(node.id, cell.x, cell.y, { gate: false });
+                const now = engine.getItem(node.id);
+                if (now && (now.w !== cell.w || now.h !== cell.h))
+                    engine.resizeCheck(node.id, cell.w, cell.h);
+                lastWant = null;
+                project();
+                syncPlaceholder();
+                const at = engine.getItem(node.id);
+                return !!at && at.x === cell.x && at.y === cell.y && at.w === cell.w && at.h === cell.h;
+            },
             move: (w) => {
                 const item = engine.getItem(node.id);
                 if (!item)
@@ -2354,11 +2534,29 @@ export function bindDashboardGrid(api, group, options = {}) {
                 const cell = { x: item.x, y: item.y, w: item.w, h: item.h };
                 const rect = cellToRect(item, frame(), geom(), rows());
                 const commands = buildCommitCommands(deltasSince(startCells, startGeom, node.id));
+                const groups = [];
+                for (const [id, before] of startCells) {
+                    if (!isGroupMember(id))
+                        continue;
+                    const it = engine.getItem(id);
+                    const g0 = startGeom.get(id);
+                    if (!it || !g0)
+                        continue;
+                    if (it.x === before.x && it.y === before.y && it.w === before.w && it.h === before.h)
+                        continue;
+                    groups.push({
+                        id,
+                        cellBefore: before,
+                        cellAfter: { x: it.x, y: it.y, w: it.w, h: it.h },
+                        frameBefore: { x: g0.pos.x, y: g0.pos.y, width: g0.size.width, height: g0.size.height },
+                        frameAfter: cellToRect(it, frame(), geom(), rows()),
+                    });
+                }
                 engine.endGesture();
                 adoptedGhostId = null;
                 disarmGlideSoon();
                 syncPlaceholder();
-                return { commands, cell, rect };
+                return { commands, cell, rect, groups };
             },
         };
     };
@@ -2388,6 +2586,56 @@ export function bindDashboardGrid(api, group, options = {}) {
             beginSlabResize(id, edges, ev);
             return (slabGesture === null || slabGesture === void 0 ? void 0 : slabGesture.id) === id;
         },
+        beginSlabMove: (id, ev) => {
+            if (isStatic)
+                return false;
+            beginSlabMove(id, ev);
+            return (slabGesture === null || slabGesture === void 0 ? void 0 : slabGesture.id) === id;
+        },
+        dragMember: (id, ev) => {
+            var _a;
+            if (isStatic || disposed || !engine.getItem(id) || gesture || slabGesture)
+                return false;
+            const toTool = (e) => {
+                var _a;
+                const rect = api.container.getBoundingClientRect();
+                const world = ((_a = api.viewport) === null || _a === void 0 ? void 0 : _a.clientToWorld) ? api.viewport.clientToWorld(e.clientX, e.clientY, rect) : { x: e.clientX - rect.left, y: e.clientY - rect.top };
+                return { world, screen: { x: e.clientX - rect.left, y: e.clientY - rect.top }, source: e };
+            };
+            beginSlabMove(id, toTool(ev));
+            if (((_a = currentSlab()) === null || _a === void 0 ? void 0 : _a.id) !== id)
+                return false;
+            const detachAll = () => {
+                window.removeEventListener('pointermove', onMove, true);
+                window.removeEventListener('pointerup', onUp, true);
+                window.removeEventListener('pointercancel', onCancel, true);
+                window.removeEventListener('keydown', onKey, true);
+            };
+            const onMove = (e) => {
+                var _a;
+                if (disposed || ((_a = currentSlab()) === null || _a === void 0 ? void 0 : _a.id) !== id)
+                    return detachAll();
+                slabMove(toTool(e));
+                api.render();
+            };
+            const onUp = () => {
+                detachAll();
+                slabUp();
+            };
+            const onCancel = () => {
+                detachAll();
+                slabCancel();
+            };
+            const onKey = (e) => {
+                if (e.key === 'Escape')
+                    onCancel();
+            };
+            window.addEventListener('pointermove', onMove, true);
+            window.addEventListener('pointerup', onUp, true);
+            window.addEventListener('pointercancel', onCancel, true);
+            window.addEventListener('keydown', onKey, true);
+            return true;
+        },
         slabMove: (ev) => slabMove(ev),
         slabUp: () => slabUp(),
         slabCancel: () => slabCancel(),
@@ -2494,7 +2742,7 @@ export function bindDashboardGrid(api, group, options = {}) {
             return insideMemberGroupFrame(ev.world.x, ev.world.y) || worldInsideBoard(ev.world.x, ev.world.y);
         },
         onPointerDown(ev, hit) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
             if (gesture)
                 return; // mid-palette
             const target = ((_b = (_a = ev.source) === null || _a === void 0 ? void 0 : _a.target) !== null && _b !== void 0 ? _b : null);
@@ -2532,6 +2780,10 @@ export function bindDashboardGrid(api, group, options = {}) {
                         : slabEdgesNear(grp, ev.world.x, ev.world.y);
                     if (anyEdge(edges))
                         beginSlabResize(slabId, edges, ev);
+                    // The caption band is the section's handle: pressed and travelled,
+                    // it moves the whole section (its inner empty space only selects).
+                    else if (ownCaption)
+                        beginSlabMove(slabId, ev);
                     return;
                 }
                 // OUR OWN empty band, and we are a section of a parent board: the
@@ -2548,12 +2800,14 @@ export function bindDashboardGrid(api, group, options = {}) {
                             : slabEdgesNear(group, ev.world.x, ev.world.y);
                         if (anyEdge(edges) && parent.beginSlabResize(group.id, edges, ev))
                             forwardSlab = parent;
+                        else if (!anyEdge(edges) && captionId === group.id && ((_r = parent.beginSlabMove) === null || _r === void 0 ? void 0 : _r.call(parent, group.id, ev)))
+                            forwardSlab = parent;
                     }
                     return;
                 }
                 // The board's own empty area: a void click. Nothing to drag, and the
                 // selection clears exactly as a click outside any board would.
-                (_s = (_r = diagram).clearSelection) === null || _s === void 0 ? void 0 : _s.call(_r);
+                (_t = (_s = diagram).clearSelection) === null || _t === void 0 ? void 0 : _t.call(_s);
                 selectWidget(undefined);
                 api.render();
                 return;
@@ -2562,17 +2816,17 @@ export function bindDashboardGrid(api, group, options = {}) {
             if (!node)
                 return;
             selectWidget(node.id); // a press selects, whether or not it starts a gesture
-            if (((_t = node.state) === null || _t === void 0 ? void 0 : _t.locked) === true)
+            if (((_u = node.state) === null || _u === void 0 ? void 0 : _u.locked) === true)
                 return; // pinned: refuse; click still focuses
             if (isStatic)
                 return; // a static board: claimed and deadened, click still focuses
             // Which edges did the press take? The corner handle names its own (s+e,
             // or s+w on RTL); a bare press within EDGE_GRIP of the tile's border
             // takes that border; anywhere else is a move. A grip press is a move.
-            const onHandle = !!((_u = target === null || target === void 0 ? void 0 : target.closest) === null || _u === void 0 ? void 0 : _u.call(target, '.axdb-rs'));
+            const onHandle = !!((_v = target === null || target === void 0 ? void 0 : target.closest) === null || _v === void 0 ? void 0 : _v.call(target, '.axdb-rs'));
             const hostEl = hostOf(node.id);
-            const resizable = ((_v = node.getMetadata) === null || _v === void 0 ? void 0 : _v.call(node, 'widgetResizable')) !== false;
-            const movable = ((_w = node.getMetadata) === null || _w === void 0 ? void 0 : _w.call(node, 'widgetMovable')) !== false;
+            const resizable = ((_w = node.getMetadata) === null || _w === void 0 ? void 0 : _w.call(node, 'widgetResizable')) !== false;
+            const movable = ((_x = node.getMetadata) === null || _x === void 0 ? void 0 : _x.call(node, 'widgetMovable')) !== false;
             // `ev.screen` is ELEMENT-LOCAL px; host rects are in client px. Compare
             // like with like — the source event's clientX/Y when there is one, else
             // the container's origin plus the local offset.
@@ -2620,9 +2874,10 @@ export function bindDashboardGrid(api, group, options = {}) {
                 startSize: { width: node.size.width, height: node.size.height },
                 startPos: { x: node.position.x, y: node.position.y },
                 edges,
-                spans: { w: (_x = it === null || it === void 0 ? void 0 : it.w) !== null && _x !== void 0 ? _x : 1, h: (_y = it === null || it === void 0 ? void 0 : it.h) !== null && _y !== void 0 ? _y : 1 },
+                spans: { w: (_y = it === null || it === void 0 ? void 0 : it.w) !== null && _y !== void 0 ? _y : 1, h: (_z = it === null || it === void 0 ? void 0 : it.h) !== null && _z !== void 0 ? _z : 1 },
                 removedFromBoard: false,
                 leg: null,
+                strip: null,
                 lastWorld: null,
                 lastScreen: null,
                 hostEl: null,
@@ -2927,31 +3182,258 @@ export function bindDashboardGrid(api, group, options = {}) {
             const rect = api.container.getBoundingClientRect();
             return ((_a = api.viewport) === null || _a === void 0 ? void 0 : _a.clientToWorld) ? api.viewport.clientToWorld(cx, cy, rect) : { x: cx - rect.left, y: cy - rect.top };
         };
-        const first = toWorld(ev.clientX, ev.clientY);
         // The board holds the NEW group, not the bare page: it is adopted under the
         // group's id, sized for the page plus its strip, taking the room under the
         // pointer with its top edge at the pointer — the tab is what the pointer
-        // holds, the page hangs below it.
-        const leg = adopt({ id: plan.arrivingId }, first, plan.size, { fit: 'shrink', anchor: 'top' });
-        if (!leg)
-            return false;
+        // holds, the page hangs below it. NOT at the press: a ghost in the engine
+        // costs rows, and on a fit board every tile squeezes the moment it enters,
+        // so the ghost enters only when the pointer is over free board space, and
+        // leaves whenever it is over a strip, a group or an edge. A full board that
+        // refuses the ghost still lets the page join, reorder or split.
+        let leg = null;
+        const ensureLeg = (world) => {
+            if (!leg)
+                leg = adopt({ id: plan.arrivingId }, world, plan.size, { fit: 'shrink', anchor: 'top' });
+            return leg;
+        };
+        const naturalSpan = (() => {
+            const sp = sizeToSpan(plan.size.width, plan.size.height, frame(), geom(), rows());
+            return { w: Math.max(1, Math.min(columns, sp.w)), h: Math.max(TEAR_OUT_MIN_ROWS, sp.h) };
+        })();
+        // A DOCKED group takes at most HALF the board — VS Code's edge drop splits
+        // the area in two. A page as tall as the container it left would
+        // otherwise shove the whole dashboard out of view. Half of the board as
+        // it stood at the press, and of what the canvas shows, whichever is less.
+        const dockSpan = (() => {
+            const rows0 = rows();
+            const rect = api.container.getBoundingClientRect();
+            const rh = rowHeightFor(geom(), rows0) + gap;
+            const visible = rect.height > 0 && rh > 0 ? Math.max(1, Math.floor((rect.height + gap) / rh)) : rows0;
+            const halfRows = Math.max(TEAR_OUT_MIN_ROWS, Math.ceil(Math.min(rows0, visible) / 2));
+            const halfCols = Math.max(1, Math.ceil(columns / 2));
+            return { w: Math.min(naturalSpan.w, halfCols), h: Math.min(naturalSpan.h, halfRows) };
+        })();
         tearing = pageId;
         const doc = (_a = api.container.ownerDocument) !== null && _a !== void 0 ? _a : document;
         const chip = doc.createElement('div');
         chip.className = 'axdb-drag-chip axdb-tab-chip';
         chip.textContent = plan.label;
         doc.body.appendChild(chip);
-        // Over ANOTHER tab container the page joins it instead of taking a cell:
-        // the tile leaves the board (its displaced tiles come home), the target's
-        // frame lights up and its strip marks where the tab will go.
+        const moveChip = (cx, cy) => {
+            chip.style.left = `${cx + 6}px`;
+            chip.style.top = `${cy + 6}px`;
+        };
+        moveChip(ev.clientX, ev.clientY);
+        armGlide();
+        api.render();
         const layer = htmlLayer();
+        const area = (g) => {
+            const sz = sizeOf(g);
+            return sz.width * sz.height;
+        };
         const targets = plan.joinTargets
             .map((id) => diagram.getGroup(id))
-            .filter((g) => !!g && g.id !== fromGroupId);
-        const targetAt = (wx, wy) => { var _a; return (_a = targets.find((t) => worldInsideGroup(t, wx, wy))) !== null && _a !== void 0 ? _a : null; };
-        let over = null;
+            .filter((g) => !!g && g.id !== fromGroupId)
+            .sort((a, b) => area(a) - area(b));
+        // GEOMETRY MUST NOT MOVE WITH THE GHOST. On a fit board the rows squeeze
+        // while the ghost occupies some and relax when it leaves, so a target's
+        // frame changes with the very decision being made about it: a join makes
+        // the ghost leave, the frame grows, and the same pointer now reads as a
+        // split. The target and its frame are therefore anchored when the pointer
+        // enters it and kept until it leaves; the board frame is the one at press.
+        let anchor = null;
+        const inRect = (r, wx, wy) => wx >= r.x && wx <= r.x + r.width && wy >= r.y && wy <= r.y + r.height;
+        const targetAt = (wx, wy) => {
+            var _a;
+            if (anchor && inRect(anchor.frame, wx, wy))
+                return anchor.g;
+            const t = (_a = targets.find((x) => worldInsideGroup(x, wx, wy))) !== null && _a !== void 0 ? _a : null;
+            if (t)
+                leg === null || leg === void 0 ? void 0 : leg.leave(); // the ghost leaves first, so the frame anchored is the relaxed one
+            anchor = t ? { g: t, frame: frameOfGroup(t), stripH: plan.stripHeight(t.id) } : null;
+            return t;
+        };
+        // THE BANDS ARE ON THE SCREEN. Dockview measures its container edges on
+        // the element, and so must we: the camera moves during the drag (the
+        // board glides, the ghost adds rows a bounded scroll answers to), so a
+        // band fixed in world space at the press drifts away from the edge the
+        // user sees. The frame is mapped to client space through the live
+        // camera and clipped to the canvas, so a scrolled board's bands sit at
+        // its VISIBLE edges.
+        const ROOT_TOP = 20;
+        const ROOT_BOTTOM = 20;
+        const ROOT_SIDE = 40;
+        const visibleFrame = () => {
+            const rect = api.container.getBoundingClientRect();
+            const o = toWorld(rect.left, rect.top);
+            const u = toWorld(rect.left + 100, rect.top + 100);
+            const sx = 100 / (u.x - o.x || 100);
+            const sy = 100 / (u.y - o.y || 100);
+            const f = frame();
+            const left = rect.left + (f.x - o.x) * sx;
+            const top = rect.top + (f.y - o.y) * sy;
+            const right = left + f.width * sx;
+            const bottom = top + f.height * sy;
+            if (rect.width <= 0 || rect.height <= 0)
+                return { left, top, right, bottom }; // unlaid-out: nothing to clip to
+            return { left: Math.max(left, rect.left), top: Math.max(top, rect.top), right: Math.min(right, rect.right), bottom: Math.min(bottom, rect.bottom) };
+        };
+        const rootAt = (cx, cy) => {
+            // The bands reach a little OUTSIDE the frame too: a pointer that
+            // overshoots the board's top edge by a few pixels means "the top".
+            const v = visibleFrame();
+            if (cx < v.left - ROOT_SIDE || cx > v.right + ROOT_SIDE || cy < v.top - ROOT_TOP || cy > v.bottom + ROOT_BOTTOM)
+                return null;
+            const rows = Math.max(TEAR_OUT_MIN_ROWS, rowsWithout(plan.arrivingId));
+            const w = dockSpan.w;
+            const h = dockSpan.h;
+            if (cy - v.top <= ROOT_TOP)
+                return { kind: 'root', side: 'top', cell: { x: 0, y: 0, w: columns, h } };
+            if (cx - v.left <= ROOT_SIDE)
+                return { kind: 'root', side: 'left', cell: { x: 0, y: 0, w, h: rows } };
+            if (v.right - cx <= ROOT_SIDE)
+                return { kind: 'root', side: 'right', cell: { x: Math.max(0, columns - w), y: 0, w, h: rows } };
+            if (v.bottom - cy <= ROOT_BOTTOM)
+                return { kind: 'root', side: 'bottom', cell: { x: 0, y: rows, w: columns, h } };
+            return null;
+        };
+        const rowsWithout = (id) => {
+            let r = 0;
+            for (const it of engine.getItems())
+                if (it.id !== id)
+                    r = Math.max(r, it.y + it.h);
+            return r;
+        };
+        /** A split being previewed: the target shrunk to its half, to be restored when the pointer leaves. */
+        let split = null;
+        const halves = (target, side) => {
+            // The cell to halve is the target's own — not the half it is already
+            // shrunk to while a split is being previewed.
+            const live = engine.getItem(target.id);
+            const it = split && split.id === target.id ? split.before : live;
+            if (!it || !live)
+                return null; // a group on another board: no cell of ours to halve
+            if (side === 'left' || side === 'right') {
+                if (it.w < 2)
+                    return null;
+                const a = Math.ceil(it.w / 2);
+                const b = it.w - a;
+                return side === 'right'
+                    ? { keep: { x: it.x, y: it.y, w: a, h: it.h }, born: { x: it.x + a, y: it.y, w: b, h: it.h } }
+                    : { keep: { x: it.x + b, y: it.y, w: a, h: it.h }, born: { x: it.x, y: it.y, w: b, h: it.h } };
+            }
+            if (it.h < 2 * TEAR_OUT_MIN_ROWS)
+                return null;
+            const a = Math.ceil(it.h / 2);
+            const b = it.h - a;
+            return side === 'bottom'
+                ? { keep: { x: it.x, y: it.y, w: it.w, h: a }, born: { x: it.x, y: it.y + a, w: it.w, h: b } }
+                : { keep: { x: it.x, y: it.y + b, w: it.w, h: a }, born: { x: it.x, y: it.y, w: it.w, h: b } };
+        };
+        const zoneAt = (cx, cy, world) => {
+            const target = targetAt(world.x, world.y);
+            const home = !target && worldInsideGroup(from, world.x, world.y);
+            // A strip is the most precise target there is: anyone's wins outright.
+            if (target) {
+                const idx = plan.stripIndex(target.id, cx, cy);
+                if (idx !== null)
+                    return { kind: 'strip', target, index: idx };
+            }
+            else if (home) {
+                const idx = plan.stripIndex(fromGroupId, cx, cy);
+                if (idx !== null)
+                    return { kind: 'reorder', index: idx };
+            }
+            // The board's own edges beat whatever sits against them — Dockview's
+            // container edges over its groups — so a group at the top of the board
+            // still leaves the top band to the board.
+            const root = rootAt(cx, cy);
+            if (root)
+                return root;
+            if (target) {
+                const f = anchor && anchor.g === target ? anchor.frame : frameOfGroup(target);
+                const stripH = anchor && anchor.g === target ? anchor.stripH : plan.stripHeight(target.id);
+                const bodyH = Math.max(1, f.height - stripH);
+                const rx = Math.min(1, Math.max(0, (world.x - f.x) / Math.max(1, f.width)));
+                const ry = Math.min(1, Math.max(0, (world.y - f.y - stripH) / bodyH));
+                if (rx >= 1 / 3 && rx <= 2 / 3 && ry >= 1 / 3 && ry <= 2 / 3)
+                    return { kind: 'join', target };
+                const d = [['left', rx], ['right', 1 - rx], ['top', ry], ['bottom', 1 - ry]];
+                d.sort((p, q) => p[1] - q[1]);
+                const h = halves(target, d[0][0]);
+                return h ? Object.assign({ kind: 'split', target, side: d[0][0] }, h) : { kind: 'join', target };
+            }
+            if (home)
+                return { kind: 'home' };
+            return { kind: 'board' };
+        };
+        const zoneKey = (z) => JSON.stringify(z, (k, v) => (k === 'target' ? v.id : v));
+        // DOCKING PUSHES SECTIONS. A section is a locked tile so that a widget
+        // never pushes it; a group docked against the board's edge is the one
+        // gesture that must — everything below the top band moves down. For the
+        // preview every member group is unlocked; they are relocked when the
+        // pointer leaves the band, and their moved cells are committed with the
+        // dock.
+        let unlockedGroups = [];
+        const unlockGroups = () => {
+            if (unlockedGroups.length > 0)
+                return;
+            for (const it of engine.getItems()) {
+                if (it.id !== plan.arrivingId && it.locked && isGroupMember(it.id)) {
+                    it.locked = false;
+                    unlockedGroups.push(it.id);
+                }
+            }
+        };
+        const relockGroups = () => {
+            for (const id of unlockedGroups) {
+                const it = engine.getItem(id);
+                if (it)
+                    it.locked = true;
+            }
+            unlockedGroups = [];
+        };
+        const groupCommands = (fin, except) => fin.groups.filter((g) => g.id !== except).map((g) => new SetGroupCellCommand(g.id, g.cellBefore, g.cellAfter, g.frameBefore, g.frameAfter));
+        // A TOP DOCK INSERTS ROWS. The engine's push cascade resolves the band's
+        // collisions one tile at a time and scrambles what stood beneath it (the
+        // demo's KPI row came apart, two of its tiles under the chart). VS Code
+        // shoves the whole area down intact, so after the ghost takes the band
+        // every tile that stood at or below it is put back at its own column,
+        // exactly the band's height lower — a translation of a layout without
+        // overlaps has none — and comes back the same way when the pointer leaves.
+        // The layout translated is the one from BEFORE the ghost entered (the
+        // leg's baseline), not the engine's mid-gesture state: the adoption
+        // itself pushes tiles about, and a snapshot taken after it would carry
+        // that cascade into the insert.
+        let inserted = null;
+        const insertRows = (cell, l) => {
+            if (cell.w < columns)
+                return; // a side dock has no whole rows to insert
+            inserted = l.baseline();
+            for (const [id, c] of inserted) {
+                const it = engine.getItem(id);
+                if (!it)
+                    continue;
+                it.x = c.x;
+                it.y = c.y >= cell.y ? c.y + cell.h : c.y;
+            }
+        };
+        const undoInsertRows = () => {
+            if (!inserted)
+                return;
+            leg === null || leg === void 0 ? void 0 : leg.leave(); // the ghost frees its rows first
+            for (const [id, c] of inserted) {
+                const it = engine.getItem(id);
+                if (it) {
+                    it.x = c.x;
+                    it.y = c.y;
+                }
+            }
+            inserted = null;
+            project();
+        };
         let joinEl = null;
-        const showJoin = (g) => {
+        const showOverlay = (r) => {
             if (!layer)
                 return;
             if (!joinEl) {
@@ -2959,37 +3441,115 @@ export function bindDashboardGrid(api, group, options = {}) {
                 joinEl.className = 'axdb-join';
                 layer.prepend(joinEl);
             }
-            const sz = sizeOf(g);
-            joinEl.style.left = `${g.position.x}px`;
-            joinEl.style.top = `${g.position.y}px`;
-            joinEl.style.width = `${sz.width}px`;
-            joinEl.style.height = `${sz.height}px`;
+            joinEl.style.left = `${r.x}px`;
+            joinEl.style.top = `${r.y}px`;
+            joinEl.style.width = `${r.width}px`;
+            joinEl.style.height = `${r.height}px`;
         };
-        const hideJoin = () => {
+        const hideOverlay = () => {
             joinEl === null || joinEl === void 0 ? void 0 : joinEl.remove();
             joinEl = null;
-            plan.markDrop(null, null);
         };
-        const setOver = (g, world) => {
-            if (g === over)
+        const undoSplitPreview = () => {
+            if (!split)
                 return;
-            over = g;
-            if (g) {
-                leg.leave();
-                showJoin(g);
-            }
-            else {
-                hideJoin();
-                leg.enter(world);
+            const it = engine.getItem(split.id);
+            leg === null || leg === void 0 ? void 0 : leg.leave(); // the born half must be free before the target grows back into it
+            if (it) {
+                if (it.x !== split.before.x || it.y !== split.before.y)
+                    engine.moveCheck(split.id, split.before.x, split.before.y, { gate: false });
+                if (it.w !== split.before.w || it.h !== split.before.h)
+                    engine.resizeCheck(split.id, split.before.w, split.before.h);
+                it.locked = true;
             }
+            split = null;
+            project();
         };
-        const moveChip = (cx, cy) => {
-            chip.style.left = `${cx + 6}px`;
-            chip.style.top = `${cy + 6}px`;
+        const previewSplit = (z, world) => {
+            const it = engine.getItem(z.target.id);
+            const l = ensureLeg(world);
+            if (!it || !l)
+                return false;
+            split = { id: z.target.id, before: { x: it.x, y: it.y, w: it.w, h: it.h }, frameBefore: frameOfGroup(z.target), keep: z.keep };
+            it.locked = false; // its own gesture for the moment: it may shrink and shift
+            if (it.w !== z.keep.w || it.h !== z.keep.h)
+                engine.resizeCheck(z.target.id, z.keep.w, z.keep.h);
+            const now = engine.getItem(z.target.id);
+            if (now && (now.x !== z.keep.x || now.y !== z.keep.y))
+                engine.moveCheck(z.target.id, z.keep.x, z.keep.y, { gate: false });
+            const ok = l.place(z.born);
+            project();
+            placeholder === null || placeholder === void 0 ? void 0 : placeholder.remove(); // the accent overlay says which half; the grey placeholder under it is noise
+            placeholder = null;
+            return ok;
+        };
+        let zone = { kind: 'board' };
+        let key = zoneKey(zone);
+        const applyZone = (z, world) => {
+            var _a;
+            const k = zoneKey(z);
+            const same = k === key;
+            key = k;
+            zone = z;
+            if (same) {
+                if (z.kind === 'board')
+                    (_a = ensureLeg(world)) === null || _a === void 0 ? void 0 : _a.move(world);
+                return;
+            }
+            undoSplitPreview();
+            undoInsertRows();
+            if (z.kind !== 'root')
+                relockGroups();
+            plan.markDrop(null, null);
+            hideOverlay();
+            switch (z.kind) {
+                case 'strip':
+                    leg === null || leg === void 0 ? void 0 : leg.leave();
+                    showOverlay(frameOfGroup(z.target));
+                    plan.markDrop(z.target.id, z.index);
+                    break;
+                case 'join':
+                    leg === null || leg === void 0 ? void 0 : leg.leave();
+                    showOverlay(frameOfGroup(z.target));
+                    break;
+                case 'split': {
+                    if (!previewSplit(z, world)) {
+                        zone = { kind: 'join', target: z.target };
+                        key = zoneKey(zone);
+                        leg === null || leg === void 0 ? void 0 : leg.leave();
+                        showOverlay(frameOfGroup(z.target));
+                        break;
+                    }
+                    showOverlay(cellToRect(z.born, frame(), geom(), rows()));
+                    break;
+                }
+                case 'root': {
+                    const l = ensureLeg(world);
+                    if (l) {
+                        unlockGroups();
+                        l.place(z.cell);
+                        insertRows(z.cell, l);
+                        project();
+                        placeholder === null || placeholder === void 0 ? void 0 : placeholder.remove();
+                        placeholder = null;
+                        showOverlay(cellToRect(z.cell, frame(), geom(), rows()));
+                    }
+                    break;
+                }
+                case 'reorder':
+                    leg === null || leg === void 0 ? void 0 : leg.leave();
+                    plan.markDrop(fromGroupId, z.index);
+                    break;
+                case 'home':
+                    leg === null || leg === void 0 ? void 0 : leg.leave();
+                    break;
+                case 'board': {
+                    const l = ensureLeg(world);
+                    l === null || l === void 0 ? void 0 : l.enter(world);
+                    break;
+                }
+            }
         };
-        moveChip(ev.clientX, ev.clientY);
-        armGlide();
-        api.render();
         let last = { x: ev.clientX, y: ev.clientY };
         const detach = () => {
             window.removeEventListener('pointermove', onMove, true);
@@ -3003,68 +3563,98 @@ export function bindDashboardGrid(api, group, options = {}) {
             last = { x: e.clientX, y: e.clientY };
             moveChip(e.clientX, e.clientY);
             const world = toWorld(e.clientX, e.clientY);
-            const home = worldInsideGroup(from, world.x, world.y);
-            const target = home ? null : targetAt(world.x, world.y);
-            setOver(target, world);
-            // Over its own container it goes home: a tab dragged around its own
-            // strip must not tear itself out.
-            chip.classList.toggle('axdb-out', home || (!target && !worldInsideBoardGrace(world.x, world.y)));
-            if (target)
-                plan.markDrop(target.id, plan.dropIndex(target.id, e.clientX, e.clientY));
-            else if (!home)
-                leg.move(world);
+            const z = zoneAt(e.clientX, e.clientY, world);
+            applyZone(z, world);
+            // Dimmed = a release here does nothing: home, off the board, or a board
+            // that refused the ghost (bounded and full).
+            chip.classList.toggle('axdb-out', zone.kind === 'home' || (zone.kind === 'root' && !leg) || (zone.kind === 'board' && (!leg || !worldInsideBoardGrace(world.x, world.y))));
             api.render();
         };
+        const done = (changed, kind) => {
+            var _a;
+            disarmGlideSoon();
+            enforceBoardHeight();
+            persistLayouts();
+            api.renderNow();
+            (_a = options.onGesture) === null || _a === void 0 ? void 0 : _a.call(options, { type: kind, kind: 'move', nodeId: pageId, changed });
+        };
         const finish = (commit) => {
-            var _a, _b, _c;
+            var _a, _b;
             detach();
             chip.remove();
-            hideJoin();
+            hideOverlay();
+            plan.markDrop(null, null);
             tearing = null;
             if (disposed)
                 return;
             const world = toWorld(last.x, last.y);
-            const home = worldInsideGroup(from, world.x, world.y);
-            const target = commit && !home ? targetAt(world.x, world.y) : null;
-            if (target) {
+            const z = commit ? zoneAt(last.x, last.y, world) : { kind: 'home' };
+            if (z.kind !== 'root')
+                undoInsertRows();
+            if (!commit || z.kind === 'home' || (z.kind === 'root' && !ensureLeg(world)) || (z.kind === 'board' && (!ensureLeg(world) || !worldInsideBoardGrace(world.x, world.y)))) {
+                undoSplitPreview();
+                leg === null || leg === void 0 ? void 0 : leg.abort();
+                relockGroups();
+                done(false, 'cancel');
+                return;
+            }
+            if (z.kind === 'reorder') {
+                undoSplitPreview();
+                leg === null || leg === void 0 ? void 0 : leg.abort();
+                const cmds = plan.reorder(z.index);
+                const changed = cmds.length > 0 ? execute('Reorder tab', cmds) : false;
+                done(changed, changed ? 'commit' : 'cancel');
+                return;
+            }
+            if (z.kind === 'strip' || z.kind === 'join') {
                 // JOIN: no cell on this board — the leg is abandoned (its displaced
                 // tiles are already home) and the page becomes the target's tab.
-                const index = plan.dropIndex(target.id, last.x, last.y);
-                leg.abort();
-                const planned = plan.join(target.id, index, group.id);
-                const collapse = planned.collapse.length > 0 ? [...planRemovalOf(fromGroupId), ...planned.collapse] : [];
-                const changed = execute('Move tab', [...planned.move, ...collapse]);
-                disarmGlideSoon();
-                enforceBoardHeight();
-                persistLayouts();
-                api.renderNow();
-                (_a = options.onGesture) === null || _a === void 0 ? void 0 : _a.call(options, { type: 'commit', kind: 'move', nodeId: pageId, changed });
+                undoSplitPreview();
+                const index = z.kind === 'strip' ? z.index : plan.dropIndex(z.target.id, last.x, last.y);
+                leg === null || leg === void 0 ? void 0 : leg.abort();
+                const planned = plan.join(z.target.id, index, group.id);
+                done(execute('Move tab', [...planned.move, ...planned.collapse]), 'commit');
                 return;
             }
-            if (!commit || home || !worldInsideBoardGrace(world.x, world.y)) {
-                leg.abort();
-                disarmGlideSoon();
-                api.renderNow();
-                (_b = options.onGesture) === null || _b === void 0 ? void 0 : _b.call(options, { type: 'cancel', kind: 'move', nodeId: pageId, changed: false });
+            if (z.kind === 'split') {
+                // SPLIT: the target keeps one half of its cell, the page's new group the
+                // other. The preview already holds both in the engine; commit them.
+                if (!split || split.id !== z.target.id || zoneKey(zone) !== zoneKey(z))
+                    applyZone(z, world);
+                const fin = (_a = leg === null || leg === void 0 ? void 0 : leg.finalize()) !== null && _a !== void 0 ? _a : null;
+                const it = engine.getItem(z.target.id);
+                const before = split;
+                if (it)
+                    it.locked = true;
+                split = null;
+                if (!fin || !before || !it) {
+                    leg === null || leg === void 0 ? void 0 : leg.abort();
+                    done(false, 'cancel');
+                    return;
+                }
+                const keep = { x: it.x, y: it.y, w: it.w, h: it.h };
+                const planned = plan.commands(fin.cell, fin.rect, group.id);
+                const changed = execute('Split group', [
+                    ...fin.commands,
+                    ...groupCommands(fin, z.target.id),
+                    new SetGroupCellCommand(z.target.id, before.before, keep, before.frameBefore, cellToRect(keep, frame(), geom(), rows())),
+                    ...planned.move,
+                    ...planned.collapse,
+                ]);
+                done(changed, 'commit');
                 return;
             }
-            const fin = leg.finalize();
+            // ROOT DOCK or a free cell on the board: the leg sits where it will land.
+            if (zoneKey(zone) !== zoneKey(z))
+                applyZone(z, world);
+            const fin = (_b = leg === null || leg === void 0 ? void 0 : leg.finalize()) !== null && _b !== void 0 ? _b : null;
+            relockGroups();
             if (!fin) {
-                disarmGlideSoon();
-                api.renderNow();
+                done(false, 'cancel');
                 return;
             }
             const planned = plan.commands(fin.cell, fin.rect, group.id);
-            // The container the page left may have been holding its last page: it
-            // goes too, and the tiles around its slab settle the way a removal
-            // settles them (VS Code closes a group whose last editor leaves).
-            const collapse = planned.collapse.length > 0 ? [...planRemovalOf(fromGroupId), ...planned.collapse] : [];
-            const changed = execute('Move tab out', [...fin.commands, ...planned.move, ...collapse]);
-            disarmGlideSoon();
-            enforceBoardHeight();
-            persistLayouts();
-            api.renderNow();
-            (_c = options.onGesture) === null || _c === void 0 ? void 0 : _c.call(options, { type: 'commit', kind: 'move', nodeId: pageId, changed });
+            done(execute(z.kind === 'root' ? 'Dock tab' : 'Move tab out', [...fin.commands, ...groupCommands(fin), ...planned.move, ...planned.collapse]), 'commit');
         };
         const onUp = () => finish(true);
         const onCancel = () => finish(false);
@@ -3107,6 +3697,7 @@ export function bindDashboardGrid(api, group, options = {}) {
             spans: { w: Math.max(1, spec.w), h: Math.max(1, spec.h) },
             removedFromBoard: true,
             leg: null,
+            strip: null,
             lastWorld: null,
             lastScreen: null,
             hostEl: null,
@@ -3220,7 +3811,15 @@ export function bindDashboardGrid(api, group, options = {}) {
             return false;
         engine.beginGesture();
         const snap = snapshotAll();
-        if (!op()) {
+        // A section is a LOCKED tile; for ITS OWN move it is the one moving.
+        const self = engine.getItem(id);
+        const wasLocked = !!(self === null || self === void 0 ? void 0 : self.locked);
+        if (self && isGroupMember(id))
+            self.locked = false;
+        const ok = op();
+        if (self && isGroupMember(id))
+            self.locked = wasLocked;
+        if (!ok) {
             engine.endGesture();
             return false;
         }