@grafloria/element 0.4.50 → 0.4.52

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@grafloria/element",
-  "version": "0.4.50",
+  "version": "0.4.52",
   "type": "module",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
   "peerDependencies": {
-    "@grafloria/engine": "^0.3.8",
+    "@grafloria/engine": "^0.3.9",
     "@grafloria/renderer": "^0.4.0"
   },
   "dependencies": {

package/src/lib/dashboard-kit/dashboard.d.ts

@@ -227,7 +227,7 @@ export interface DashboardOptions {
      * so a designer/viewer pair is one flag apart. Live: `handle.setStatic()`.
      */
     static?: boolean;
-    /** The deepest board a drop may enter (a view is 0; default 2). See the grid binder's `nesting`. */
+    /** The deepest board a drop may enter (a view is 0; unbounded by default). See the grid binder's `nesting`. */
     nesting?: number;
     /**
      * DRAG HANDLE — DevExpress drags an item by its caption. `true`: the caption

package/src/lib/dashboard-kit/grid-binder.d.ts

@@ -243,7 +243,7 @@ export interface DashboardGridOptions {
      * counting a view as 0 — a widget into a section is 1, into a section
      * inside a tab page is 2. Deeper containers are opaque to a drag: the
      * pointer over them means a cell on their parent board (or beside them).
-     * Default 2, the depth the gates exercise.
+     * Unbounded by default.
      */
     nesting?: number;
     /**
@@ -670,7 +670,7 @@ interface AdoptedLeg {
         y: number;
         w: number;
         h: number;
-    }): boolean;
+    }, pushSolid?: boolean): boolean;
     /** Every other tile's cell before the ghost entered — the layout a row insert translates. */
     baseline(): Map<string, CellRect>;
     /** Where the tile sits right now, or null while it is off the board. */

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

@@ -56,7 +56,7 @@ import { buildCommitCommands, cellFromGridItem, cellToRect, columnUnitFor, gridI
 import { ensureDashboardKitStyles } from './styles.js';
 import { captionOfGroup, captionPainted, captionPassThrough, captionKey, paintCaptionBand, sectionCaptionReserve, sizeCaptionBand } from './caption.js';
 import { TAB_STRIP_HEIGHT } from './tabs.js';
-import { BESIDE_BAND, resolve as resolveZone } from './zones.js';
+import { BESIDE_BAND, resolve as resolveZone, resolveTabZone } from './zones.js';
 /** The class of the painted grip element (a child of the node host). */
 export const GRIP_CLASS = 'axdb-grip';
 /** The container class that turns the caption strip's grip dots on. */
@@ -367,8 +367,8 @@ export function bindDashboardGrid(api, group, options = {}) {
     const fluid = options.fluid === true;
     const overflow = (_h = options.overflow) !== null && _h !== void 0 ? _h : 'bounded';
     let isStatic = options.static === true;
-    /** The deepest board a drop may enter — a root is 0; two levels are what the gates exercise (tile first, step 2). */
-    const nesting = (_j = options.nesting) !== null && _j !== void 0 ? _j : 2;
+    /** The deepest board a drop may enter — a root is 0. Unbounded unless asked for: three-level drops are in the specs today (tile first, step 2). */
+    const nesting = (_j = options.nesting) !== null && _j !== void 0 ? _j : Number.POSITIVE_INFINITY;
     let dragHandle = normalizeDragHandle(options.dragHandle);
     let dragSel = dragHandleSelector(dragHandle);
     api.container.classList.toggle(DRAG_HANDLE_CLASS, dragHandle === true);
@@ -624,10 +624,14 @@ export function bindDashboardGrid(api, group, options = {}) {
         const cell = grp
             ? cellFromGridItem((_g = grp.getMetadata) === null || _g === void 0 ? void 0 : _g.call(grp, 'gridItem'))
             : null;
-        // Member groups are LOCKED slabs (see the module doc).
+        // A member group is a SOLID tile (tile first, step 3): a widget carried
+        // over it slides aside and it never packs — the board under the hand
+        // holds still, so its zones (into, a tab, beside) stay reachable — and
+        // it is moved by INTENT: placed beside, pushed by a moved section, a
+        // dock or a widget it refused, moved by its own gesture.
         if (cell)
-            return Object.assign(Object.assign({ id }, cell), { locked: true });
-        return { id, x: 0, y: 0, w: columns, h: 1, locked: true, autoPosition: true };
+            return Object.assign(Object.assign({ id }, cell), { solid: true });
+        return { id, x: 0, y: 0, w: columns, h: 1, solid: true, autoPosition: true };
     };
     /** Persist adopted cells so save/undo round-trips them. */
     const persistAdoptedCell = (id, item) => {
@@ -1288,7 +1292,13 @@ export function bindDashboardGrid(api, group, options = {}) {
      * carried along the top of a tall panel to its far right means "after it",
      * not "above it". The shift is undone if the pointer leaves the band.
      */
-    /** The container a BESIDE drop unlocked (and maybe shifted): relocked, and put back if asked, when the zone or the gesture ends. */
+    /**
+     * The beside the hand holds (tile first, step 3): the container's cell and
+     * frame AT REST (the resolve reads the held container at rest), the cell
+     * the widget took, and the row it took it at. The shift itself is the
+     * engine's `placeBeside`; the sections it pushed remember their cells and
+     * come back by themselves when the widget leaves (S2).
+     */
     let beside = null;
     const endBeside = (restore) => {
         if (!beside)
@@ -1296,28 +1306,22 @@ export function bindDashboardGrid(api, group, options = {}) {
         const it = engine.getItem(beside.id);
         let moved = false;
         if (it && restore && (it.x !== beside.from.x || it.y !== beside.from.y))
-            moved = engine.moveCheck(beside.id, beside.from.x, beside.from.y, { gate: false }).changed || moved;
-        if (restore) {
-            // The sections the shift pushed come back with it.
-            for (const [oid, c] of beside.others) {
-                const o = engine.getItem(oid);
-                if (o && (o.x !== c.x || o.y !== c.y))
-                    moved = engine.moveCheck(oid, c.x, c.y, { gate: false }).changed || moved;
-            }
-        }
-        if (it)
-            it.locked = true;
-        relockOthersForSlab();
+            moved = engine.moveCheck(beside.id, beside.from.x, beside.from.y, { gate: false }).changed;
         beside = null;
         // The frames the zone test reads are the MODEL's: a restore that moved
         // the container without projecting left its frame where the push had
-        // put it, so the next test read the pointer as OUTSIDE it (the user's
-        // 3440-px corner on 0.4.48: along the top band the panel was pushed
-        // down, and the corner never turned into "right").
+        // put it (the user's 3440-px corner on 0.4.48).
         if (moved)
             project();
     };
-    const applyBeside = (g, z) => {
+    /** The row of this board's grid under a world y — where a beside lands (D3: the pointer's row, not the container's top). */
+    const rowOfPoint = (y) => {
+        const r0 = cellToRect({ x: 0, y: 0, w: 1, h: 1 }, frame(), geom(), rows());
+        const r1 = cellToRect({ x: 0, y: 1, w: 1, h: 1 }, frame(), geom(), rows());
+        const pitch = Math.max(1, r1.y - r0.y);
+        return Math.max(0, Math.floor((y - r0.y) / pitch));
+    };
+    const applyBeside = (g, z, row) => {
         var _a;
         const tc = engine.getItem(z.id);
         if (!tc)
@@ -1326,71 +1330,26 @@ export function bindDashboardGrid(api, group, options = {}) {
             g.leg.adopted.abort();
             g.leg = null;
         }
-        const w = g.spans.w;
-        const h = g.spans.h;
         if (g.removedFromBoard) {
             g.removedFromBoard = false;
             (_a = hostOf(g.id)) === null || _a === void 0 ? void 0 : _a.classList.remove('axdb-out');
-            engine.add({ id: g.id, x: 0, y: engine.rows(), w, h });
+            engine.add({ id: g.id, x: 0, y: engine.rows(), w: g.spans.w, h: g.spans.h });
         }
         if (beside && (beside.id !== z.id || beside.side !== z.side))
-            endBeside(true); // another container, or another side of it: start over from the rest layout
-        const from = beside ? beside.from : { x: tc.x, y: tc.y };
-        let cell;
-        let shiftTo = null;
-        switch (z.side) {
-            case 'right':
-                cell = { x: from.x + tc.w, y: from.y };
-                if (cell.x + w > columns) {
-                    shiftTo = { x: columns - w - tc.w, y: from.y };
-                    cell = { x: columns - w, y: from.y };
-                }
-                break;
-            case 'left':
-                cell = { x: from.x - w, y: from.y };
-                if (cell.x < 0) {
-                    shiftTo = { x: w, y: from.y };
-                    cell = { x: 0, y: from.y };
-                }
-                break;
-            case 'top':
-                cell = { x: Math.max(0, Math.min(from.x, columns - w)), y: from.y }; // the ghost takes the container's rows; the container is pushed down under it
-                break;
-            default:
-                cell = { x: Math.max(0, Math.min(from.x, columns - w)), y: from.y + tc.h };
-        }
-        if (shiftTo && shiftTo.x < 0)
-            shiftTo = null; // no room even shifted: the widget goes where it can
+            endBeside(true); // another container, or another side of it: from the rest layout
         if (!beside) {
-            // The other sections give way to the shift the way they give way to a
-            // moved group (0.4.44): on the demo the Operations section spans the
-            // row under the panel and a locked tile refused the shift outright.
-            // Their cells are kept so they come back if the pointer leaves.
-            const others = new Map();
-            for (const o of engine.getItems())
-                if (o.id !== z.id && o.id !== g.id && isGroupMember(o.id))
-                    others.set(o.id, { x: o.x, y: o.y });
             const grp0 = diagram.getGroup(z.id);
-            beside = { id: z.id, side: z.side, from, frame0: grp0 ? frameOfGroup(grp0) : cellToRect({ x: from.x, y: from.y, w: tc.w, h: tc.h }, frame(), geom(), rows()), vacated: cell, others };
-            unlockOthersForSlab(z.id);
+            beside = { id: z.id, side: z.side, from: { x: tc.x, y: tc.y }, frame0: grp0 ? frameOfGroup(grp0) : cellToRect({ x: tc.x, y: tc.y, w: tc.w, h: tc.h }, frame(), geom(), rows()), vacated: { x: tc.x, y: tc.y }, row };
         }
-        tc.locked = false; // for the gesture: it shifts, or the ghost pushes it
-        // The ghost steps off the board while the container shifts: the engine
-        // will not push the dragged tile, so a chart as wide as the panel had its
-        // own cell as the panel's target and the shift was refused (lab L94).
-        // Then it takes the cell the shift vacated.
-        if (shiftTo && (tc.x !== shiftTo.x || tc.y !== shiftTo.y)) {
-            if (engine.getItem(g.id))
-                engine.remove(g.id);
-            engine.moveCheck(z.id, shiftTo.x, shiftTo.y, { gate: false });
+        const r = engine.placeBeside(g.id, z.id, z.side, row);
+        const at = engine.getItem(g.id);
+        if (r.changed && at) {
+            beside.vacated = { x: at.x, y: at.y };
+            beside.row = row;
         }
-        beside.vacated = cell;
-        if (!engine.getItem(g.id))
-            engine.add({ id: g.id, x: 0, y: engine.rows(), w, h });
-        if (!engine.moveCheck(g.id, cell.x, cell.y, { gate: false }).changed) {
-            const at = engine.getItem(g.id);
-            if (!at || at.x !== cell.x || at.y !== cell.y)
-                placeNear(g.id, cell.x, cell.y, w);
+        else if (at) {
+            // Refused (a bound): the widget goes where it can, as any refused cell does.
+            placeNear(g.id, at.x, at.y, g.spans.w);
         }
         project();
     };
@@ -1610,13 +1569,6 @@ export function bindDashboardGrid(api, group, options = {}) {
             },
             move: false,
         };
-        // A TOP or LEFT edge moves the slab's origin, and the engine refuses to
-        // move a locked tile: the move never landed, only the resize did, and a
-        // section pulled up by its caption grew DOWNWARD a row per pointer step
-        // — 18 rows for a 2-row pull (identification round, F16). Unlocked for
-        // its own gesture, as a move is; relocked on release.
-        if (edges.n || edges.w)
-            it.locked = false;
         capturePointer(slabGesture.pointerId);
         api.container.style.cursor = cursorFor(edges);
     };
@@ -1633,24 +1585,6 @@ export function bindDashboardGrid(api, group, options = {}) {
      * pushes it; a group's children ride along: the frame moves, the nested
      * board re-projects. The others relock on release.
      */
-    let slabUnlocked = [];
-    const unlockOthersForSlab = (id) => {
-        slabUnlocked = [];
-        for (const o of engine.getItems()) {
-            if (o.id !== id && o.locked && isGroupMember(o.id)) {
-                o.locked = false;
-                slabUnlocked.push(o.id);
-            }
-        }
-    };
-    const relockOthersForSlab = () => {
-        for (const oid of slabUnlocked) {
-            const o = engine.getItem(oid);
-            if (o)
-                o.locked = true;
-        }
-        slabUnlocked = [];
-    };
     const beginSlabMove = (id, ev) => {
         const grp = diagram.getGroup(id);
         const it = engine.getItem(id);
@@ -1658,8 +1592,6 @@ export function bindDashboardGrid(api, group, options = {}) {
             return;
         engine.beginGesture();
         const snap = snapshotAll();
-        it.locked = false;
-        unlockOthersForSlab(id);
         slabGesture = {
             id,
             edges: NO_EDGES,
@@ -1676,11 +1608,6 @@ export function bindDashboardGrid(api, group, options = {}) {
         capturePointer(slabGesture.pointerId);
         api.container.style.cursor = 'grabbing';
     };
-    const relockSlab = (id) => {
-        const it = engine.getItem(id);
-        if (it)
-            it.locked = true;
-    };
     /** The cell a slab move asked for and could not have — painted so the refusal is visible; null clears it. */
     let refusal = null;
     const showRefusal = (cell, w, h) => {
@@ -1734,7 +1661,7 @@ export function bindDashboardGrid(api, group, options = {}) {
                 // Along its ROW only: a section dragged LEFT that wandered DOWN its
                 // column (the row search) read as the wrong tile moving.
                 const was = { x: it.x, y: it.y };
-                const moved = engine.moveCheck(g.id, cell.x, cell.y, { gate: false }).changed || placeOnRow(g.id, cell.x, cell.y, it.w);
+                const moved = engine.moveCheck(g.id, cell.x, cell.y, { gate: false, pushSolid: true }).changed || placeOnRow(g.id, cell.x, cell.y, it.w, true); // a moved section pushes the sections in its way (0.4.44)
                 if (moved) {
                     project();
                     setCarried(g.id, true); // chrome repainted by the projection is carried too
@@ -1781,7 +1708,7 @@ export function bindDashboardGrid(api, group, options = {}) {
         }
         let changed = false;
         if (x !== it.x || y !== it.y)
-            changed = engine.moveCheck(g.id, x, y, { gate: false }).changed || changed;
+            changed = engine.moveCheck(g.id, x, y, { gate: false, pushSolid: true }).changed || changed;
         if (w !== it.w || h !== it.h)
             changed = engine.resizeCheck(g.id, w, h).changed || changed;
         if (changed)
@@ -1796,8 +1723,6 @@ export function bindDashboardGrid(api, group, options = {}) {
         showRefusal(null, 0, 0);
         releasePointer(g.pointerId);
         api.container.style.cursor = '';
-        relockSlab(g.id);
-        relockOthersForSlab();
         if (g.move && g.started)
             setCarried(g.id, false); // exempt through the drop write, then the glides resume
         if (!g.started) {
@@ -1833,8 +1758,6 @@ export function bindDashboardGrid(api, group, options = {}) {
         slabGesture = null;
         releasePointer(g.pointerId);
         api.container.style.cursor = '';
-        relockSlab(g.id);
-        relockOthersForSlab();
         if (g.move && g.started)
             setCarried(g.id, false);
         if (g.started)
@@ -1953,7 +1876,7 @@ 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, _e;
+        var _a, _b, _c;
         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;
@@ -1978,21 +1901,10 @@ export function bindDashboardGrid(api, group, options = {}) {
         }
         endBeside(true);
         if (g.started) {
-            if (g.removedFromBoard || g.kind === 'palette') {
-                // The engine cannot resurrect a removed item — rebuild from the
-                // gesture-start snapshot (cells are pure data; the constructor
-                // honours legal layouts verbatim).
-                engine.endGesture();
-                const items = [];
-                for (const [id, c] of g.startCells) {
-                    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);
-            }
-            else {
-                engine.cancelGesture();
-            }
+            // The engine's gesture snapshot restores cells, sizes AND membership
+            // (engine 0.3.8): a ghost removed mid-gesture comes back at its start
+            // cell, a palette tile added mid-gesture is gone.
+            engine.cancelGesture();
             if (designRows !== undefined) {
                 maxRows = liveBound(engine.getItems());
                 engine.maxRows = maxRows;
@@ -2033,7 +1945,7 @@ export function bindDashboardGrid(api, group, options = {}) {
         enforceBoardHeight();
         api.renderNow();
         if (notify) {
-            (_e = options.onGesture) === null || _e === void 0 ? void 0 : _e.call(options, { type: 'cancel', kind: g.kind, nodeId: g.id, changed: false });
+            (_c = options.onGesture) === null || _c === void 0 ? void 0 : _c.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. */
@@ -2048,7 +1960,7 @@ export function bindDashboardGrid(api, group, options = {}) {
         };
     };
     const onToolMove = (ev) => {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         const g = gesture;
         if (!g || g.kind === 'palette')
             return;
@@ -2103,8 +2015,9 @@ export function bindDashboardGrid(api, group, options = {}) {
             // (A container on another board still resolves as a plain cell there
             // until the gesture scope spans boards — step 3.)
             if (z.kind === 'beside' && !isStatic && z.board.ref === selfPeer) {
-                if (!z.kept)
-                    applyBeside(g, { id: z.containerId, side: z.side });
+                const row = rowOfPoint(ev.world.y);
+                if (!z.kept || !beside || beside.row !== row)
+                    applyBeside(g, { id: z.containerId, side: z.side }, row);
                 syncPlaceholder();
                 return;
             }
@@ -2115,7 +2028,13 @@ export function bindDashboardGrid(api, group, options = {}) {
             const onSelf = z.kind !== 'off' && z.kind !== 'strip' && z.board.ref === selfPeer;
             const inside = onSelf || (z.kind === 'off' && worldInsideBoardGrace(ev.world.x, ev.world.y));
             const peer = !onSelf && z.kind !== 'off' && z.kind !== 'strip' ? z.board.ref : null;
-            if (peer) {
+            if (peer && g.refusedPeer === peer && parentPeerOf(api.container, peer.group.id) === selfPeer) {
+                // -- REFUSED, PUSHED (D2): a section of this board that cannot take
+                // the widget is pushed by it instead — the widget takes the cell
+                // under the hand on THIS board, and means it.
+                placeOnSelf(g, desired, true);
+            }
+            else if (peer) {
                 // -- HANDOFF: the pointer is over another board -------------------
                 if (g.leg && g.leg.peer === peer) {
                     g.leg.adopted.move(ev.world);
@@ -2135,38 +2054,31 @@ export function bindDashboardGrid(api, group, options = {}) {
                         height: g.node.size.height,
                     });
                     if (adopted) {
+                        g.refusedPeer = null;
                         (_c = hostOf(g.id)) === null || _c === void 0 ? void 0 : _c.classList.remove('axdb-out');
                         g.leg = { peer, adopted };
                         g.leg.adopted.move(ev.world);
                     }
+                    else if (parentPeerOf(api.container, peer.group.id) === selfPeer) {
+                        // A section of this board refused (full, fit): the widget pushes it (D2).
+                        g.refusedPeer = peer;
+                        placeOnSelf(g, desired, true);
+                    }
                     else {
-                        // Bounded/full board refused the adoption: dim = will snap home.
+                        // A board deeper down refused the adoption: dim = will snap home (the N-board scope is step 4).
+                        g.refusedPeer = peer;
                         (_d = hostOf(g.id)) === null || _d === void 0 ? void 0 : _d.classList.add('axdb-out');
                     }
                 }
             }
             else if (inside) {
                 // -- back on (or still on) our own board --------------------------
+                g.refusedPeer = null;
                 if (g.leg) {
                     g.leg.adopted.abort();
                     g.leg = null;
                 }
-                if (g.removedFromBoard) {
-                    g.removedFromBoard = false;
-                    (_e = hostOf(g.id)) === null || _e === void 0 ? void 0 : _e.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.
-                    engine.add({ id: g.id, x: 0, y: engine.rows(), w: g.spans.w, h: g.spans.h });
-                    engine.moveCheck(g.id, cell.x, cell.y, { gate: false });
-                    project();
-                }
-                else {
-                    const spanW = (_g = (_f = engine.getItem(g.id)) === null || _f === void 0 ? void 0 : _f.w) !== null && _g !== void 0 ? _g : 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();
-                }
+                placeOnSelf(g, desired);
             }
             else {
                 // -- outside every board ------------------------------------------
@@ -2177,7 +2089,7 @@ export function bindDashboardGrid(api, group, options = {}) {
                 if (!g.removedFromBoard) {
                     g.removedFromBoard = true;
                     engine.remove(g.id); // survivors settle home; cells minted nowhere
-                    (_h = hostOf(g.id)) === null || _h === void 0 ? void 0 : _h.classList.add('axdb-out');
+                    (_e = hostOf(g.id)) === null || _e === void 0 ? void 0 : _e.classList.add('axdb-out');
                     project();
                 }
             }
@@ -2287,7 +2199,7 @@ export function bindDashboardGrid(api, group, options = {}) {
                     maxRows = n;
                     engine.maxRows = n;
                 };
-                const slabRows = (_k = (_j = parent.memberCell(group.id)) === null || _j === void 0 ? void 0 : _j.h) !== null && _k !== void 0 ? _k : maxRows;
+                const slabRows = (_g = (_f = parent.memberCell(group.id)) === null || _f === void 0 ? void 0 : _f.h) !== null && _g !== void 0 ? _g : maxRows;
                 const inner = maxRows;
                 const rhNow = rowHeightFor(geom(), rows());
                 const rowPx = rhNow + gap;
@@ -2451,7 +2363,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, (_l = g.node.size.depth) !== null && _l !== void 0 ? _l : 0);
+        g.node.setSize(w, h, (_h = g.node.size.depth) !== null && _h !== void 0 ? _h : 0);
         g.node.setPosition(px, py);
         ghostStyleFastPath(g, { x: px, y: py, width: w, height: h });
         const spanF = bound() !== undefined ? frame() : f;
@@ -2695,6 +2607,25 @@ export function bindDashboardGrid(api, group, options = {}) {
         });
         return peers.filter((p) => !p.group.parentGroupId).map((p) => boardRef(p, 0));
     };
+    /** The ghost takes the cell under the hand on THIS board: re-entering at the bottom edge first (collision-free), then gatelessly; a tile already here moves through the gate. */
+    const placeOnSelf = (g, desired, pushSolid = false) => {
+        var _a, _b, _c;
+        if (g.removedFromBoard) {
+            g.removedFromBoard = false;
+            (_a = hostOf(g.id)) === null || _a === void 0 ? void 0 : _a.classList.remove('axdb-out');
+            const cell = pointToCell(desired.x, desired.y, frame(), geom(), rows(), g.spans.w);
+            engine.add({ id: g.id, x: 0, y: engine.rows(), w: g.spans.w, h: g.spans.h });
+            if (!engine.moveCheck(g.id, cell.x, cell.y, { gate: false, pushSolid }).changed)
+                placeNear(g.id, cell.x, cell.y, g.spans.w, pushSolid);
+            project();
+        }
+        else {
+            const spanW = (_c = (_b = engine.getItem(g.id)) === null || _b === void 0 ? void 0 : _b.w) !== null && _c !== void 0 ? _c : g.spans.w;
+            const cell = pointToCell(desired.x, desired.y, frame(), geom(), rows(), spanW);
+            if (engine.moveCheck(g.id, cell.x, cell.y, { pushSolid }).changed)
+                project();
+        }
+    };
     /** What the pointer means for the dragged tile: the resolve over the live tree, with the beside the hand holds. */
     const resolveTileZone = (g, ev) => {
         let strip = null;
@@ -2712,8 +2643,19 @@ export function bindDashboardGrid(api, group, options = {}) {
             ghostDepth: 0,
             ghostSubtree: EMPTY_SUBTREE,
             gap,
+            homeChain: homeChain(),
         });
     };
+    /** The groups this board sits in, all the way up: their bands never apply to a tile of this board. */
+    const homeChain = () => {
+        const out = new Set();
+        let cur = group;
+        for (let i = 0; cur && i < 32; i++) {
+            out.add(cur.id);
+            cur = cur.parentGroupId ? diagram.getGroup(cur.parentGroupId) : undefined;
+        }
+        return out;
+    };
     /** The board whose engine holds OUR group as an item (nesting parent). */
     const parentPeer = () => {
         for (const p of peersOnCanvas()) {
@@ -2756,7 +2698,7 @@ export function bindDashboardGrid(api, group, options = {}) {
      * wherever the last swing left it. Ask where the tile IS, not whether the
      * call moved it.
      */
-    const placeOnRow = (id, x, y, w) => {
+    const placeOnRow = (id, x, y, w, pushSolid = false) => {
         const at = (cx) => {
             const i = engine.getItem(id);
             return !!i && i.x === cx && i.y === y;
@@ -2764,7 +2706,7 @@ export function bindDashboardGrid(api, group, options = {}) {
         const maxX = Math.max(0, columns - w);
         if (at(x))
             return true;
-        if (engine.moveCheck(id, x, y, { gate: false }).changed)
+        if (engine.moveCheck(id, x, y, { gate: false, pushSolid }).changed)
             return true;
         for (let d = 1; d <= columns; d++) {
             for (const cx of [x - d, x + d]) {
@@ -2772,14 +2714,14 @@ export function bindDashboardGrid(api, group, options = {}) {
                     continue;
                 if (at(cx))
                     return true;
-                if (engine.moveCheck(id, cx, y, { gate: false }).changed)
+                if (engine.moveCheck(id, cx, y, { gate: false, pushSolid }).changed)
                     return true;
             }
         }
         return false;
     };
-    const placeNear = (id, x, y, w) => {
-        if (placeOnRow(id, x, y, w))
+    const placeNear = (id, x, y, w, pushSolid = false) => {
+        if (placeOnRow(id, x, y, w, pushSolid))
             return true;
         // EVERY column on that row refused — which is what a locked section
         // spanning the full width does, and there are plenty of those. Sliding
@@ -2791,7 +2733,7 @@ export function bindDashboardGrid(api, group, options = {}) {
             for (const cy of [y - d, y + d]) {
                 if (cy < 0)
                     continue;
-                if (placeOnRow(id, x, cy, w))
+                if (placeOnRow(id, x, cy, w, pushSolid))
                     return true;
             }
         }
@@ -2806,7 +2748,7 @@ export function bindDashboardGrid(api, group, options = {}) {
     const fitHeightAt = (id, x, y, w, hNatural) => {
         let limit = hNatural;
         for (const it of engine.getItems()) {
-            if (it.id === id || !it.locked)
+            if (it.id === id || !(it.locked || it.solid))
                 continue;
             if (!(it.x < x + w && x < it.x + it.w))
                 continue;
@@ -2935,7 +2877,7 @@ export function bindDashboardGrid(api, group, options = {}) {
                 const it = engine.getItem(node.id);
                 return it ? cellToRect(it, frame(), geom(), rows()) : null;
             },
-            place: (cell) => {
+            place: (cell, pushSolid = false) => {
                 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);
@@ -2952,10 +2894,10 @@ export function bindDashboardGrid(api, group, options = {}) {
                     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 });
+                    engine.moveCheck(node.id, cell.x, cell.y, { gate: false, pushSolid });
                 const now = engine.getItem(node.id);
                 if (now && (now.w !== cell.w || now.h !== cell.h))
-                    engine.resizeCheck(node.id, cell.w, cell.h);
+                    engine.resizeCheck(node.id, cell.w, cell.h, { pushSolid });
                 lastWant = null;
                 project();
                 syncPlaceholder();
@@ -3836,7 +3778,7 @@ export function bindDashboardGrid(api, group, options = {}) {
         // thirds, and the user, putting a page back into the panel it came from,
         // never found the "into": "close to the edge means beside it, the content
         // area means inside, the header means a new tab" (0.4.42).
-        const EDGE_BAND = 0.2;
+        const EDGE_BAND = BESIDE_BAND; // one band for a tab's split and a widget's beside (zones.ts)
         const visibleFrame = () => {
             const rect = api.container.getBoundingClientRect();
             const o = toWorld(rect.left, rect.top);
@@ -3954,47 +3896,55 @@ export function bindDashboardGrid(api, group, options = {}) {
         const zoneAt = (cx, cy, world) => {
             // A pointer OUTSIDE the visible canvas is off, full stop: a camera that
             // moved can map it to a world point inside a group, and that group
-            // took a join or a split from a release in the page header.
-            if (!clientInsideCanvasGrace(cx, cy))
-                return { kind: 'off' };
-            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 >= EDGE_BAND && rx <= 1 - EDGE_BAND && ry >= EDGE_BAND && ry <= 1 - EDGE_BAND)
-                    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' };
+            // took a join or a split from a release in the page header. The
+            // target is looked up (and anchored) only inside it.
+            const clientInside = clientInsideCanvasGrace(cx, cy);
+            const target = clientInside ? targetAt(world.x, world.y) : null;
+            const root = clientInside ? rootAt(cx, cy) : null;
             const foreign = foreignAt(world.x, world.y);
-            if (foreign && (!worldInsideBoard(world.x, world.y) || foreign.frameArea() < boardArea()))
-                return { kind: 'board', peer: foreign };
-            return { kind: 'board' };
+            // The ORDER is zones.ts's, shared with the split board: a strip, the
+            // board's own edges, the target's fifth or middle, home, then a board.
+            const tz = resolveTabZone({
+                x: world.x,
+                y: world.y,
+                clientInside,
+                ownStrip: plan.stripIndex(fromGroupId, cx, cy),
+                stripOf: (id) => plan.stripIndex(id, cx, cy),
+                root: root && root.kind === 'root' ? { side: root.side } : null,
+                target: target
+                    ? {
+                        id: target.id,
+                        frame: anchor && anchor.g === target ? anchor.frame : frameOfGroup(target),
+                        stripHeight: anchor && anchor.g === target ? anchor.stripH : plan.stripHeight(target.id),
+                    }
+                    : null,
+                home: worldInsideGroup(from, world.x, world.y) ? frameOfGroup(from) : null,
+                homeBand: 0, // on a grid board the whole source frame is home
+                band: EDGE_BAND,
+                canSplit: (_id, side) => !!target && !!halves(target, side),
+                pane: false,
+                foreign: !!foreign && (!worldInsideBoard(world.x, world.y) || foreign.frameArea() < boardArea()),
+            });
+            switch (tz.kind) {
+                case 'off':
+                    return { kind: 'off' };
+                case 'strip':
+                    return { kind: 'strip', target: target, index: tz.index };
+                case 'reorder':
+                    return { kind: 'reorder', index: tz.index };
+                case 'root':
+                    return root;
+                case 'join':
+                    return { kind: 'join', target: target };
+                case 'split': {
+                    const h = halves(target, tz.side);
+                    return h ? Object.assign({ kind: 'split', target: target, side: tz.side }, h) : { kind: 'join', target: target };
+                }
+                case 'home':
+                    return { kind: 'home' };
+                default:
+                    return tz.kind === 'board' && tz.foreign && foreign ? { kind: 'board', peer: foreign } : { kind: 'board' };
+            }
         };
         const zoneKey = (z) => JSON.stringify(z, (k, v) => (k === 'target' ? v.id : k === 'peer' ? v.group.id : v));
         // DOCKING PUSHES SECTIONS. A section is a locked tile so that a widget
@@ -4003,25 +3953,6 @@ export function bindDashboardGrid(api, group, options = {}) {
         // 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
@@ -4089,18 +4020,24 @@ export function bindDashboardGrid(api, group, options = {}) {
                     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 previewSplit = (z, world) => {
             const it = engine.getItem(z.target.id);
+            if (!it)
+                return false;
+            // The target's cell AT REST is the one the commit restores — read it
+            // BEFORE the leg enters: the arriving ghost is placed under the pointer
+            // first, and a target that is a tile like any other is pushed by it
+            // for a moment (tile first, step 3) until it takes its half below.
+            const before = { x: it.x, y: it.y, w: it.w, h: it.h };
+            const frameBefore = frameOfGroup(z.target);
             const l = ensureLeg(world, null);
-            if (!it || !l)
+            if (!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
+            split = { id: z.target.id, before, frameBefore, keep: z.keep };
             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);
@@ -4122,8 +4059,7 @@ export function bindDashboardGrid(api, group, options = {}) {
             const l = ensureLeg(world, null);
             if (!l)
                 return false;
-            unlockGroups();
-            l.place(z.cell);
+            l.place(z.cell, true); // DOCKING PUSHES SECTIONS: everything below the band moves down, solid or not
             insertRows(z.cell, l);
             project();
             placeholder === null || placeholder === void 0 ? void 0 : placeholder.remove();
@@ -4145,7 +4081,6 @@ export function bindDashboardGrid(api, group, options = {}) {
             }
             undoSplitPreview();
             undoInsertRows();
-            relockGroups();
             plan.markDrop(null, null);
             hideOverlay();
             // A PREVIEW IS AN OVERLAY. A split and a dock used to be applied LIVE
@@ -4233,7 +4168,6 @@ export function bindDashboardGrid(api, group, options = {}) {
             if (!commit || z.kind === 'home' || z.kind === 'off' || (z.kind === 'root' && !ensureLeg(world, null)) || (z.kind === 'board' && (!ensureLeg(world, (_a = z.peer) !== null && _a !== void 0 ? _a : null) || landingHidden()))) {
                 undoSplitPreview();
                 leg === null || leg === void 0 ? void 0 : leg.abort();
-                relockGroups();
                 done(false, 'cancel');
                 return;
             }
@@ -4272,8 +4206,6 @@ export function bindDashboardGrid(api, group, options = {}) {
                 const fin = (_b = leg === null || leg === void 0 ? void 0 : leg.finalize()) !== null && _b !== void 0 ? _b : 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();
@@ -4301,7 +4233,6 @@ export function bindDashboardGrid(api, group, options = {}) {
             hideOverlay(); // a re-applied zone repaints its preview; the release is not a preview
             plan.markDrop(null, null);
             const fin = (_c = leg === null || leg === void 0 ? void 0 : leg.finalize()) !== null && _c !== void 0 ? _c : null;
-            relockGroups();
             if (!fin) {
                 done(false, 'cancel');
                 return;
@@ -4464,14 +4395,7 @@ export function bindDashboardGrid(api, group, options = {}) {
             return false;
         engine.beginGesture();
         const snap = snapshotAll();
-        // 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;
@@ -4758,7 +4682,7 @@ export function bindDashboardGrid(api, group, options = {}) {
             return buildCommitCommands(deltas);
         },
         moveTo(id, x, y) {
-            return programmatic('Move widget', id, () => engine.moveCheck(id, x, y).changed);
+            return programmatic('Move widget', id, () => engine.moveCheck(id, x, y, { pushSolid: isGroupMember(id) }).changed);
         },
         resizeTo(id, w, h) {
             const hh = isGroupMember(id) ? Math.max(h, innerRowsOf(id)) : h; // a section: never below its children

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

@@ -23,6 +23,7 @@
  * the authored size.
  */
 import { __awaiter } from "tslib";
+import { BESIDE_BAND, resolveTabZone } from './zones.js';
 import { BatchCommand, Command } from '@grafloria/engine';
 import { LiveRegionController, registerTool } from '@grafloria/renderer';
 import { anyEdge, clearOtherSelections, dragHandleSelector, gripHostOf, gripOf, normalizeDragHandle, ownsPress, parentPeerOf, pressOnDragHandle, registerBoardPeer, syncGrip, DRAG_HANDLE_CLASS, EDGE_GRIP } from './grid-binder.js';
@@ -1037,37 +1038,48 @@ export function bindDashboardSplit(api, group, options = {}) {
                 return true;
             return cx >= rect.left - EDGE_GRACE && cx <= rect.right + EDGE_GRACE && cy >= rect.top - EDGE_GRACE && cy <= rect.bottom + EDGE_GRACE;
         };
-        /** The centre third of a container's BODY (below its strip), both axes — the grid board's join zone. */
-        const centreThird = (g, w) => {
-            const f = frameOfGroup(g);
-            if (!inRect(f, w.x, w.y))
-                return false;
-            const top = f.y + plan.stripHeight(g.id);
-            const h = Math.max(0, f.y + f.height - top);
-            return w.x >= f.x + f.width / 3 && w.x <= f.x + (2 * f.width) / 3 && w.y >= top + h / 3 && w.y <= top + (2 * h) / 3;
-        };
         const zoneAt = (cx, cy, w) => {
-            if (!clientInsideCanvasGrace(cx, cy))
-                return { kind: 'off' };
-            const own = plan.stripIndex(fromGroupId, cx, cy);
-            if (own !== null)
-                return { kind: 'reorder', index: own };
-            for (const t of targets) {
-                const i = plan.stripIndex(t.id, cx, cy);
-                if (i !== null)
-                    return { kind: 'strip', targetId: t.id, index: i };
-            }
-            for (const t of targets)
-                if (centreThird(t, w))
-                    return { kind: 'join', targetId: t.id };
-            if (centreThird(from, w))
-                return { kind: 'home' };
-            if (worldInsideBoard(w.x, w.y)) {
-                const t = dropTargetAt(tree0, w.x, w.y);
-                if (t)
-                    return { kind: 'pane', target: t };
+            var _a;
+            // The ORDER is zones.ts's, shared with the grid board: a strip, the
+            // target's fifth (a pane beside it on that side, the sides taking the
+            // corners) or its middle (a join), home — the source's middle, its own
+            // edges meaning a pane beside itself — then the pane under the pointer.
+            // The fifth replaced the centre third here too (0.4.42's rule, at last
+            // on both boards).
+            const clientInside = clientInsideCanvasGrace(cx, cy);
+            const target = clientInside ? ((_a = targets.find((t) => inRect(frameOfGroup(t), w.x, w.y))) !== null && _a !== void 0 ? _a : null) : null;
+            const paneTarget = clientInside && worldInsideBoard(w.x, w.y) ? dropTargetAt(tree0, w.x, w.y) : null;
+            const tz = resolveTabZone({
+                x: w.x,
+                y: w.y,
+                clientInside,
+                ownStrip: plan.stripIndex(fromGroupId, cx, cy),
+                stripOf: (id) => plan.stripIndex(id, cx, cy),
+                root: null,
+                target: target ? { id: target.id, frame: frameOfGroup(target), stripHeight: plan.stripHeight(target.id) } : null,
+                home: inRect(frameOfGroup(from), w.x, w.y) ? frameOfGroup(from) : null,
+                homeBand: BESIDE_BAND,
+                band: BESIDE_BAND,
+                canSplit: () => true,
+                pane: !!paneTarget,
+                foreign: false,
+            });
+            switch (tz.kind) {
+                case 'off':
+                    return { kind: 'off' };
+                case 'strip':
+                    return { kind: 'strip', targetId: tz.targetId, index: tz.index };
+                case 'reorder':
+                    return { kind: 'reorder', index: tz.index };
+                case 'join':
+                    return { kind: 'join', targetId: tz.targetId };
+                case 'split':
+                    return { kind: 'pane', target: { id: tz.targetId, side: tz.side, rect: frameOfGroup(target) } };
+                case 'pane':
+                    return { kind: 'pane', target: paneTarget };
+                default:
+                    return { kind: 'home' };
             }
-            return { kind: 'home' };
         };
         const apply = (z) => {
             plan.markDrop(z.kind === 'reorder' ? fromGroupId : z.kind === 'strip' ? z.targetId : null, z.kind === 'reorder' || z.kind === 'strip' ? z.index : null);

package/src/lib/dashboard-kit/zones.d.ts

@@ -81,6 +81,13 @@ export interface ResolveInput {
     ghostSubtree: ReadonlySet<string>;
     /** The board's gap, the tolerance around the vacated cell. */
     gap: number;
+    /**
+     * The containers the dragged tile's OWN board sits in, innermost first or
+     * in any order: their bands do not apply to it. A widget leaving its page
+     * through the page's left fifth is moving within the page, not asking to
+     * be put beside the container it is still inside.
+     */
+    homeChain: ReadonlySet<string>;
 }
 export type Zone = {
     kind: 'off';
@@ -111,3 +118,74 @@ export declare const BESIDE_STAY = 0.05;
  */
 export declare function bandOf(f: ZoneRect, stripHeight: number, x: number, y: number, band?: number): BesideSide | null;
 export declare function resolve(input: ResolveInput): Zone;
+/** A join target as the walk sees it: another tab container, its frame anchored by the binder while the pointer is inside it. */
+export interface TabTarget {
+    id: string;
+    frame: ZoneRect;
+    stripHeight: number;
+}
+export interface TabZoneInput {
+    x: number;
+    y: number;
+    /** Inside the visible canvas plus its grace, in CLIENT space: off otherwise, whatever the world point says. */
+    clientInside: boolean;
+    /** The source strip's slot under the pointer (client space), else null. */
+    ownStrip: number | null;
+    /** A target strip's slot under the pointer (client space), else null. */
+    stripOf(targetId: string): number | null;
+    /** The board's own edge band under the pointer (client space) — a dock; null on boards that have none. */
+    root: {
+        side: BesideSide;
+    } | null;
+    /** The join target whose frame holds the point, or null. */
+    target: TabTarget | null;
+    /** The source group's frame, when the pointer is inside it. */
+    home: ZoneRect | null;
+    /** The source group's own band: 0 keeps its whole frame "home", a fifth lets its edges mean "beside myself". */
+    homeBand: number;
+    /** The outer fraction of a target's body that splits it (Dockview's fifth). */
+    band: number;
+    /** Whether the target can be halved on that side (a grid target too small refuses; a pane always can). */
+    canSplit(targetId: string, side: BesideSide): boolean;
+    /** A pane insertion exists under the pointer (split boards). */
+    pane: boolean;
+    /** A foreign board lies under the pointer and takes the drop (grid boards). */
+    foreign: boolean;
+}
+export type TabZone = {
+    kind: 'off';
+} | {
+    kind: 'reorder';
+    index: number;
+} | {
+    kind: 'strip';
+    targetId: string;
+    index: number;
+} | {
+    kind: 'root';
+    side: BesideSide;
+} | {
+    kind: 'join';
+    targetId: string;
+} | {
+    kind: 'split';
+    targetId: string;
+    side: BesideSide;
+} | {
+    kind: 'home';
+} | {
+    kind: 'pane';
+} | {
+    kind: 'board';
+    foreign: boolean;
+};
+/**
+ * What a pointer means for a TORN-OUT PAGE, in the one order both binders
+ * use: off the canvas, then a strip (the most precise target there is —
+ * a target's, or the source's own for a reorder), then the board's own
+ * edges (Dockview's container edges beat the groups against them), then the
+ * target under the pointer — its outer fifth splits it on that side, the
+ * sides taking the corners, its middle joins it — then home, then a pane, a
+ * foreign board, or this board.
+ */
+export declare function resolveTabZone(input: TabZoneInput): TabZone;

package/src/lib/dashboard-kit/zones.js

@@ -106,22 +106,28 @@ export function resolve(input) {
         const px = x + dx;
         const py = y + dy;
         for (const c of board.children()) {
-            const atRest = held && c.id === held.containerId ? held.frame0 : null;
+            // the held container at rest — unless the hand has left that frame for the live one
+            const atRest = held && c.id === held.containerId && inRect(held.frame0, x, y) ? held.frame0 : null;
             const frame = atRest !== null && atRest !== void 0 ? atRest : c.frame;
             const tx = atRest ? x : px;
             const ty = atRest ? y : py;
             if (!inRect(frame, tx, ty))
                 continue;
-            const side = bandOf(frame, c.stripHeight, tx, ty, c.band);
+            // A band does not reach THROUGH a nested container: a hand over a
+            // section inside the page is inside the page, wherever the outer
+            // container's fifth falls (the inset margin is what remains of the
+            // band there). The page's plain widgets do not stop it.
+            const ndx0 = atRest ? c.frame.x - atRest.x : dx;
+            const ndy0 = atRest ? c.frame.y - atRest.y : dy;
+            const overNested = !!c.inner && c.inner.children().some((cc) => inRect(cc.frame, x + ndx0, y + ndy0));
+            const side = overNested || input.homeChain.has(c.id) ? null : bandOf(frame, c.stripHeight, tx, ty, c.band);
             if (side)
                 return { kind: 'beside', board, containerId: c.id, side, kept: false };
             if (opaque(board, c) || !c.inner)
                 return { kind: 'plain', board, grace: false };
-            const ndx = atRest ? c.frame.x - atRest.x : dx;
-            const ndy = atRest ? c.frame.y - atRest.y : dy;
-            if (!c.inner.contains(x + ndx, y + ndy))
+            if (!c.inner.contains(x + ndx0, y + ndy0))
                 return { kind: 'plain', board, grace: false }; // the margin: the container's own frame
-            return descend(c.inner, ndx, ndy);
+            return descend(c.inner, ndx0, ndy0);
         }
         return { kind: 'plain', board, grace: false };
     };
@@ -159,4 +165,39 @@ function stripHeightOf(roots, containerId) {
     }
     return 0;
 }
+/**
+ * What a pointer means for a TORN-OUT PAGE, in the one order both binders
+ * use: off the canvas, then a strip (the most precise target there is —
+ * a target's, or the source's own for a reorder), then the board's own
+ * edges (Dockview's container edges beat the groups against them), then the
+ * target under the pointer — its outer fifth splits it on that side, the
+ * sides taking the corners, its middle joins it — then home, then a pane, a
+ * foreign board, or this board.
+ */
+export function resolveTabZone(input) {
+    if (!input.clientInside)
+        return { kind: 'off' };
+    const { x, y } = input;
+    if (input.target) {
+        const idx = input.stripOf(input.target.id);
+        if (idx !== null)
+            return { kind: 'strip', targetId: input.target.id, index: idx };
+    }
+    else if (input.ownStrip !== null)
+        return { kind: 'reorder', index: input.ownStrip };
+    if (input.root)
+        return { kind: 'root', side: input.root.side };
+    if (input.target) {
+        const t = input.target;
+        const side = bandOf(t.frame, t.stripHeight, x, y, input.band);
+        if (side && input.canSplit(t.id, side))
+            return { kind: 'split', targetId: t.id, side };
+        return { kind: 'join', targetId: t.id };
+    }
+    if (input.home && inRect(input.home, x, y) && !bandOf(input.home, 0, x, y, input.homeBand))
+        return { kind: 'home' };
+    if (input.pane)
+        return { kind: 'pane' };
+    return { kind: 'board', foreign: input.foreign };
+}
 //# sourceMappingURL=zones.js.map