@grafloria/element 0.4.69 → 0.4.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grafloria/element",
-  "version": "0.4.69",
+  "version": "0.4.71",
   "type": "module",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",

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

@@ -472,6 +472,13 @@ interface BinderPeer {
         cellAfter?: CellRect;
         frameBefore?: WorldRect;
         frameAfter?: WorldRect;
+        /**
+         * The parent's OWN commit for the growth so far, when a cell command
+         * cannot carry it — a SPLIT parent's tree with the pane's new share
+         * (0.4.71). Supersedes what an earlier ask answered; the arriving
+         * board's `finalize` carries it instead of a `SetGroupCellCommand`.
+         */
+        commands?: Command[];
     };
     containsWorld(x: number, y: number): boolean;
     /**
@@ -631,7 +638,7 @@ export interface AdoptedLeg {
         containerId: string;
         side: BesideSide;
         frame0: WorldRect;
-        vacated: WorldRect;
+        vacated?: WorldRect;
     } | null;
     /**
      * Take the tile OFF the board while the pointer is somewhere the board is

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

@@ -2508,6 +2508,7 @@ export function bindDashboardGrid(api, group, options = {}) {
             let rowsAdded = 0;
             let firstBefore = null;
             let lastAfter = null;
+            let parentCommands;
             // At most the tile's own height in rows: past that the board is not
             // "full", it is smaller than the thing being dropped into it.
             for (let i = 0; parent && !entered && i < Math.max(1, span.h); i++) {
@@ -2517,11 +2518,13 @@ export function bindDashboardGrid(api, group, options = {}) {
                 rowsAdded += 1;
                 firstBefore = firstBefore !== null && firstBefore !== void 0 ? firstBefore : { cell: res.cellBefore, frame: res.frameBefore };
                 lastAfter = { cell: res.cellAfter, frame: res.frameAfter };
+                if (res.commands)
+                    parentCommands = res.commands; // the latest ask's answer carries every row so far
                 setLiveBound((maxRows !== null && maxRows !== void 0 ? maxRows : 0) + 1);
                 entered = engine.add({ id: node.id, x: 0, y: engine.rows(), w: span.w, h: span.h });
             }
             if (parent && rowsAdded > 0 && firstBefore && lastAfter) {
-                grown = { peer: parent, rows: rowsAdded, cellBefore: firstBefore.cell, frameBefore: firstBefore.frame, cellAfter: lastAfter.cell, frameAfter: lastAfter.frame };
+                grown = Object.assign({ peer: parent, rows: rowsAdded, cellBefore: firstBefore.cell, frameBefore: firstBefore.frame, cellAfter: lastAfter.cell, frameAfter: lastAfter.frame }, (parentCommands ? { commands: parentCommands } : {}));
             }
         }
         if (!entered) {
@@ -2663,6 +2666,7 @@ export function bindDashboardGrid(api, group, options = {}) {
                 syncPlaceholder();
             },
             finalize: () => {
+                var _a;
                 endBeside(false); // the shift stays: the deltas below carry it
                 const item = engine.getItem(node.id);
                 if (!item) {
@@ -2678,7 +2682,8 @@ export function bindDashboardGrid(api, group, options = {}) {
                 const commands = tileCommands(deltasSince(startCells, startGeom, node.id));
                 // …and the rows this board took from its parent to hold the arrival (D4).
                 if (grown) {
-                    commands.push(new SetGroupCellCommand(group.id, grown.cellBefore, grown.cellAfter, grown.frameBefore, grown.frameAfter));
+                    // A grid parent's rows are the section's cell; a split parent's are its tree (0.4.71).
+                    commands.push(...((_a = grown.commands) !== null && _a !== void 0 ? _a : [new SetGroupCellCommand(group.id, grown.cellBefore, grown.cellAfter, grown.frameBefore, grown.frameAfter)]));
                     grown = null;
                 }
                 engine.endGesture();

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

@@ -30,7 +30,7 @@ import { anyEdge, clearOtherSelections, clientPerWorldOf, dragHandleSelector, gr
 import { buildCommitCommands, cellFromGridItem } from './grid-mapping.js';
 import { SequenceCommand } from './commit.js';
 import { TAB_STRIP_HEIGHT } from './tabs.js';
-import { addSplitLeaf, cellsFromSplit, cloneSplit, dividersOf, groupRectsOf, insertSplitLeaf, moveSplitDivider, normalizeSplit, pathToLeaf, projectSplit, removeSplitLeaf, splitFromCells, splitLeaves, } from './split-layout.js';
+import { addSplitLeaf, cellsFromSplit, cloneSplit, dividersOf, groupRectsOf, insertSplitLeaf, isSplitGroup, moveSplitDivider, nodeAt, normalizeSplit, pathToLeaf, projectSplit, removeSplitLeaf, splitFromCells, splitLeaves, } from './split-layout.js';
 import { ensureDashboardKitStyles } from './styles.js';
 import { captionKey, captionOfGroup, captionPainted, paintCaptionBand, sectionCaptionReserve, sizeCaptionBand } from './caption.js';
 /** Group metadata key the tree persists under. */
