@unofficialbox/box-open-elements 0.31.1 → 0.32.0

package/dist/patterns/process-modeler/process-modeler.js

@@ -74,7 +74,9 @@ export class ProcessModeler extends BaseElement {
     activeDrawer;
     drawerReturn;
     selectedIds = new Set();
-    clipboardIds = [];
+    clipboard = null;
+    clipboardSession = 0;
+    restoringBoxFocus = false;
     selectionToolbarKey = "";
     sectionSequence = 0;
     versionValue = 0;
@@ -99,6 +101,14 @@ export class ProcessModeler extends BaseElement {
     spacePressed = false;
     dropLine;
     paletteDragKind = null;
+    palettePointer;
+    suppressPaletteClick = false;
+    escapePalettePointer = (event) => {
+        if (event.key !== 'Escape' || !this.palettePointer)
+            return;
+        this.cancelPalettePointer();
+        event.preventDefault();
+    };
     narrowValue = false;
     suppressClick = false;
     resizeObserver;
@@ -157,6 +167,7 @@ export class ProcessModeler extends BaseElement {
         };
     }
     load(document, options = {}) {
+        this.cancelPalettePointer();
         const projection = this.model.project(document);
         validateProjection(projection);
         this.documentValue = document;
@@ -170,7 +181,7 @@ export class ProcessModeler extends BaseElement {
         this.selectedId = null;
         this.selectedLineId = null;
         this.selectedIds.clear();
-        this.clipboardIds = [];
+        this.clearClipboard();
         this.refresh();
         if (options.selectedPath)
             this.selectedPath = options.selectedPath;
@@ -259,6 +270,8 @@ export class ProcessModeler extends BaseElement {
     }
     set locked(value) {
         this.toggleAttribute("locked", value);
+        if (value)
+            this.cancelPalettePointer();
     }
     get snapToGrid() {
         return this.hasAttribute("snap-to-grid");
@@ -281,6 +294,8 @@ export class ProcessModeler extends BaseElement {
     }
     disconnectedCallback() {
         this.resizeObserver?.disconnect();
+        this.clearClipboard();
+        this.cancelPalettePointer();
         this.closeDrawer();
         const chooser = this.shadowRoot?.querySelector("[part=insert-chooser]");
         if (chooser)
@@ -341,56 +356,85 @@ export class ProcessModeler extends BaseElement {
     setValidationAtPath(message, path) {
         this.setValidation(message ? [{ message, path }] : []);
     }
+    connectionProblem(edit) {
+        if (!this.model.connectionProblem || this.documentValue === undefined || !['connect', 'reattach'].includes(edit.type))
+            return null;
+        if (!this.isRendered) {
+            this.projection = this.model.project(this.documentValue);
+            validateProjection(this.projection);
+        }
+        const line = edit.type === 'reattach' ? this.projection.lines.find(line => line.id === edit.lineId) : undefined;
+        const from = edit.from ?? line?.from;
+        const to = edit.to ?? line?.to;
+        if (!from || !to)
+            return null;
+        return this.model.connectionProblem(this.documentValue, { from, to, ...(line ? { ignoreLineId: line.id } : {}) }, this.projection) || null;
+    }
     requestEdit(edit) {
         if (this.locked || (this.disableConnections && (edit.type === "connect" || edit.type === "disconnect" || edit.type === 'reattach')))
             return;
+        const problem = this.connectionProblem(edit);
+        if (problem) {
+            this.setStatus(problem, true);
+            return;
+        }
+        const request = { ...edit, accept: this.editAcceptance(edit) };
+        emit(this, "process-edit-request", request);
+    }
+    editAcceptance(edit) {
         const before = this.layout;
+        const beforeSelection = [...this.selectedIds];
         const previousIds = new Set(this.projection.boxes.map((box) => box.id));
         let accepted = false;
-        const request = {
-            ...edit,
-            accept: (command) => {
-                if (accepted)
-                    return;
-                accepted = true;
-                if (command.layout)
-                    this.layoutValue = structuredClone(command.layout);
-                this.refresh();
-                const inserted = edit.type === 'insert' && !edit.boxId && !command.layout
-                    ? this.projection.boxes.find(box => !previousIds.has(box.id)) : undefined;
-                const reflowed = inserted ? this.reflowStraightInsert(edit, inserted.id, before) : false;
-                if (!reflowed &&
-                    !command.layout &&
-                    edit.position &&
-                    Number.isFinite(edit.position.x) &&
-                    Number.isFinite(edit.position.y)) {
-                    const added = this.projection.boxes.find(box => box.id === edit.boxId) ?? this.projection.boxes.find((box) => !previousIds.has(box.id));
-                    if (added)
-                        this.layoutValue = this.translatedLayout(added.id, edit.position.x, edit.position.y);
-                }
-                const after = this.layout;
-                const restore = (layout) => {
-                    this.layoutValue = structuredClone(layout);
-                    this.refresh();
-                    this.emitPositions();
-                };
-                this.history.record({
-                    undo: () => {
-                        command.undo();
-                        restore(before);
-                    },
-                    redo: () => {
-                        command.redo();
-                        restore(after);
-                    },
-                });
+        return (command) => {
+            if (accepted)
+                return;
+            accepted = true;
+            if (command.layout)
+                this.layoutValue = structuredClone(command.layout);
+            if (edit.type === 'reset-line' && edit.lineId)
+                delete this.layoutValue.lines?.[edit.lineId];
+            this.refresh();
+            const inserted = edit.type === 'insert' && !edit.boxId && !command.layout
+                ? this.projection.boxes.find(box => !previousIds.has(box.id)) : undefined;
+            const reflowed = inserted ? this.reflowStraightInsert(edit, inserted.id, before) : false;
+            if (!reflowed &&
+                !command.layout &&
+                edit.position &&
+                Number.isFinite(edit.position.x) &&
+                Number.isFinite(edit.position.y)) {
+                const added = this.projection.boxes.find(box => box.id === edit.boxId) ?? this.projection.boxes.find((box) => !previousIds.has(box.id));
+                if (added)
+                    this.layoutValue = this.translatedLayout(added.id, edit.position.x, edit.position.y);
+            }
+            const after = this.layout;
+            const acceptedSelection = command.selectionIds ? [...command.selectionIds] : undefined;
+            const restore = (layout) => {
+                this.layoutValue = structuredClone(layout);
                 this.refresh();
-                if (JSON.stringify(before) !== JSON.stringify(after))
-                    this.emitPositions();
-                announce("Process updated", "polite", this.ownerDocument);
-            },
+                this.emitPositions();
+            };
+            this.history.record({
+                undo: () => {
+                    command.undo();
+                    restore(before);
+                    if (acceptedSelection)
+                        this.selectMany(beforeSelection);
+                },
+                redo: () => {
+                    command.redo();
+                    restore(after);
+                    if (acceptedSelection)
+                        this.selectMany(acceptedSelection);
+                },
+            });
+            if (acceptedSelection)
+                this.selectMany(acceptedSelection);
+            this.refresh();
+            if (JSON.stringify(before) !== JSON.stringify(after))
+                this.emitPositions();
+            announce("Process updated", "polite", this.ownerDocument);
         };
-        emit(this, "process-edit-request", request);
     }
     undo() {
         if (this.locked)
@@ -541,6 +585,13 @@ export class ProcessModeler extends BaseElement {
         });
     }
     resetLine(id) {
+        const line = this.projection.lines.find(line => line.id === id);
+        if (this.locked || !line)
+            return;
+        if (line.fromSide || line.toSide || line.points?.length) {
+            this.requestEdit({ type: 'reset-line', lineId: id });
+            return;
+        }
         if (!this.layoutValue.lines?.[id])
             return;
         const next = this.layout;
@@ -763,7 +814,7 @@ export class ProcessModeler extends BaseElement {
         palette.prepend(skip, paletteHeading);
         const hint = document.createElement("p");
         hint.setAttribute("part", "palette-hint");
-        hint.textContent = "Drag onto the canvas, a connection, or a frame. Select a step first to add after it.";
+        hint.textContent = "Drag onto the canvas, onto a line to insert, or into a frame. Choosing one with a step selected adds it after that step. Or click a dot beside any step to add one that way.";
         palette.append(hint);
         for (const [part, label] of [["palette", "Building blocks"], ["inspector", "Process details"]]) {
             const pane = root.querySelector(`[part=${part}]`);
@@ -864,6 +915,12 @@ export class ProcessModeler extends BaseElement {
         controls.setAttribute("role", "toolbar");
         controls.setAttribute("aria-label", "Canvas view controls");
         for (const command of ["zoom-out", "reset", "zoom-in", "fit", "snap", "lock"]) {
+            if (command === 'snap') {
+                const divider = document.createElement('span');
+                divider.setAttribute('part', 'controls-divider');
+                divider.setAttribute('aria-hidden', 'true');
+                controls.append(divider);
+            }
             const button = root.querySelector(`[data-command=${command}]`);
             if (button)
                 controls.append(button);
@@ -896,6 +953,7 @@ export class ProcessModeler extends BaseElement {
                 this.narrowValue = narrow;
                 this.toggleAttribute("data-narrow", narrow);
                 this.toggleAttribute('data-phone', entries[0].contentRect.width < 560);
+                this.toggleAttribute('data-hide-tidy', entries[0].contentRect.width <= 560);
                 this.renderSelectionToolbar();
                 this.positionSelectionToolbar();
                 if (!narrow)
@@ -1152,6 +1210,12 @@ export class ProcessModeler extends BaseElement {
             emit(this, 'process-variable-edit-request', edit);
         }
     }
+    selectionDimensions(box) {
+        const shape = box.shape ?? this.catalog.find(kind => kind.kind === box.kind)?.shape;
+        const compact = shape === 'gateway' || shape === 'event';
+        const position = this.layoutValue.boxes[box.id];
+        return { width: position.width ?? (compact ? 56 : 224), height: position.height ?? (compact ? 56 : 64) };
+    }
     selectionCommand(command) {
         if (this.locked)
             return;
@@ -1165,7 +1229,10 @@ export class ProcessModeler extends BaseElement {
             this.tidySelection();
             return;
         }
-        this.arrangeSelection('top');
+        const rectangles = boxes.map(box => ({ ...this.layoutValue.boxes[box.id], ...this.selectionDimensions(box) }));
+        const width = Math.max(...rectangles.map(r => r.x + r.width)) - Math.min(...rectangles.map(r => r.x));
+        const height = Math.max(...rectangles.map(r => r.y + r.height)) - Math.min(...rectangles.map(r => r.y));
+        this.arrangeSelection(width >= height ? 'middle' : 'center');
     }
     tidySelection() {
         if (this.locked || this.selectedBoxes.length < 2)
@@ -1234,20 +1301,62 @@ export class ProcessModeler extends BaseElement {
         });
         if (sorted.length < 2)
             return;
-        const width = (box) => next.boxes[box.id].width ?? (box.shape === 'gateway' || box.shape === 'event' ? 56 : 224);
-        const height = (box) => next.boxes[box.id].height ?? (box.shape === 'gateway' || box.shape === 'event' ? 56 : 64);
+        const width = (box) => this.selectionDimensions(box).width;
+        const height = (box) => this.selectionDimensions(box).height;
         const minX = Math.min(...sorted.map(box => next.boxes[box.id].x));
         const maxX = Math.max(...sorted.map(box => next.boxes[box.id].x + width(box)));
         const minY = Math.min(...sorted.map(box => next.boxes[box.id].y));
         const maxY = Math.max(...sorted.map(box => next.boxes[box.id].y + height(box)));
-        const ordered = [...sorted].sort((a, b) => action === 'distribute-vertical' ? next.boxes[a.id].y - next.boxes[b.id].y : next.boxes[a.id].x - next.boxes[b.id].x);
-        const starts = ordered.map(box => action === 'distribute-vertical' ? next.boxes[box.id].y : next.boxes[box.id].x);
+        const snap = (value) => Math.round(value / 16) * 16;
+        const targets = new Map(sorted.map(box => [box.id, { x: next.boxes[box.id].x, y: next.boxes[box.id].y }]));
+        const vertical = action === 'distribute-vertical';
+        if (action === 'distribute-horizontal' || vertical) {
+            if (sorted.length < 3)
+                return;
+            const axis = vertical ? 'y' : 'x';
+            const size = vertical ? height : width;
+            const ordered = [...sorted].sort((a, b) => targets.get(a.id)[axis] - targets.get(b.id)[axis]);
+            const first = targets.get(ordered[0].id)[axis];
+            const last = targets.get(ordered.at(-1).id)[axis] + size(ordered.at(-1));
+            const gap = (last - first - ordered.reduce((total, box) => total + size(box), 0)) / (ordered.length - 1);
+            let position = first + size(ordered[0]) + gap;
+            for (const box of ordered.slice(1, -1)) {
+                targets.get(box.id)[axis] = position;
+                position += size(box) + gap;
+            }
+        }
+        else {
+            for (const box of sorted) {
+                const target = targets.get(box.id);
+                if (action === 'left')
+                    target.x = minX;
+                if (action === 'center')
+                    target.x = snap((minX + maxX) / 2) - width(box) / 2;
+                if (action === 'right')
+                    target.x = maxX - width(box);
+                if (action === 'top')
+                    target.y = minY;
+                if (action === 'middle')
+                    target.y = snap((minY + maxY) / 2) - height(box) / 2;
+                if (action === 'bottom')
+                    target.y = maxY - height(box);
+            }
+            if (action === 'middle' || action === 'center') {
+                const axis = action === 'middle' ? 'x' : 'y';
+                const size = action === 'middle' ? width : height;
+                const ordered = [...sorted].sort((a, b) => targets.get(a.id)[axis] - targets.get(b.id)[axis]);
+                for (let index = 1; index < ordered.length; index++) {
+                    const previous = ordered[index - 1], box = ordered[index];
+                    const minimum = targets.get(previous.id)[axis] + size(previous) + 48;
+                    const target = targets.get(box.id);
+                    if (target[axis] < minimum)
+                        target[axis] += snap(minimum - target[axis] + 8);
+                }
+            }
+        }
         for (const box of sorted) {
-            const position = next.boxes[box.id];
-            const index = ordered.indexOf(box);
-            const x = action === 'left' ? minX : action === 'center' ? (minX + maxX - width(box)) / 2 : action === 'right' ? maxX - width(box) : action === 'distribute-horizontal' ? starts[0] + index * (starts.at(-1) - starts[0]) / (ordered.length - 1) : position.x;
-            const y = action === 'top' ? minY : action === 'middle' ? (minY + maxY - height(box)) / 2 : action === 'bottom' ? maxY - height(box) : action === 'distribute-vertical' ? starts[0] + index * (starts.at(-1) - starts[0]) / (ordered.length - 1) : position.y;
-            const dx = x - position.x, dy = y - position.y;
+            const position = next.boxes[box.id], target = targets.get(box.id);
+            const dx = target.x - position.x, dy = target.y - position.y;
             const group = new Set([box.id]);
             for (let changed = true; changed;) {
                 changed = false;
@@ -1275,6 +1384,16 @@ export class ProcessModeler extends BaseElement {
         this.setSection({ id, title, x, y, width: right - x, height: bottom - y });
     }
     setupListeners() {
+        this.addEventListener('pointermove', event => this.movePalettePointer(event));
+        this.addEventListener('pointerup', event => this.finishPalettePointer(event));
+        this.addEventListener('pointercancel', event => { if (event.pointerId === this.palettePointer?.id)
+            this.cancelPalettePointer(); });
+        this.addEventListener('lostpointercapture', event => { if (event.pointerId === this.palettePointer?.id)
+            this.cancelPalettePointer(); });
+        this.shadowRoot.addEventListener('keydown', event => { if (event.key === 'Escape' && this.palettePointer) {
+            this.cancelPalettePointer();
+            event.preventDefault();
+        } }, true);
         this.shadowRoot.addEventListener("click", (event) => {
             const command = event.target.closest("button")?.dataset.command;
             if (command === "zoom-in")
@@ -1404,6 +1523,92 @@ export class ProcessModeler extends BaseElement {
             this.paintViewport();
         });
     }
+    clearClipboard() {
+        const previous = this.clipboard;
+        this.clipboard = null;
+        this.clipboardSession++;
+        previous?.dispose?.();
+    }
+    copySelection() {
+        this.clearClipboard();
+        const session = this.clipboardSession;
+        let active = true;
+        let claimed = false;
+        const request = {
+            sourceIds: Object.freeze([...this.selectedIds]),
+            capture: clipboard => {
+                if (!active || claimed || session !== this.clipboardSession || !this.isConnected)
+                    return;
+                claimed = true;
+                if (!Number.isInteger(clipboard?.itemCount) || clipboard.itemCount < 1 || typeof clipboard.paste !== 'function' || (clipboard.dispose !== undefined && typeof clipboard.dispose !== 'function')) {
+                    this.setStatus('The host did not supply a valid clipboard');
+                    return;
+                }
+                this.clipboard = Object.freeze({ itemCount: clipboard.itemCount, paste: clipboard.paste.bind(clipboard), ...(clipboard.dispose ? { dispose: clipboard.dispose.bind(clipboard) } : {}) });
+                this.setStatus(`${clipboard.itemCount} steps copied`);
+            },
+            refuse: message => { if (!active || claimed || session !== this.clipboardSession || !this.isConnected)
+                return; claimed = true; this.setStatus(message ?? 'Copy is not supported by this host'); },
+        };
+        try {
+            emit(this, 'process-copy-request', request);
+        }
+        finally {
+            active = false;
+        }
+        if (!claimed && session === this.clipboardSession && this.isConnected)
+            this.setStatus('Copy is not supported by this host');
+        return claimed;
+    }
+    pasteClipboard() {
+        const clipboard = this.clipboard;
+        if (!clipboard || this.locked)
+            return;
+        const session = this.clipboardSession;
+        const accept = this.editAcceptance({ type: 'duplicate' });
+        let active = true;
+        let settled = false;
+        const request = {
+            offset: Object.freeze({ x: 32, y: 32 }),
+            accept: command => {
+                if (!active || settled || session !== this.clipboardSession || this.locked)
+                    return;
+                settled = true;
+                accept(command);
+            },
+            refuse: message => { if (!active || settled || session !== this.clipboardSession || !this.isConnected)
+                return; settled = true; this.setStatus(message ?? 'Paste was refused by this host'); },
+        };
+        try {
+            clipboard.paste(request);
+        }
+        finally {
+            active = false;
+        }
+        if (!settled && session === this.clipboardSession)
+            this.setStatus('Paste was not accepted by this host');
+    }
+    duplicateBoxes(ids, distance) {
+        const selected = new Set(ids);
+        if (!selected.size || [...selected].some(id => !this.projection.boxes.some(box => box.id === id) || !this.layoutValue.boxes[id]))
+            return;
+        const sources = [...selected].filter(id => {
+            let parent = this.projection.boxes.find(box => box.id === id)?.parentId;
+            while (parent) {
+                if (selected.has(parent))
+                    return false;
+                parent = this.projection.boxes.find(box => box.id === parent)?.parentId;
+            }
+            return true;
+        });
+        if (sources.length === 1) {
+            const position = this.layoutValue.boxes[sources[0]];
+            this.requestEdit({ type: 'duplicate', sourceId: sources[0], position: { x: position.x + distance, y: position.y + distance } });
+        }
+        else {
+            this.requestEdit({ type: 'duplicate', sourceIds: sources, offset: { x: distance, y: distance } });
+        }
+    }
     onKey(event) {
         if (event.defaultPrevented)
             return;
@@ -1432,20 +1637,18 @@ export class ProcessModeler extends BaseElement {
             return;
         }
         if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === 'c' && this.selectedIds.size) {
-            event.preventDefault();
-            this.clipboardIds = [...this.selectedIds];
-            this.setStatus(`${this.clipboardIds.length} steps copied`);
+            if (this.copySelection())
+                event.preventDefault();
             return;
         }
-        if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === 'v' && this.clipboardIds.length && !this.locked) {
+        if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === 'v' && this.clipboard && !this.locked) {
             event.preventDefault();
-            this.clipboardIds.forEach((id, index) => { const position = this.layoutValue.boxes[id]; if (position)
-                this.requestEdit({ type: 'duplicate', sourceId: id, position: { x: position.x + 32 * (index + 1), y: position.y + 32 * (index + 1) } }); });
+            this.pasteClipboard();
             return;
         }
         if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === 'd' && this.selectedIds.size && !this.locked) {
             event.preventDefault();
-            [...this.selectedIds].forEach(id => { const position = this.layoutValue.boxes[id]; this.requestEdit({ type: 'duplicate', sourceId: id, position: { x: position.x + 32, y: position.y + 32 } }); });
+            this.duplicateBoxes([...this.selectedIds], 48);
             return;
         }
         if (event.key === "Escape") {
@@ -1455,6 +1658,7 @@ export class ProcessModeler extends BaseElement {
             if (this.selectedLineId)
                 this.selectLine(null);
             this.portDrag = undefined;
+            this.endDrag = undefined;
             this.marquee = undefined;
             this.segmentDrag = undefined;
             this.drag = undefined;
@@ -1481,6 +1685,18 @@ export class ProcessModeler extends BaseElement {
             this.openKeyboardChooser(box);
             return;
         }
+        const direction = {
+            ArrowLeft: [-1, 0],
+            ArrowRight: [1, 0],
+            ArrowUp: [0, -1],
+            ArrowDown: [0, 1],
+        }[event.key];
+        const canInsertDirection = event.ctrlKey && event.altKey && box && !this.locked && this.catalog.length && !this.disableConnections;
+        if (direction && !canInsertDirection && (event.altKey || !box || this.locked)) {
+            event.preventDefault();
+            this.navigateSelection(direction);
+            return;
+        }
         if (!box || this.locked)
             return;
         if (event.key === "Enter") {
@@ -1509,12 +1725,6 @@ export class ProcessModeler extends BaseElement {
             event.preventDefault();
             this.selectionCommand("delete-many");
         }
-        const direction = {
-            ArrowLeft: [-1, 0],
-            ArrowRight: [1, 0],
-            ArrowUp: [0, -1],
-            ArrowDown: [0, 1],
-        }[event.key];
         if (direction) {
             event.preventDefault();
             if (event.ctrlKey && event.altKey && this.catalog.length && !this.disableConnections) {
@@ -1527,31 +1737,52 @@ export class ProcessModeler extends BaseElement {
                 this.openAnchoredChooser(this.nextEdit(box, side, { x: pos.x + direction[0] * 320, y: pos.y + direction[1] * 170 }), this.nextChooserTitle(box, side), anchor, returnFocus);
                 return;
             }
-            if (event.altKey) {
-                const origin = this.layoutValue.boxes[box.id];
-                const center = { x: origin.x + (origin.width ?? 224) / 2, y: origin.y + (origin.height ?? 64) / 2 };
-                const candidates = this.projection.boxes.filter(candidate => candidate.id !== box.id).map(candidate => {
-                    const position = this.layoutValue.boxes[candidate.id];
-                    const dx = position.x + (position.width ?? 224) / 2 - center.x;
-                    const dy = position.y + (position.height ?? 64) / 2 - center.y;
-                    const forward = dx * direction[0] + dy * direction[1];
-                    const sideways = Math.abs(dx * direction[1] - dy * direction[0]);
-                    return { candidate, forward, score: forward + sideways * 2 };
-                }).filter(item => item.forward > 0).sort((a, b) => a.score - b.score || a.candidate.id.localeCompare(b.candidate.id));
-                const next = candidates[0]?.candidate;
-                if (next) {
-                    this.select(next.id);
-                    this.focusBox(next.id);
-                    this.setStatus(`${next.title} selected`);
-                }
-                return;
-            }
             const pos = this.layoutValue.boxes[box.id];
             const distance = event.shiftKey ? 64 : 16;
             this.move(box.id, pos.x + direction[0] * distance, pos.y + direction[1] * distance);
             this.focusBox(box.id);
         }
     }
+    navigateSelection(direction) {
+        const canvas = this.shadowRoot.querySelector('[part=canvas]');
+        const box = this.selected;
+        const origin = box ? this.layoutValue.boxes[box.id] : undefined;
+        const originSize = box ? this.selectionDimensions(box) : undefined;
+        const center = origin && originSize
+            ? { x: origin.x + originSize.width / 2, y: origin.y + originSize.height / 2 }
+            : { x: (canvas.clientWidth / 2 - this.viewport.x) / this.viewport.zoom, y: (canvas.clientHeight / 2 - this.viewport.y) / this.viewport.zoom };
+        const candidates = this.projection.boxes.filter(candidate => candidate.id !== box?.id && candidate.kind !== 'section').map(candidate => {
+            const position = this.layoutValue.boxes[candidate.id];
+            const size = this.selectionDimensions(candidate);
+            const dx = position.x + size.width / 2 - center.x;
+            const dy = position.y + size.height / 2 - center.y;
+            const forward = dx * direction[0] + dy * direction[1];
+            const sideways = Math.abs(dx * direction[1] - dy * direction[0]);
+            return { candidate, forward, score: forward + sideways * 2.5 };
+        }).filter(item => item.forward > 4).sort((a, b) => a.score - b.score);
+        const next = candidates[0]?.candidate;
+        if (!next) {
+            this.setStatus('Nothing further that way');
+            return;
+        }
+        this.select(next.id);
+        this.revealBox(next);
+        this.focusBox(next.id);
+        this.setStatus(`${next.title} selected`);
+    }
+    revealBox(box) {
+        const canvas = this.shadowRoot.querySelector('[part=canvas]');
+        if (!canvas.clientWidth || !canvas.clientHeight)
+            return;
+        const position = this.layoutValue.boxes[box.id];
+        const size = this.selectionDimensions(box);
+        const left = position.x * this.viewport.zoom + this.viewport.x;
+        const top = position.y * this.viewport.zoom + this.viewport.y;
+        if (left > 48 && top > 48 && left + size.width * this.viewport.zoom < canvas.clientWidth - 48 && top + size.height * this.viewport.zoom < canvas.clientHeight - 48)
+            return;
+        this.setView({ x: canvas.clientWidth / 2 - (position.x + size.width / 2) * this.viewport.zoom,
+            y: canvas.clientHeight / 2 - (position.y + size.height / 2) * this.viewport.zoom, zoom: this.viewport.zoom });
+    }
     pointerDown(event) {
         if (event.button !== 0)
             return;
@@ -1655,10 +1886,12 @@ export class ProcessModeler extends BaseElement {
             const start = this.portDrag.start;
             ghost.setAttribute("points", `${start.x},${start.y} ${point.x},${start.y} ${point.x},${point.y}`);
             const target = this.boxAt(point, this.portDrag.id);
-            const pinned = target ? this.sideAt(target, point) : undefined;
-            this.shadowRoot.querySelectorAll('[data-box-id]').forEach(box => { box.dataset.connectTarget = String(box.dataset.boxId === target?.id); });
+            const problem = target ? this.connectionProblem({ type: 'connect', from: this.portDrag.id, to: target.id }) : null;
+            const pinned = target && !problem ? this.sideAt(target, point) : undefined;
+            ghost.dataset.invalid = String(Boolean(problem));
+            this.shadowRoot.querySelectorAll('[data-box-id]').forEach(box => { box.dataset.connectTarget = String(box.dataset.boxId === target?.id); box.dataset.connectInvalid = String(box.dataset.boxId === target?.id && Boolean(problem)); });
             this.shadowRoot.querySelectorAll('[part=port]').forEach(port => { port.dataset.hot = String(port.dataset.owner === target?.id && port.dataset.side === pinned); });
-            this.showConnectTooltip(point, target ? pinned ? `Pin to the ${pinned} of ${target.title}` : `Connect to ${target.title}` : 'Drop here to add a connected step');
+            this.showConnectTooltip(point, problem ?? (target ? pinned ? `Pin to the ${pinned} of ${target.title}` : `Connect to ${target.title}` : 'Drop here to add a connected step'), Boolean(problem));
             return;
         }
         if (this.endDrag) {
@@ -1674,11 +1907,13 @@ export class ProcessModeler extends BaseElement {
             if (fixed)
                 ghost.setAttribute('points', `${fixed.x},${fixed.y} ${point.x},${fixed.y} ${point.x},${point.y}`);
             const target = this.boxAt(point);
-            const pinned = target ? this.sideAt(target, point) : undefined;
-            this.shadowRoot.querySelectorAll('[data-box-id]').forEach(box => { box.dataset.connectTarget = String(box.dataset.boxId === target?.id); });
+            const problem = target ? this.connectionProblem({ type: 'reattach', lineId: this.endDrag.lineId, [this.endDrag.end]: target.id }) : null;
+            const pinned = target && !problem ? this.sideAt(target, point) : undefined;
+            ghost.dataset.invalid = String(Boolean(problem) || !target);
+            this.shadowRoot.querySelectorAll('[data-box-id]').forEach(box => { box.dataset.connectTarget = String(box.dataset.boxId === target?.id); box.dataset.connectInvalid = String(box.dataset.boxId === target?.id && Boolean(problem)); });
             this.shadowRoot.querySelectorAll('[part=port]').forEach(port => { port.dataset.hot = String(port.dataset.owner === target?.id && port.dataset.side === pinned); });
-            this.showConnectTooltip(point, target ? pinned ? `Pin to the ${pinned} of ${target.title}` : `Attach to ${target.title}` : 'Drop on a step to reattach', !target);
-            this.setStatus(target ? `Release to attach the connection to ${target.title}` : 'Move over a step to attach this connection');
+            this.showConnectTooltip(point, problem ?? (target ? pinned ? `Pin to the ${pinned} of ${target.title}` : `Attach to ${target.title}` : 'Drop on a step to reattach'), Boolean(problem) || !target);
+            this.setStatus(problem ?? (target ? `Release to attach the connection to ${target.title}` : 'Move over a step to attach this connection'));
             return;
         }
         if (this.segmentDrag) {
@@ -1777,7 +2012,7 @@ export class ProcessModeler extends BaseElement {
             this.portDrag = undefined;
             this.shadowRoot.querySelector('[part=connection-preview]')?.remove();
             this.shadowRoot.querySelector('[part=connect-tooltip]')?.remove();
-            this.shadowRoot.querySelectorAll('[data-connect-target]').forEach(box => { delete box.dataset.connectTarget; });
+            this.shadowRoot.querySelectorAll('[data-connect-target]').forEach(box => { delete box.dataset.connectTarget; delete box.dataset.connectInvalid; });
             this.shadowRoot.querySelectorAll('[part=port]').forEach(port => { delete port.dataset.hot; });
             if (commit) {
                 if (Math.hypot(point.x - port.start.x, point.y - port.start.y) < 8) {
@@ -1809,7 +2044,7 @@ export class ProcessModeler extends BaseElement {
             this.endDrag = undefined;
             this.shadowRoot.querySelector('[part=connection-preview]')?.remove();
             this.shadowRoot.querySelector('[part=connect-tooltip]')?.remove();
-            this.shadowRoot.querySelectorAll('[data-connect-target]').forEach(box => { delete box.dataset.connectTarget; });
+            this.shadowRoot.querySelectorAll('[data-connect-target]').forEach(box => { delete box.dataset.connectTarget; delete box.dataset.connectInvalid; });
             this.shadowRoot.querySelectorAll('[part=port]').forEach(port => { delete port.dataset.hot; });
             if (commit) {
                 if (Math.hypot(point.x - drag.start.x, point.y - drag.start.y) < 8) {
@@ -1925,6 +2160,9 @@ export class ProcessModeler extends BaseElement {
     }
     markDropLine(point, except) {
         this.dropLine = point ? this.lineAt(point, except)?.id : undefined;
+        this.paintDropLine();
+    }
+    paintDropLine() {
         this.shadowRoot.querySelectorAll('[part=line]').forEach(path => { const active = path.dataset.lineId === this.dropLine; path.dataset.drop = String(active); path.setAttribute('marker-end', `url(#${active || path.dataset.selected === 'true' ? 'boe-process-arrow-brand' : 'boe-process-arrow'})`); });
     }
     alignedPoint(id, x, y) {
@@ -2141,8 +2379,15 @@ export class ProcessModeler extends BaseElement {
         this.updateToolbar();
         if (selectionBefore !== JSON.stringify({ ids: [...this.selectedIds], path: this.selectedPath }))
             emit(this, "selection-changed", { box: this.selected, boxes: this.selectedBoxes, path: this.selectedPath });
-        if (focused)
-            this.focusBox(focused);
+        if (focused) {
+            this.restoringBoxFocus = true;
+            try {
+                this.focusBox(focused);
+            }
+            finally {
+                this.restoringBoxFocus = false;
+            }
+        }
     }
     get allChecks() { return this.computedChecks; }
     collectChecks() {
@@ -2171,6 +2416,13 @@ export class ProcessModeler extends BaseElement {
         for (const box of [...this.projection.boxes].sort((a, b) => Number(Boolean(b.frame)) - Number(Boolean(a.frame)))) {
             const element = document.createElement("div");
             element.tabIndex = 0;
+            element.addEventListener('focus', () => {
+                if (!this.restoringBoxFocus && !this.pointers.size && !this.portDrag && !this.endDrag && !this.segmentDrag && !this.marquee && !this.frameResize) {
+                    this.select(box.id);
+                    if (box.kind !== 'section')
+                        this.revealBox(box);
+                }
+            });
             element.setAttribute("role", "group");
             element.setAttribute("part", box.frame ? "frame" : "box");
             element.dataset.boxId = box.id;
@@ -2305,13 +2557,10 @@ export class ProcessModeler extends BaseElement {
             element.addEventListener("keydown", event => {
                 if (event.target !== element)
                     return;
-                if (event.key === " ") {
-                    event.preventDefault();
-                    element.click();
-                }
+                // Space reaches the canvas handler so holding it pans from a focused step.
                 // Let Enter reach the canvas handler after selecting the focused step.
                 // Cancelling it here prevents the editor from opening and taking focus.
-                else if (event.key === "Enter") {
+                if (event.key === "Enter") {
                     // Connection completion consumes Enter; it must not also edit the target.
                     if (this.connecting || this.pendingReattach)
                         event.preventDefault();
@@ -2346,6 +2595,7 @@ export class ProcessModeler extends BaseElement {
                 for (const side of ["north", "east", "south", "west"]) {
                     const port = document.createElement("button");
                     port.type = "button";
+                    port.tabIndex = -1;
                     port.setAttribute("part", "port");
                     port.dataset.side = side;
                     port.dataset.owner = box.id;
@@ -2551,6 +2801,145 @@ export class ProcessModeler extends BaseElement {
             height: `${position.height ?? 64}px`,
         });
     }
+    activatePaletteKind(kind) {
+        if (this.locked)
+            return;
+        if (this.narrowValue) {
+            this.closeDrawer();
+            this.shadowRoot.querySelector('[part=canvas]').focus({ preventScroll: true });
+        }
+        if (kind.placement) {
+            this.addLayoutKind(kind);
+            return;
+        }
+        const selected = this.selectedIds.size === 1 ? this.selected : null;
+        const from = selected && !selected.frame && selected.kind !== 'section' && !['end', 'finish'].includes(selected.kind) ? selected.id : undefined;
+        const outgoing = from ? this.projection.lines.filter(line => line.from === from) : [];
+        const line = outgoing.length === 1 ? outgoing[0] : undefined;
+        this.requestEdit(line ? { type: 'insert', kind, lineId: line.id, from: line.from, to: line.to } : { type: 'add', kind, ...(from ? { from } : {}) });
+    }
+    paletteLineAt(point) {
+        let nearest;
+        let best = 20 / this.viewport.zoom;
+        for (const line of this.projection.lines) {
+            const points = this.routedLines.get(line.id) ?? [];
+            for (let i = 1; i < points.length; i++) {
+                const a = points[i - 1], b = points[i], dx = b.x - a.x, dy = b.y - a.y, length = dx * dx + dy * dy;
+                const t = length ? Math.max(0, Math.min(1, ((point.x - a.x) * dx + (point.y - a.y) * dy) / length)) : 0;
+                const distance = Math.hypot(point.x - a.x - t * dx, point.y - a.y - t * dy);
+                if (distance < best) {
+                    best = distance;
+                    nearest = line;
+                }
+            }
+        }
+        return nearest;
+    }
+    paletteFrameAt(point) {
+        let nearest;
+        let depth = -1;
+        for (const box of this.projection.boxes) {
+            if (!box.frame)
+                continue;
+            const p = this.layoutValue.boxes[box.id];
+            if (!p)
+                continue;
+            const { width, height } = this.selectionDimensions(box);
+            if (point.x < p.x || point.x > p.x + width || point.y < p.y || point.y > p.y + height)
+                continue;
+            let level = 0, parent = box.parentId;
+            while (parent) {
+                level++;
+                parent = this.projection.boxes.find(box => box.id === parent)?.parentId;
+            }
+            if (level > depth) {
+                depth = level;
+                nearest = box;
+            }
+        }
+        return nearest;
+    }
+    markPaletteDrop(point) {
+        this.dropLine = point ? this.paletteLineAt(point)?.id : undefined;
+        const frame = point && !this.dropLine ? this.paletteFrameAt(point) : undefined;
+        this.shadowRoot.querySelectorAll('[part=frame]').forEach(element => { element.dataset.paletteDrop = String(element.dataset.boxId === frame?.id); });
+        this.paintDropLine();
+    }
+    paletteCanvasPoint(event) {
+        const rect = this.shadowRoot.querySelector('[part=canvas]').getBoundingClientRect();
+        if (event.clientX <= rect.left || event.clientX >= rect.right || event.clientY <= rect.top || event.clientY >= rect.bottom)
+            return;
+        return this.canvasPoint(event);
+    }
+    movePalettePointer(event) {
+        const drag = this.palettePointer;
+        if (!drag || drag.id !== event.pointerId)
+            return;
+        if (this.locked) {
+            this.cancelPalettePointer();
+            return;
+        }
+        if (!drag.moved && Math.hypot(event.clientX - drag.x, event.clientY - drag.y) < 5)
+            return;
+        if (!drag.moved) {
+            drag.moved = true;
+            if (this.narrowValue)
+                this.closeDrawer();
+        }
+        let ghost = this.shadowRoot.querySelector('[part=palette-ghost]');
+        if (!ghost) {
+            ghost = document.createElement('div');
+            ghost.setAttribute('part', 'palette-ghost');
+            ghost.dataset.pointer = 'true';
+            ghost.setAttribute('aria-hidden', 'true');
+            if (drag.kind.icon)
+                ghost.append(drag.kind.icon());
+            ghost.append(document.createTextNode(drag.kind.label));
+            this.shadowRoot.append(ghost);
+        }
+        ghost.style.left = `${event.clientX}px`;
+        ghost.style.top = `${event.clientY}px`;
+        this.markPaletteDrop(!drag.kind.placement && drag.kind.kind !== 'end' ? this.paletteCanvasPoint(event) : undefined);
+        event.preventDefault();
+    }
+    cancelPalettePointer() {
+        const drag = this.palettePointer;
+        this.palettePointer = undefined;
+        this.ownerDocument.removeEventListener('keydown', this.escapePalettePointer, true);
+        if (!drag)
+            return;
+        this.suppressPaletteClick = true;
+        this.shadowRoot?.querySelector('[part=palette-ghost]')?.remove();
+        this.markPaletteDrop(undefined);
+        try {
+            this.releasePointerCapture(drag.id);
+        }
+        catch { /* Capture may already have been lost. */ }
+    }
+    finishPalettePointer(event) {
+        const drag = this.palettePointer;
+        if (!drag || drag.id !== event.pointerId)
+            return;
+        const point = this.paletteCanvasPoint(event);
+        this.cancelPalettePointer();
+        if (this.locked)
+            return;
+        if (!drag.moved) {
+            this.activatePaletteKind(drag.kind);
+            if (this.narrowValue)
+                this.closeDrawer();
+            return;
+        }
+        if (!point)
+            return;
+        if (drag.kind.placement) {
+            this.addLayoutKind(drag.kind, point);
+            return;
+        }
+        const line = drag.kind.kind === 'end' ? undefined : this.paletteLineAt(point);
+        const frame = line ? undefined : this.paletteFrameAt(point);
+        this.requestEdit({ type: line ? 'insert' : 'add', kind: drag.kind, lineId: line?.id, from: line?.from, to: line?.to, parentId: frame?.id, position: point });
+    }
     renderPalette() {
         const choices = this.shadowRoot.querySelector("[part=choices]");
         const query = this.shadowRoot.querySelector("[part=search]").value.toLowerCase();
@@ -2583,19 +2972,30 @@ export class ProcessModeler extends BaseElement {
             description.textContent = kind.description;
             button.append(icon, name, description);
             button.disabled = this.locked;
-            button.draggable = !this.locked;
-            button.addEventListener("click", () => {
-                if (kind.placement) {
-                    this.addLayoutKind(kind);
+            button.draggable = false;
+            button.addEventListener('pointerdown', event => {
+                if (this.locked || event.button !== 0 || event.isPrimary === false)
                     return;
+                this.cancelPalettePointer();
+                this.suppressPaletteClick = false;
+                this.palettePointer = { kind, id: event.pointerId, x: event.clientX, y: event.clientY, moved: false };
+                this.ownerDocument.addEventListener('keydown', this.escapePalettePointer, true);
+                try {
+                    this.setPointerCapture(event.pointerId);
                 }
-                const from = this.selectedId;
-                const outgoing = from ? this.projection.lines.filter(line => line.from === from) : [];
-                const line = outgoing.length === 1 ? outgoing[0] : undefined;
-                this.requestEdit(line ? { type: "insert", kind, lineId: line.id, from: line.from, to: line.to } : { type: "add", kind, ...(from ? { from } : {}) });
+                catch { /* Detached synthetic pointers cannot be captured. */ }
+                event.preventDefault();
+                event.stopPropagation();
             });
-            button.addEventListener("dragstart", event => { this.paletteDragKind = kind; event.dataTransfer?.setData("application/boe-process-kind", kind.kind); });
-            button.addEventListener("dragend", () => { this.paletteDragKind = null; this.shadowRoot?.querySelector('[part=palette-ghost]')?.remove(); this.markDropLine(undefined); });
+            button.addEventListener('click', event => {
+                if (event.detail > 0 && this.suppressPaletteClick) {
+                    this.suppressPaletteClick = false;
+                    return;
+                }
+                this.activatePaletteKind(kind);
+            });
+            button.addEventListener('dragstart', event => { this.paletteDragKind = kind; event.dataTransfer?.setData('application/boe-process-kind', kind.kind); });
+            button.addEventListener('dragend', () => { this.paletteDragKind = null; this.shadowRoot?.querySelector('[part=palette-ghost]')?.remove(); this.markDropLine(undefined); });
             choices.append(button);
         }
         const canvas = this.shadowRoot.querySelector("[part=canvas]");
@@ -3058,7 +3458,7 @@ export class ProcessModeler extends BaseElement {
             duplicate.type = 'button';
             duplicate.textContent = 'Duplicate';
             duplicate.disabled = this.locked;
-            duplicate.onclick = () => this.requestEdit({ type: 'duplicate', sourceId: selected.id, position: { x: this.layoutValue.boxes[selected.id].x + 32, y: this.layoutValue.boxes[selected.id].y + 32 } });
+            duplicate.onclick = () => this.duplicateBoxes([selected.id], 48);
             const remove = document.createElement('button');
             remove.type = 'button';
             remove.textContent = 'Delete';
@@ -3071,7 +3471,7 @@ export class ProcessModeler extends BaseElement {
     }
     renderSelectionToolbar() {
         const toolbar = this.shadowRoot.querySelector('[part=selection-toolbar]');
-        const key = `${[...this.selectedIds].join(',')}|${this.selected?.kind}|${this.selected?.shape}|${this.selectedLineId}|${Boolean(this.selectedLineId && this.layoutValue.lines?.[this.selectedLineId])}|${this.locked}|${this.narrowValue}|${this.projection.lines.filter(line => line.from === this.selectedId).map(line => `${line.id}:${line.label}:${line.dashed}`).join(',')}`;
+        const key = `${[...this.selectedIds].join(',')}|${this.selected?.kind}|${this.selected?.shape}|${this.selectedLineId}|${Boolean(this.selectedLine && (this.layoutValue.lines?.[this.selectedLine.id] || this.selectedLine.fromSide || this.selectedLine.toSide || this.selectedLine.points?.length))}|${this.locked}|${this.narrowValue}|${this.projection.lines.filter(line => line.from === this.selectedId).map(line => `${line.id}:${line.label}:${line.dashed}`).join(',')}`;
         if (key === this.selectionToolbarKey)
             return;
         this.selectionToolbarKey = key;
@@ -3100,7 +3500,7 @@ export class ProcessModeler extends BaseElement {
         if (this.selectedLine) {
             const line = this.selectedLine;
             add('Insert a step', 'insert', () => this.openLineChooser(line, toolbar.querySelector('[data-selection-command=insert]') ?? undefined), true);
-            if (this.layoutValue.lines?.[line.id])
+            if (this.layoutValue.lines?.[line.id] || line.fromSide || line.toSide || line.points?.length)
                 add('Reset line', 'reset-line', () => this.resetLine(line.id));
             if (!this.disableConnections)
                 add('Delete', 'delete-line', () => this.requestEdit({ type: 'disconnect', lineId: line.id }));
@@ -3115,7 +3515,7 @@ export class ProcessModeler extends BaseElement {
             if (failurePath)
                 add('If it fails', 'add-failure', () => this.openAnchoredChooser({ type: 'add', from: box.id, routeLabel: 'If it fails', dashed: true }, `If a step in ${box.title} fails`, toolbar.querySelector('[data-selection-command=add-failure]') ?? undefined, Array.from(this.shadowRoot.querySelectorAll('[data-box-id]')).find(element => element.dataset.boxId === box.id)), true);
             if (!['start', 'timer', 'section'].includes(box.kind))
-                add('Duplicate', 'duplicate', () => { const position = this.layoutValue.boxes[box.id]; this.requestEdit({ type: 'duplicate', sourceId: box.id, position: { x: position.x + 32, y: position.y + 32 } }); });
+                add('Duplicate', 'duplicate', () => this.duplicateBoxes([box.id], 48));
             if (!['start', 'timer'].includes(box.kind))
                 add('Delete', 'delete-many', () => this.selectionCommand('delete-many'));
         }
@@ -3218,9 +3618,11 @@ export class ProcessModeler extends BaseElement {
     focusBox(id) {
         Array.from(this.shadowRoot.querySelectorAll("[data-box-id]"))
             .find((box) => box.dataset.boxId === id)
-            ?.focus();
+            ?.focus({ preventScroll: true });
     }
     setStatus(message, urgent = false) {
+        if (!this.isRendered)
+            return;
         this.shadowRoot.querySelector(urgent ? "[part=status]" : "[part=urgent-status]").textContent = "";
         this.shadowRoot.querySelector(urgent ? "[part=urgent-status]" : "[part=status]").textContent = message;
     }