@@ -243,8 +243,8 @@ export function bindDashboardSplit(api, group, options = {}) {
         if (grp)
             diagram.runSystemWrite(() => grp.setFrame(Object.assign({}, r)));
     };
-    /** The tree currently PAINTED — the gesture's live tree while one runs. */
-    const paintedTree = () => ((gesture === null || gesture === void 0 ? void 0 : gesture.started) ? gesture.liveTree : readTree());
+    /** The tree currently PAINTED — the gesture's live tree while one runs, else a pane grown for an arriving tile (0.4.71), else the persisted one. */
+    const paintedTree = () => { var _a; return ((gesture === null || gesture === void 0 ? void 0 : gesture.started) ? gesture.liveTree : ((_a = grown === null || grown === void 0 ? void 0 : grown.tree) !== null && _a !== void 0 ? _a : readTree())); };
     const project = (tree = paintedTree()) => {
         const rects = rectsOf(tree);
         for (const [id, r] of rects) {
@@ -580,6 +580,253 @@ export function bindDashboardSplit(api, group, options = {}) {
         g.leg.adopted.abort();
         g.leg = null;
     };
+    /**
+     * What the zone means for the pane under the hand — the one step the widget
+     * drag and the palette drag share (0.4.70): a strip marks its slot (a
+     * widget's, never a chip's — the walk answers no strip for a chip); a band
+     * beside a container is a pane on that side, this board's line; a plain
+     * cell on a NESTED board, or on the board holding this one, hands the tile
+     * to that board through a leg (its own placeholder), a board that refuses
+     * leaving the split rule to answer; anything else is the nearest edge of
+     * the pane under the pointer. Answers the insertion target, or null.
+     */
+    const zoneTarget = (g, z, world, inside, px) => {
+        var _a, _b, _c;
+        if (z.kind === 'strip') {
+            endLeg(g);
+            g.beside = null;
+            if (!g.strip || g.strip.containerId !== z.containerId || g.strip.index !== z.index)
+                (_a = options.tabDrop) === null || _a === void 0 ? void 0 : _a.markDrop(z.containerId, z.index);
+            g.strip = { containerId: z.containerId, index: z.index };
+            return null;
+        }
+        endStrip(g);
+        const peer = z.kind === 'plain' ? ((_b = z.board.ref) !== null && _b !== void 0 ? _b : null) : null;
+        if (z.kind === 'beside') {
+            endLeg(g);
+            const grp = diagram.getGroup(z.containerId);
+            const rect = (_c = rectsOf(g.liveTree).get(z.containerId)) !== null && _c !== void 0 ? _c : (grp ? frameOfGroupW(grp) : null);
+            if (!rect)
+                return null;
+            g.beside = z.kept && g.beside ? g.beside : { containerId: z.containerId, side: z.side, frame0: rect };
+            return { id: z.containerId, side: z.side, rect };
+        }
+        g.beside = null;
+        if (peer && peer !== selfPeerRef) {
+            if (g.leg && g.leg.peer !== peer)
+                endLeg(g);
+            if (!g.leg) {
+                const adopted = peer.adopt({ id: g.id }, world, px, {});
+                if (adopted)
+                    g.leg = { peer, adopted };
+            }
+            if (g.leg) {
+                g.leg.adopted.move(world);
+                return null;
+            }
+        }
+        else
+            endLeg(g);
+        return inside ? dropTargetAt(g.liveTree, world.x, world.y, g.id) : null;
+    };
+    // -- the split board as an adoption TARGET (0.4.70) ----------------------------
+    /**
+     * A tile from ANOTHER board — a widget leaving a page or a section, a
+     * palette chip — held over this board through a leg. Measured live on
+     * 0.4.69: a widget dragged out of the Filters page in split mode got no
+     * line and no placeholder anywhere, the ghost dimmed, every release
+     * snapped home — this peer's `adopt` answered null. The leg's promise is
+     * the insertion line on the nearest edge of the pane under the pointer;
+     * nothing moves until the release (the split model's rule); `finalize`
+     * answers the tree with the new pane, so the source's commit carries it. A
+     * beside on a container of this board is a pane on that side of it. An
+     * empty board takes the tile as its whole.
+     */
+    const adoptPane = (node, world, opts = {}) => {
+        if (disposed || isStatic)
+            return null;
+        const tree = readTree();
+        if (tree && splitLeaves(tree).includes(node.id))
+            return null; // a pane of this board never adopts itself
+        const whole = { path: [], side: 'top', rect: frame() };
+        const state = { target: null };
+        const targetAt = (w) => (!worldInsideBoard(w.x, w.y) ? null : tree ? dropTargetAt(tree, w.x, w.y) : whole);
+        const paint = () => {
+            showInsertion(state.target ? insertionRect(state.target.rect, state.target.side) : null);
+            api.render();
+        };
+        const after = () => {
+            if (!state.target)
+                return null;
+            if (!tree)
+                return normalizeSplit(addSplitLeaf(null, node.id, frame(), gap, padding));
+            const t = state.target;
+            const side = rtl && (t.side === 'left' || t.side === 'right') ? (t.side === 'left' ? 'right' : 'left') : t.side;
+            return normalizeSplit(insertSplitLeaf(tree, node.id, targetRef(t), side));
+        };
+        const cellOf = () => {
+            var _a;
+            const t = after();
+            return t ? ((_a = cellsFromSplit(t, columns, rowsGuess()).get(node.id)) !== null && _a !== void 0 ? _a : null) : null;
+        };
+        const rectOf = () => {
+            var _a;
+            const t = after();
+            return t ? ((_a = rectsOf(t).get(node.id)) !== null && _a !== void 0 ? _a : null) : null;
+        };
+        const besideOn = (containerId, side) => {
+            const rect = rectsOf(tree).get(containerId);
+            if (!rect)
+                return;
+            state.target = { id: containerId, side, rect };
+            paint();
+        };
+        if (opts.beside)
+            besideOn(opts.beside.containerId, opts.beside.side);
+        else {
+            state.target = targetAt(world);
+            paint();
+        }
+        return {
+            groupId: group.id,
+            move: (w) => {
+                state.target = targetAt(w);
+                paint();
+            },
+            beside: (containerId, side) => besideOn(containerId, side),
+            besideState: () => {
+                const t = state.target;
+                if (!t || !('id' in t) || !diagram.getGroup(t.id))
+                    return null;
+                return { containerId: t.id, side: t.side, frame0: t.rect };
+            },
+            leave: () => {
+                state.target = null;
+                paint();
+            },
+            enter: (w) => {
+                state.target = targetAt(w);
+                paint();
+            },
+            place: () => false, // a pane is the tree's to size: no prescribed cell here
+            baseline: () => (tree ? cellsFromSplit(tree, columns, rowsGuess()) : new Map()),
+            cell: () => cellOf(),
+            rect: () => rectOf(),
+            abort: () => {
+                state.target = null;
+                showInsertion(null);
+                api.render();
+            },
+            finalize: () => {
+                const t = after();
+                const cell = cellOf();
+                const rect = rectOf();
+                state.target = null;
+                showInsertion(null);
+                if (!t || !cell || !rect)
+                    return null;
+                return { commands: [new SetSplitTreeCommand(group.id, tree, t)], cell, rect };
+            },
+        };
+    };
+    // -- D4 on a split board (0.4.71): a section pane GROWS for a tile arriving by hand ------
+    /**
+     * The rows a nested GROW board asks its parent for (the grid binder's D4
+     * loop, one at a time). Measured live on 0.4.70: the fluid demo's
+     * Operations section refused a widget in split mode and the line beside it
+     * answered — a pane could not ask for rows. A pane's height is a share of
+     * its COLUMN, so the row comes from the divider above or below it: the
+     * pane's subtree in the nearest column ancestor grows by one row's pixels
+     * and that sibling gives them (never below the divider's floor — then the
+     * ask is refused, as a full grid parent refuses). The grown tree is painted
+     * live, so the section's frame follows and its board can take the tile;
+     * the commit is this board's own tree command, handed back for the
+     * arriving board's `finalize` to carry; a negative ask gives the rows
+     * back, and at zero the persisted tree paints again, exactly.
+     */
+    let grown = null;
+    class GrownTreeCommand extends SetSplitTreeCommand {
+        execute(context) {
+            super.execute(context);
+            grown = null;
+            if (!disposed)
+                project(readTree());
+            api.render();
+        }
+        undo(context) {
+            super.undo(context);
+            grown = null;
+            if (!disposed)
+                project(readTree());
+            api.render();
+        }
+    }
+    const resizePaneBy = (id, dRows) => {
+        var _a;
+        if (disposed || isStatic || !Number.isFinite(dRows) || dRows === 0)
+            return { changed: false };
+        const base = (grown === null || grown === void 0 ? void 0 : grown.id) === id ? grown.base : readTree();
+        if (!base)
+            return { changed: false };
+        const rowsNow = (grown === null || grown === void 0 ? void 0 : grown.id) === id ? grown.rows : 0;
+        const rowsNext = rowsNow + dRows;
+        const paintFor = (tree) => {
+            project(tree !== null && tree !== void 0 ? tree : readTree());
+            api.render();
+        };
+        const frameOf = (tree) => rectsOf(tree).get(id);
+        const cellOf = (tree) => cellsFromSplit(tree, columns, rowsGuess()).get(id);
+        if (rowsNext <= 0) {
+            // every row given back: the persisted tree, exactly
+            const before = (_a = grown === null || grown === void 0 ? void 0 : grown.tree) !== null && _a !== void 0 ? _a : base;
+            grown = null;
+            paintFor(null);
+            const fb = frameOf(before);
+            const fa = frameOf(base);
+            const cb = cellOf(before);
+            const ca = cellOf(base);
+            return rowsNow > 0 && fb && fa && cb && ca ? { changed: true, cellBefore: cb, cellAfter: ca, frameBefore: fb, frameAfter: fa } : { changed: false };
+        }
+        const path = pathToLeaf(base, id);
+        if (!path)
+            return { changed: false };
+        // the nearest COLUMN ancestor: the pane's subtree there is what grows
+        let groupPath = null;
+        let childIndex = -1;
+        for (let depth = path.length - 1; depth >= 0 && !groupPath; depth--) {
+            const gp = path.slice(0, depth);
+            const g = nodeAt(base, gp);
+            if (isSplitGroup(g) && g.dir === 'column' && g.children.length > 1) {
+                groupPath = gp;
+                childIndex = path[depth];
+            }
+        }
+        if (!groupPath)
+            return { changed: false }; // the pane already spans the board's height: nobody to take a row from
+        const group0 = nodeAt(base, groupPath);
+        if (!isSplitGroup(group0))
+            return { changed: false };
+        const key = groupPath.join('/');
+        const divider = dividersOf(base, frame(), gap, padding, rtl).find((d) => d.path.join('/') === key);
+        if (!divider || divider.length <= 0)
+            return { changed: false };
+        const px = rowsNext * (baseRowHeight + gap);
+        const fraction = px / divider.length;
+        const last = childIndex === group0.children.length - 1;
+        const tree = moveSplitDivider(base, groupPath, last ? childIndex - 1 : childIndex, last ? -fraction : fraction);
+        const fb = frameOf((grown === null || grown === void 0 ? void 0 : grown.id) === id ? grown.tree : base);
+        const f0 = frameOf(base);
+        const fa = frameOf(tree);
+        const cb = cellOf((grown === null || grown === void 0 ? void 0 : grown.id) === id ? grown.tree : base);
+        const ca = cellOf(tree);
+        if (!fb || !f0 || !fa || !cb || !ca)
+            return { changed: false };
+        if (fa.height < f0.height + px - 1)
+            return { changed: false }; // the sibling has no row to give (the divider's floor)
+        grown = { id, base, tree, rows: rowsNext };
+        paintFor(tree);
+        return { changed: true, cellBefore: cb, cellAfter: ca, frameBefore: fb, frameAfter: fa, commands: [new GrownTreeCommand(group.id, base, normalizeSplit(tree))] };
+    };
     // -- a11y -------------------------------------------------------------------
     const nameOf = (id) => {
         var _a, _b, _c, _d;
@@ -760,7 +1007,7 @@ export function bindDashboardSplit(api, group, options = {}) {
         api.render();
     };
     const onToolMove = (ev) => {
-        var _a, _b, _c, _d, _e;
+        var _a, _b;
         const g = gesture;
         if (!g || g.kind === 'palette')
             return;
@@ -801,53 +1048,7 @@ export function bindDashboardSplit(api, group, options = {}) {
         const inside = worldInsideBoard(ev.world.x, ev.world.y);
         const prev = prevWorld;
         prevWorld = { x: ev.world.x, y: ev.world.y };
-        const z = tileZone(g, ev, prev);
-        let t = null;
-        if (z.kind === 'strip') {
-            // -- INTO A STRIP: the strip marks the slot; nothing else is painted.
-            endLeg(g);
-            g.beside = null;
-            if (!g.strip || g.strip.containerId !== z.containerId || g.strip.index !== z.index)
-                (_b = options.tabDrop) === null || _b === void 0 ? void 0 : _b.markDrop(z.containerId, z.index);
-            g.strip = { containerId: z.containerId, index: z.index };
-        }
-        else {
-            endStrip(g);
-            const peer = z.kind === 'plain' ? (_c = z.board.ref) !== null && _c !== void 0 ? _c : null : null;
-            if (z.kind === 'beside') {
-                // -- BESIDE a container: a pane on that side of it — the split board's own line.
-                endLeg(g);
-                const grp = diagram.getGroup(z.containerId);
-                const rect = (_d = rectsOf(g.liveTree).get(z.containerId)) !== null && _d !== void 0 ? _d : (grp ? frameOfGroupW(grp) : null);
-                if (rect) {
-                    g.beside = z.kept && g.beside ? g.beside : { containerId: z.containerId, side: z.side, frame0: rect };
-                    t = { id: z.containerId, side: z.side, rect };
-                }
-            }
-            else if (peer && peer !== selfPeerRef) {
-                // -- INTO a nested board (a page, a section) — or out onto the board
-                // that holds this one: that board holds the widget through a leg and
-                // paints its own placeholder. A board that refuses (full, fit) leaves
-                // the split rule to answer.
-                g.beside = null;
-                if (g.leg && g.leg.peer !== peer)
-                    endLeg(g);
-                if (!g.leg) {
-                    const adopted = peer.adopt({ id: g.id }, ev.world, pxSizeOf(g), {});
-                    if (adopted)
-                        g.leg = { peer, adopted };
-                }
-                if (g.leg)
-                    g.leg.adopted.move(ev.world);
-                else
-                    t = inside ? dropTargetAt(g.liveTree, ev.world.x, ev.world.y, g.id) : null;
-            }
-            else {
-                g.beside = null;
-                endLeg(g);
-                t = inside ? dropTargetAt(g.liveTree, ev.world.x, ev.world.y, g.id) : null;
-            }
-        }
+        const t = zoneTarget(g, tileZone(g, ev, prev), ev.world, inside, pxSizeOf(g));
         g.target = t ? targetOf(t) : null;
         showInsertion(t ? insertionRect(t.rect, t.side) : null);
         const out = !inside &&
@@ -857,7 +1058,7 @@ export function bindDashboardSplit(api, group, options = {}) {
             options.dragOut === 'remove' &&
             (!options.removeZone || options.removeZone({ x: ev.screen.x, y: ev.screen.y }, { x: ev.world.x, y: ev.world.y }));
         g.out = out;
-        (_e = g.hostEl) === null || _e === void 0 ? void 0 : _e.classList.toggle('axdb-out', out);
+        (_b = g.hostEl) === null || _b === void 0 ? void 0 : _b.classList.toggle('axdb-out', out);
         api.render();
     };
     const onToolUp = () => {
@@ -1553,6 +1754,11 @@ export function bindDashboardSplit(api, group, options = {}) {
             window.removeEventListener('pointermove', onMove, true);
             window.removeEventListener('pointerup', onUp, true);
         };
+        // The chip's size in this board's units — what a page or a section that
+        // adopts it makes its tile from (the grid board does the same, 0.4.53).
+        const f0 = frame();
+        const colW0 = Math.max(1, (f0.width - 2 * padding - (columns - 1) * gap) / columns);
+        const chipPx = { width: Math.max(1, spec.w * (colW0 + gap) - gap), height: Math.max(1, spec.h * (baseRowHeight + gap) - gap) };
         const onMove = (e) => {
             if (gesture !== g)
                 return detach();
@@ -1561,19 +1767,39 @@ export function bindDashboardSplit(api, group, options = {}) {
                 chip.style.top = `${e.clientY + 6}px`;
             }
             const w = toWorld(e.clientX, e.clientY);
-            const t = worldInsideBoard(w.x, w.y) ? dropTargetAt(g.liveTree, w.x, w.y) : null;
+            const inside = worldInsideBoard(w.x, w.y);
+            // Through the zones (0.4.70): a page or a section takes the chip through
+            // a leg and shows its own placeholder; a container's band means a pane
+            // beside it; a chip never becomes a tab (the grid's rule too).
+            const ev = { type: 'move', world: w, screen: { x: e.clientX, y: e.clientY }, modifiers: { shift: false, ctrl: false, alt: false, meta: false } };
+            const t = zoneTarget(g, tileZone(g, ev, null), w, inside, chipPx);
             g.target = t ? targetOf(t) : null;
             showInsertion(t ? insertionRect(t.rect, t.side) : null);
-            chip === null || chip === void 0 ? void 0 : chip.classList.toggle('axdb-out', !t && !!g.liveTree);
+            chip === null || chip === void 0 ? void 0 : chip.classList.toggle('axdb-out', !t && !g.leg && !!g.liveTree);
             api.render();
         };
         const onUp = () => {
-            var _a, _b;
+            var _a, _b, _c;
             detach();
             if (gesture !== g)
                 return;
             gesture = null;
             teardownGesture(g);
+            if (g.leg) {
+                // Dropped into another board (a page, a section): its leg closes with
+                // that board's displaced tiles; this tree is untouched.
+                const leg = g.leg;
+                g.leg = null;
+                const fin = leg.adopted.finalize();
+                if (!fin) {
+                    api.renderNow();
+                    fire({ type: 'cancel', kind: 'palette', nodeId: node.id, changed: false });
+                    return;
+                }
+                void ((_a = options.onDropIn) === null || _a === void 0 ? void 0 : _a.call(options, node, fin.cell, fin.commands, { boardId: leg.adopted.groupId }));
+                fire({ type: 'drop-in', kind: 'palette', nodeId: node.id, changed: true });
+                return;
+            }
             const tree = g.liveTree;
             const after = g.target
                 ? insertSplitLeaf(tree, node.id, targetRef(g.target), g.target.side)
@@ -1586,9 +1812,9 @@ export function bindDashboardSplit(api, group, options = {}) {
                 return;
             }
             const cells = cellsFromSplit(after, columns, rowsGuess());
-            const cell = (_a = cells.get(node.id)) !== null && _a !== void 0 ? _a : { x: 0, y: 0, w: Math.max(1, spec.w), h: Math.max(1, spec.h) };
+            const cell = (_b = cells.get(node.id)) !== null && _b !== void 0 ? _b : { x: 0, y: 0, w: Math.max(1, spec.w), h: Math.max(1, spec.h) };
             const displaced = [new SetSplitTreeCommand(group.id, tree, normalizeSplit(after))];
-            void ((_b = options.onDropIn) === null || _b === void 0 ? void 0 : _b.call(options, node, cell, displaced, { boardId: group.id }));
+            void ((_c = options.onDropIn) === null || _c === void 0 ? void 0 : _c.call(options, node, cell, displaced, { boardId: group.id }));
             fire({ type: 'drop-in', kind: 'palette', nodeId: node.id, changed: true });
         };
         window.addEventListener('pointermove', onMove, true);
@@ -1997,7 +2223,8 @@ export function bindDashboardSplit(api, group, options = {}) {
         },
         hasItem: (id) => { var _a; return ((_a = group.members) !== null && _a !== void 0 ? _a : new Set()).has(id); },
         memberCell: (id) => handle.cellOf(id),
-        resizeMemberBy: () => ({ changed: false }),
+        // A section pane grows a row for a tile arriving by hand (D4 on a split board, 0.4.71) — see resizePaneBy.
+        resizeMemberBy: (id, dRows) => resizePaneBy(id, dRows),
         // A torn-out page becomes a PANE (0.4.37) — see beginTearOut.
         tearOutMember: (pageId, fromGroupId, ev, plan) => beginTearOut(pageId, fromGroupId, ev, plan),
         // A tab group (or a section) moved by its strip's empty space becomes a
@@ -2009,7 +2236,8 @@ export function bindDashboardSplit(api, group, options = {}) {
             const f = frame();
             return f.width * f.height;
         },
-        adopt: () => null,
+        // A tile from another board lands as a PANE where the line shows (0.4.70) — see adoptPane.
+        adopt: (node, world, _px, opts) => adoptPane(node, world, opts),
     };
     const unregisterPeer = registerBoardPeer(api.container, selfPeer);
     selfPeerRef = selfPeer;