@unofficialbox/box-open-elements 0.32.0 → 0.34.0

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

@@ -1,4 +1,5 @@
 import { BaseElement } from "../../core/index.js";
+import { iconPlus, iconXBatsu } from "../../foundations/icons/glyphs/index.js";
 import { announce } from "../../foundations/a11y/index.js";
 import { dismissModal, dismissPopover, promoteModal, promotePopover, trackAnchor } from "../../foundations/overlay/index.js";
 import { KindPicker } from "../flow-builder/primitives.js";
@@ -7,6 +8,20 @@ import { restoreProcessPositions, snapshotProcessPositions, snapshotProcessProje
 import { processModelerDesign } from "./design.js";
 import { completeLayout, ProcessHistory, validateProjection, } from "./model.js";
 const svgElement = (tag) => document.createElementNS("http://www.w3.org/2000/svg", tag);
+const variableLabel = (text) => {
+    const label = document.createElement('label'), name = document.createElement('span');
+    name.setAttribute('part', 'sr-only');
+    name.textContent = text;
+    label.append(name);
+    return label;
+};
+const variableGlyph = (add = false) => {
+    const template = document.createElement('template');
+    template.innerHTML = add ? iconPlus : iconXBatsu;
+    const glyph = template.content.firstElementChild;
+    glyph.setAttribute('part', 'variable-icon');
+    return glyph;
+};
 const checkGlyph = (success = false) => {
     const icon = svgElement('svg');
     icon.setAttribute('part', 'check-icon');
@@ -53,6 +68,9 @@ export class ProcessModeler extends BaseElement {
     showLastRunValue = false;
     selectedId = null;
     selectedLineId = null;
+    selectedLineIds = new Set();
+    selectedNoteIds = new Set();
+    graphSelection = false;
     connecting = null;
     checks = [];
     renderer;
@@ -60,6 +78,8 @@ export class ProcessModeler extends BaseElement {
     inspected;
     inspectedId;
     inspectedControls = "";
+    localEchoRevision = 0;
+    pendingLocalRename;
     historyValue = new ProcessHistory();
     viewport = { x: 0, y: 0, zoom: 1 };
     pointers = new Map();
@@ -76,6 +96,33 @@ export class ProcessModeler extends BaseElement {
     selectedIds = new Set();
     clipboard = null;
     clipboardSession = 0;
+    layoutEditSession = 0;
+    acceptanceNotifications = 0;
+    deferredNotifications = [];
+    notify(name, detail) {
+        if (this.acceptanceNotifications)
+            this.deferredNotifications.push({ name, detail, session: this.layoutEditSession });
+        else
+            emit(this, name, detail);
+    }
+    flushAcceptanceNotifications() {
+        if (this.acceptanceNotifications)
+            return;
+        this.acceptanceNotifications++;
+        try {
+            // Observer edits append behind the complete accepted batch, rather than
+            // publishing newer state before older queued persistence notifications.
+            while (this.deferredNotifications.length) {
+                const notification = this.deferredNotifications.shift();
+                if (notification.session !== this.layoutEditSession)
+                    continue;
+                emit(this, notification.name, notification.detail);
+            }
+        }
+        finally {
+            this.acceptanceNotifications--;
+        }
+    }
     restoringBoxFocus = false;
     selectionToolbarKey = "";
     sectionSequence = 0;
@@ -167,7 +214,16 @@ export class ProcessModeler extends BaseElement {
         };
     }
     load(document, options = {}) {
+        this.pendingLocalRename = undefined;
+        const session = ++this.layoutEditSession;
+        this.insertion = undefined;
         this.cancelPalettePointer();
+        this.closeKeyboardChooser();
+        const chooser = this.shadowRoot?.querySelector('[part=insert-chooser]');
+        if (chooser)
+            dismissModal(chooser);
+        if (session !== this.layoutEditSession)
+            return;
         const projection = this.model.project(document);
         validateProjection(projection);
         this.documentValue = document;
@@ -177,6 +233,7 @@ export class ProcessModeler extends BaseElement {
         this.lastReadableProjection = "";
         this.readableValue = null;
         this.layoutValue = restoreProcessPositions(projection, options.positions ?? []);
+        this.clearMixedSelection();
         this.history.clear();
         this.selectedId = null;
         this.selectedLineId = null;
@@ -192,15 +249,54 @@ export class ProcessModeler extends BaseElement {
             validateProjection(this.projection);
         }
         const next = new Set(ids.filter(id => this.projection.boxes.some(box => box.id === id)));
-        if (next.size === this.selectedIds.size && [...next].every(id => this.selectedIds.has(id)))
+        if (!this.graphSelection && !this.selectedLineIds.size && !this.selectedNoteIds.size && next.size === this.selectedIds.size && [...next].every(id => this.selectedIds.has(id)))
             return;
+        this.clearMixedSelection();
         this.selectedIds = next;
         this.selectedId = this.selectedIds.values().next().value ?? null;
         this.selectedLineId = null;
         this.renderSelection();
         if (this.isRendered)
             this.updateToolbar();
-        emit(this, "selection-changed", { box: this.selected, boxes: this.selectedBoxes, path: this.selectedPath });
+        this.notify("selection-changed", { box: this.selected, boxes: this.selectedBoxes, path: this.selectedPath, ...(this.graphSelection ? { selection: this.selection } : {}) });
+    }
+    /** Detached mixed selection. Invalid and duplicate IDs are ignored by selectItems. */
+    get selection() {
+        return [...[...this.selectedIds].map(id => ({ type: 'box', id })),
+            ...[...this.selectedLineIds].map(id => ({ type: 'line', id })),
+            ...[...this.selectedNoteIds].map(id => ({ type: 'note', id }))];
+    }
+    selectItems(items) {
+        if (!this.isRendered && this.documentValue !== undefined) {
+            this.projection = this.model.project(this.documentValue);
+            validateProjection(this.projection);
+        }
+        const boxes = new Set(), lines = new Set(), notes = new Set();
+        for (const item of items) {
+            if (item.type === 'box' && this.projection.boxes.some(box => box.id === item.id))
+                boxes.add(item.id);
+            if (item.type === 'line' && this.projection.lines.some(line => line.id === item.id))
+                lines.add(item.id);
+            if (item.type === 'note' && this.layoutValue.notes?.some(note => note.id === item.id))
+                notes.add(item.id);
+        }
+        const before = JSON.stringify(this.selection);
+        this.selectedIds = boxes;
+        this.selectedLineIds = lines;
+        this.selectedNoteIds = notes;
+        this.selectedId = boxes.values().next().value ?? null;
+        this.selectedLineId = !boxes.size && !notes.size && lines.size === 1 ? lines.values().next().value : null;
+        this.graphSelection = true;
+        this.renderSelection();
+        if (this.isRendered)
+            this.updateToolbar();
+        if (before !== JSON.stringify(this.selection))
+            this.notify('selection-changed', { box: this.selected, boxes: this.selectedBoxes, path: this.selectedPath, selection: this.selection });
+    }
+    clearMixedSelection() {
+        this.selectedLineIds.clear();
+        this.selectedNoteIds.clear();
+        this.graphSelection = false;
     }
     get headingLevel() { const level = Number(this.getAttribute("heading-level") ?? 2); return Number.isInteger(level) && level >= 1 && level <= 6 ? level : 2; }
     set headingLevel(value) { this.setAttribute("heading-level", String(value)); }
@@ -224,8 +320,13 @@ export class ProcessModeler extends BaseElement {
         this.refresh();
     }
     set document(value) {
+        this.localEchoRevision++;
+        const rename = this.pendingLocalRename;
         this.documentValue = value;
         this.refresh();
+        // One explicit echo settles this intent, including a rejected unchanged echo.
+        if (rename === this.pendingLocalRename && rename && this.localEchoRevision > rename.echoRevision)
+            this.pendingLocalRename = undefined;
     }
     get model() {
         return this.modelValue;
@@ -293,6 +394,12 @@ export class ProcessModeler extends BaseElement {
         this.refresh();
     }
     disconnectedCallback() {
+        const menu = this.shadowRoot?.querySelector('[part=view-menu]');
+        if (menu)
+            menu.open = false;
+        this.viewMenuDocument?.removeEventListener('pointerdown', this.dismissViewMenuOutside, true);
+        this.viewMenuDocument = undefined;
+        this.layoutEditSession++;
         this.resizeObserver?.disconnect();
         this.clearClipboard();
         this.cancelPalettePointer();
@@ -312,7 +419,7 @@ export class ProcessModeler extends BaseElement {
         this.marquee = undefined;
         this.segmentDrag = undefined;
     }
-    connectedCallback() { super.connectedCallback(); this.resizeObserver?.observe(this); }
+    connectedCallback() { super.connectedCallback(); this.resizeObserver?.observe(this); this.syncViewMenuDismissal(); }
     refresh() {
         if (this.isRendered)
             this.update();
@@ -327,8 +434,9 @@ export class ProcessModeler extends BaseElement {
         }
         if (id !== null && !this.projection.boxes.some((box) => box.id === id))
             return;
-        if (id === this.selectedId && this.selectedIds.size === (id ? 1 : 0) && !this.selectedLineId)
+        if (id === this.selectedId && this.selectedIds.size === (id ? 1 : 0) && !this.selectedLineId && !this.graphSelection)
             return;
+        this.clearMixedSelection();
         this.selectedId = id;
         this.selectedIds = new Set(id ? [id] : []);
         this.selectedLineId = null;
@@ -336,18 +444,20 @@ export class ProcessModeler extends BaseElement {
         if (this.isRendered)
             this.updateToolbar();
         if (notify)
-            emit(this, "selection-changed", { box: this.selected, boxes: this.selectedBoxes, path: this.selectedPath });
+            this.notify("selection-changed", { box: this.selected, boxes: this.selectedBoxes, path: this.selectedPath, ...(this.graphSelection ? { selection: this.selection } : {}) });
     }
     selectLine(id) {
         if (id !== null && !this.projection.lines.some(line => line.id === id))
             return;
-        if (this.selectedLineId === id && !this.selectedIds.size)
+        if (!this.graphSelection && this.selectedLineId === id && !this.selectedIds.size)
             return;
+        this.clearMixedSelection();
+        this.selectedLineIds = new Set(id ? [id] : []);
         this.selectedLineId = id;
         this.selectedId = null;
         this.selectedIds.clear();
         this.refresh();
-        emit(this, 'selection-changed', { box: null, boxes: [], line: this.selectedLine, path: null });
+        this.notify('selection-changed', { box: null, boxes: [], line: this.selectedLine, path: null });
     }
     setValidation(checks) {
         this.checks = checks;
@@ -373,67 +483,136 @@ export class ProcessModeler extends BaseElement {
     requestEdit(edit) {
         if (this.locked || (this.disableConnections && (edit.type === "connect" || edit.type === "disconnect" || edit.type === 'reattach')))
             return;
+        if (edit.type === 'delete-selection' && (!edit.selection?.length || edit.selection.some(item => !['box', 'line', 'note'].includes(item.type) || typeof item.id !== 'string' || !item.id))) {
+            this.setStatus('The selected graph items are invalid', true);
+            return;
+        }
+        if (edit.selection)
+            edit = { ...edit, selection: Object.freeze(edit.selection.map(item => Object.freeze({ type: item.type, id: item.id }))) };
+        if (this.disableConnections && edit.type === 'delete-selection' && edit.selection?.some(item => item.type === 'line')) {
+            this.setStatus('Deleting selected lines is disabled');
+            return;
+        }
+        const placement = edit.placement;
+        if (placement) {
+            const source = placement.source;
+            let normalized;
+            if (edit.type === 'add' || edit.type === 'insert') {
+                if (source === 'next')
+                    normalized = { source };
+                else if (source === 'direction') {
+                    const side = placement.side;
+                    if (['north', 'east', 'south', 'west'].includes(side))
+                        normalized = { source, side };
+                }
+                else if (source === 'point' || source === 'line') {
+                    const { x, y } = placement.center ?? {};
+                    if (Number.isFinite(x) && Number.isFinite(y))
+                        normalized = { source, center: { x, y } };
+                }
+            }
+            if (!normalized) {
+                this.setStatus('The insertion placement is invalid', true);
+                return;
+            }
+            edit = { ...edit, placement: normalized };
+        }
         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);
+        if (edit.type !== 'delete-selection') {
+            emit(this, 'process-edit-request', request);
+            return;
+        }
+        // A synchronous host echo can prune selected lines before accept records
+        // history. Keep those observers behind the complete atomic transaction.
+        this.acceptanceNotifications++;
+        try {
+            emit(this, 'process-edit-request', request);
+        }
+        finally {
+            this.acceptanceNotifications--;
+            this.flushAcceptanceNotifications();
+        }
     }
     editAcceptance(edit) {
         const before = this.layout;
         const beforeSelection = [...this.selectedIds];
+        const beforeItems = this.selection;
         const previousIds = new Set(this.projection.boxes.map((box) => box.id));
+        const session = this.layoutEditSession;
         let accepted = false;
         return (command) => {
-            if (accepted)
+            if (accepted || session !== this.layoutEditSession)
                 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);
+            // Projection/readability/selection observers may synchronously edit or
+            // replace the document. Publish only after the whole history entry exists.
+            this.acceptanceNotifications++;
+            try {
+                if (command.layout)
+                    this.layoutValue = structuredClone(command.layout);
+                if (edit.type === 'reset-line' && edit.lineId)
+                    delete this.layoutValue.lines?.[edit.lineId];
                 this.refresh();
-                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);
+                if (session !== this.layoutEditSession)
+                    return;
+                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);
+                }
+                if (session !== this.layoutEditSession)
+                    return;
+                const after = this.layout;
+                const acceptedItems = command.selection ? command.selection.map(item => ({ type: item.type, id: item.id })) : undefined;
+                const acceptedSelection = command.selectionIds ? [...command.selectionIds] : undefined;
+                const restore = (layout) => {
+                    this.layoutValue = structuredClone(layout);
+                    this.refresh();
+                    this.emitPositions();
+                };
+                this.history.record({
+                    undo: () => {
+                        command.undo();
+                        restore(before);
+                        if (acceptedItems)
+                            this.selectItems(beforeItems);
+                        else if (acceptedSelection)
+                            this.selectMany(beforeSelection);
+                    },
+                    redo: () => {
+                        command.redo();
+                        restore(after);
+                        if (acceptedItems)
+                            this.selectItems(acceptedItems);
+                        else if (acceptedSelection)
+                            this.selectMany(acceptedSelection);
+                    },
+                });
+                if (acceptedItems)
+                    this.selectItems(acceptedItems);
+                else if (acceptedSelection)
+                    this.selectMany(acceptedSelection);
+                this.refresh();
+                if (JSON.stringify(before) !== JSON.stringify(after))
+                    this.emitPositions();
+                announce("Process updated", "polite", this.ownerDocument);
+            }
+            finally {
+                this.acceptanceNotifications--;
+                this.flushAcceptanceNotifications();
+            }
         };
     }
     undo() {
@@ -448,6 +627,53 @@ export class ProcessModeler extends BaseElement {
         this.history.redo();
         this.refresh();
     }
+    requestLayoutEdit(type, sourceIds, title, onAccepted) {
+        const capability = this.model.layoutEdit;
+        if (!capability || this.documentValue === undefined)
+            return false;
+        if (this.locked)
+            return true;
+        if (!this.isRendered) {
+            this.projection = this.model.project(this.documentValue);
+            validateProjection(this.projection);
+        }
+        const session = this.layoutEditSession;
+        const accept = this.editAcceptance({ type });
+        let active = true, settled = false, acceptedLayout = false;
+        const valid = () => active && !settled && session === this.layoutEditSession && !this.locked;
+        const request = {
+            type, sourceIds: sourceIds ? Object.freeze([...sourceIds]) : null, ...(title !== undefined ? { title } : {}), layout: this.layout,
+            accept: command => {
+                if (!valid())
+                    return;
+                settled = true;
+                if (!command.layout) {
+                    this.setStatus('The host must supply the complete accepted layout', true);
+                    return;
+                }
+                accept(command);
+                acceptedLayout = session === this.layoutEditSession;
+            },
+            refuse: message => { if (!valid())
+                return; settled = true; this.setStatus(message ?? 'The host refused this layout edit', true); },
+        };
+        // Hosts may assign a fresh document before accepting the request. Its
+        // notifications must follow the same atomic history boundary.
+        this.acceptanceNotifications++;
+        try {
+            capability.call(this.model, this.documentValue, request, this.projection);
+        }
+        finally {
+            active = false;
+            this.acceptanceNotifications--;
+            this.flushAcceptanceNotifications();
+        }
+        if (acceptedLayout && session === this.layoutEditSession)
+            onAccepted?.();
+        if (!settled && session === this.layoutEditSession)
+            this.setStatus('This layout edit was not accepted by the host', true);
+        return true;
+    }
     commitLayout(next) {
         const before = this.layout;
         const after = structuredClone(next);
@@ -476,8 +702,8 @@ export class ProcessModeler extends BaseElement {
             this.commitLayout(next);
     }
     emitPositions() {
-        emit(this, "layout-changed", { layout: this.layout });
-        emit(this, "positions-changed", { positions: this.positions, version: this.versionValue });
+        this.notify("layout-changed", { layout: this.layout });
+        this.notify("positions-changed", { positions: this.positions, version: this.versionValue });
     }
     translatedLayout(id, x, y) {
         const snap = (n) => (this.snapToGrid ? Math.round(n / 16) * 16 : n);
@@ -543,6 +769,9 @@ export class ProcessModeler extends BaseElement {
     tidy() {
         if (this.locked)
             return;
+        if (this.requestLayoutEdit('tidy', null, undefined, () => { if (this.isRendered)
+            this.fitTo(this.narrowValue ? 0.55 : 0.7); }))
+            return;
         const before = this.layout.boxes;
         this.commitLayout(this.arrangedLayout({ ...this.layout, boxes: {} }));
         if (!globalThis.matchMedia?.('(prefers-reduced-motion: reduce)').matches) {
@@ -689,13 +918,13 @@ export class ProcessModeler extends BaseElement {
         chooser.append(picker);
         this.shadowRoot.append(chooser);
         picker.addEventListener("kind-pick", event => {
-            const insertion = this.insertion;
-            dismissModal(chooser);
+            const insertion = this.insertion, session = this.layoutEditSession;
             this.insertion = undefined;
-            if (insertion)
+            dismissModal(chooser);
+            if (insertion && session === this.layoutEditSession && this.isConnected)
                 this.requestEdit({ ...insertion, kind: event.detail.kind });
         });
-        picker.addEventListener("picker-cancel", () => { dismissModal(chooser); this.insertion = undefined; });
+        picker.addEventListener("picker-cancel", () => { this.insertion = undefined; dismissModal(chooser); });
         const keyboardChooser = document.createElement('div');
         keyboardChooser.setAttribute('part', 'keyboard-chooser');
         keyboardChooser.setAttribute('popover', 'manual');
@@ -710,18 +939,35 @@ export class ProcessModeler extends BaseElement {
         keyboardChooser.append(keyboardTitle, keyboardPicker);
         this.shadowRoot.append(keyboardChooser);
         keyboardPicker.addEventListener('kind-pick', event => {
-            const edit = this.keyboardInsertion;
+            const edit = this.keyboardInsertion, session = this.layoutEditSession;
             this.closeKeyboardChooser(true);
+            if (session !== this.layoutEditSession || !this.isConnected)
+                return;
             // Keep a stable step focused while the host applies and accepts the edit.
             // World refreshes preserve step focus, including deferred acceptance.
             if (edit?.from)
                 this.focusBox(edit.from);
-            if (edit)
+            if (edit && session === this.layoutEditSession && this.isConnected)
                 this.requestEdit({ ...edit, kind: event.detail.kind });
         });
         keyboardPicker.addEventListener('picker-cancel', () => this.closeKeyboardChooser(true));
         this.setupPanes();
     }
+    viewMenuDocument;
+    syncViewMenuDismissal() {
+        const menu = this.shadowRoot?.querySelector('[part=view-menu]');
+        const target = this.isConnected && menu?.open ? this.ownerDocument : undefined;
+        if (this.viewMenuDocument === target)
+            return;
+        this.viewMenuDocument?.removeEventListener('pointerdown', this.dismissViewMenuOutside, true);
+        this.viewMenuDocument = target;
+        target?.addEventListener('pointerdown', this.dismissViewMenuOutside, true);
+    }
+    dismissViewMenuOutside = (event) => {
+        const menu = this.shadowRoot?.querySelector('[part=view-menu]');
+        if (menu?.open && !event.composedPath().includes(menu))
+            menu.open = false;
+    };
     setupPanes() {
         const root = this.shadowRoot;
         const toolbar = root.querySelector('[part=toolbar]');
@@ -754,27 +1000,99 @@ export class ProcessModeler extends BaseElement {
         viewMenu.append(summary);
         const viewOptions = document.createElement('div');
         viewOptions.setAttribute('part', 'view-menu-options');
+        viewOptions.setAttribute('role', 'menu');
+        viewOptions.setAttribute('aria-label', 'Diagram view');
         viewMenu.append(viewOptions);
+        summary.setAttribute('aria-haspopup', 'menu');
+        viewMenu.addEventListener('toggle', () => { summary.setAttribute('aria-expanded', String(viewMenu.open)); this.syncViewMenuDismissal(); });
+        const closeViewMenu = () => { const session = this.layoutEditSession; viewMenu.open = false; summary.focus({ preventScroll: true }); return session === this.layoutEditSession && this.isConnected; };
+        viewMenu.addEventListener('keydown', event => {
+            const items = Array.from(viewOptions.querySelectorAll('button')).filter(item => !item.hidden && !item.disabled);
+            if (event.key === 'Tab') {
+                if (viewMenu.open && root.activeElement === summary && !event.shiftKey && items.length) {
+                    event.preventDefault();
+                    items[0].focus();
+                }
+                else
+                    viewMenu.open = false;
+                return;
+            }
+            if (!['ArrowDown', 'ArrowUp', 'Home', 'End'].includes(event.key) || !items.length)
+                return;
+            event.preventDefault();
+            viewMenu.open = true;
+            const index = items.indexOf(root.activeElement);
+            const next = event.key === 'Home' ? 0 : event.key === 'End' ? items.length - 1 : event.key === 'ArrowDown' ? (index + 1) % items.length : (index < 0 ? items.length - 1 : (index + items.length - 1) % items.length);
+            items[next].focus();
+        });
+        root.addEventListener('pointerdown', event => { if (!event.composedPath().includes(viewMenu))
+            viewMenu.open = false; });
         for (const [value, label] of [["business", "Business view"], ["technical", "Technical view"]]) {
             const button = document.createElement("button");
             button.type = "button";
             button.dataset.detail = value;
             button.textContent = label;
-            button.onclick = () => { this.detail = value; viewMenu.open = false; };
+            button.setAttribute('role', 'menuitemradio');
+            button.onclick = () => { if (closeViewMenu())
+                this.detail = value; };
             viewOptions.append(button);
         }
         const mobileRun = document.createElement('button');
         mobileRun.type = 'button';
         mobileRun.dataset.viewOption = 'last-run';
-        mobileRun.textContent = 'Last run';
-        mobileRun.onclick = () => { this.showLastRun = !this.showLastRun; viewMenu.open = false; };
+        mobileRun.textContent = 'Show last run';
+        mobileRun.setAttribute('role', 'menuitem');
+        mobileRun.onclick = () => { if (closeViewMenu())
+            this.showLastRun = !this.showLastRun; };
         viewOptions.append(mobileRun);
         const mobileChecks = document.createElement('button');
         mobileChecks.type = 'button';
-        mobileChecks.textContent = 'Checks';
-        mobileChecks.onclick = () => { this.select(null); this.activePane = 'Checks'; this.renderPane(); viewMenu.open = false; this.openDrawer('inspector'); };
+        mobileChecks.dataset.viewOption = 'checks';
+        mobileChecks.textContent = 'Checks: ready to run';
+        mobileChecks.setAttribute('role', 'menuitem');
+        mobileChecks.onclick = () => { if (closeViewMenu())
+            checksStatus.click(); };
         viewOptions.append(mobileChecks);
-        toolbar.prepend(viewSwitch, runToggle, viewMenu);
+        const separator = document.createElement('div');
+        separator.setAttribute('role', 'separator');
+        viewOptions.append(separator);
+        for (const [command, label, hint] of [['tidy', 'Tidy up', ''], ['undo', 'Undo', 'Ctrl Z'], ['redo', 'Redo', 'Shift Ctrl Z']]) {
+            const item = document.createElement('button');
+            item.type = 'button';
+            item.dataset.viewOption = command;
+            item.setAttribute('role', 'menuitem');
+            const text = document.createElement('span');
+            text.textContent = label;
+            item.append(text);
+            if (hint) {
+                const key = document.createElement('small');
+                key.textContent = hint;
+                item.append(key);
+            }
+            item.onclick = () => { if (!closeViewMenu())
+                return; if (command === 'tidy')
+                this.tidy();
+            else if (command === 'undo')
+                this.undo();
+            else
+                this.redo(); };
+            viewOptions.append(item);
+        }
+        const spacer = document.createElement('div');
+        spacer.setAttribute('part', 'toolbar-document');
+        spacer.setAttribute('aria-hidden', 'true');
+        const spacerTitle = document.createElement('strong');
+        spacerTitle.setAttribute('part', 'toolbar-title');
+        spacerTitle.textContent = this.processTitleValue;
+        const saved = document.createElement('span');
+        saved.textContent = 'Saved';
+        spacer.append(spacerTitle, saved);
+        toolbar.prepend(spacer, viewSwitch, runToggle, viewMenu);
+        const actions = document.createElement('div');
+        actions.setAttribute('part', 'toolbar-actions');
+        for (const command of ['undo', 'redo', 'tidy'])
+            actions.append(toolbar.querySelector(`[data-command=${command}]`));
+        toolbar.append(actions);
         const layout = root.querySelector('[part=layout]');
         const scrim = document.createElement('div');
         scrim.setAttribute('part', 'pane-scrim');
@@ -854,7 +1172,13 @@ export class ProcessModeler extends BaseElement {
             trigger.setAttribute("aria-label", part === "palette" ? "Add building blocks" : `Open ${label.toLowerCase()}`);
             trigger.setAttribute('aria-expanded', 'false');
             trigger.onclick = () => this.openDrawer(part);
-            toolbar.append(trigger);
+            if (part === 'palette') {
+                trigger.textContent = '';
+                trigger.append(variableGlyph(true));
+                toolbar.prepend(trigger);
+            }
+            else
+                actions.append(trigger);
         }
         const inspector = root.querySelector('[part=inspector]');
         const heading = document.createElement("div");
@@ -953,6 +1277,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-compact-toolbar', entries[0].contentRect.width <= 1100);
                 this.toggleAttribute('data-hide-tidy', entries[0].contentRect.width <= 560);
                 this.renderSelectionToolbar();
                 this.positionSelectionToolbar();
@@ -1026,6 +1351,7 @@ export class ProcessModeler extends BaseElement {
         });
         const content = root.querySelector('[part=pane-content]');
         content.hidden = Boolean(selected);
+        content.dataset.pane = this.activePane;
         content.setAttribute("aria-labelledby", `process-tab-${this.activePane.toLowerCase()}`);
         const checks = root.querySelector('[part=checks]');
         checks.hidden = this.activePane !== "Checks";
@@ -1084,29 +1410,50 @@ export class ProcessModeler extends BaseElement {
             content.append(checks);
         }
         else if (this.activePane === "Variables") {
-            if (!this.variables.length)
-                content.textContent = 'No variables supplied by the host.';
+            const intro = document.createElement('p');
+            intro.setAttribute('part', 'variables-intro');
+            intro.textContent = 'Values the process keeps while it runs. Decisions and step inputs read them by name, written in CEL.';
+            content.append(intro);
+            const scopes = document.createElement('dl');
+            scopes.setAttribute('part', 'variable-scopes');
+            for (const [name, meaning] of [['Iteration', 'Starts fresh each time a test user runs the process.'], ['Process', 'Set once per test user and kept across their iterations.'], ['Step', 'Only inside one step or frame. Add those in the step’s details.']]) {
+                const term = document.createElement('dt');
+                term.textContent = name;
+                const definition = document.createElement('dd');
+                definition.textContent = meaning;
+                scopes.append(term, definition);
+            }
+            content.append(scopes);
+            const collection = document.createElement('div');
+            collection.setAttribute('part', 'variable-list');
+            content.append(collection);
+            if (!this.variables.length) {
+                const empty = document.createElement('p');
+                empty.textContent = 'None yet.';
+                collection.append(empty);
+            }
             for (const [index, variable] of this.variables.entries()) {
                 const row = document.createElement('div');
                 row.setAttribute('part', 'variable-row');
                 const identify = (control, key) => { control.dataset.variable = variable.name; control.dataset.variableKey = key; control.dataset.variableIndex = String(index); };
                 if (this.variablesEditable) {
-                    const label = document.createElement('label');
-                    label.textContent = 'Name';
+                    const label = variableLabel('Name');
                     const name = document.createElement('input');
                     name.type = 'text';
+                    name.placeholder = 'name';
+                    name.spellcheck = false;
+                    name.autocomplete = 'off';
                     name.value = variable.name;
                     name.disabled = this.locked;
                     identify(name, 'name');
                     name.onchange = () => this.requestVariableEdit({ type: 'rename', name: variable.name, value: name.value });
                     label.append(name);
                     row.append(label);
-                    const scopeLabel = document.createElement('label');
-                    scopeLabel.textContent = 'Scope';
+                    const scopeLabel = variableLabel('Kept for');
                     const scope = document.createElement('select');
                     identify(scope, 'scope');
                     scope.disabled = this.locked;
-                    for (const [value, text] of [['iteration', 'Each iteration'], ['process', 'The whole process']]) {
+                    for (const [value, text] of [['iteration', 'Iteration'], ['process', 'Process']]) {
                         const option = document.createElement('option');
                         option.value = value;
                         option.textContent = text;
@@ -1128,16 +1475,32 @@ export class ProcessModeler extends BaseElement {
                         row.append(scope);
                     }
                 }
-                if (variable.description) {
+                if (this.variablesEditable) {
+                    const label = variableLabel('What it’s for');
+                    const about = document.createElement('input');
+                    about.type = 'text';
+                    about.placeholder = 'What it’s for';
+                    about.value = variable.description ?? '';
+                    about.disabled = this.locked;
+                    identify(about, 'description');
+                    about.oninput = () => this.requestVariableEdit({ type: 'description', name: variable.name, value: about.value });
+                    label.append(about);
+                    row.append(label);
+                }
+                else if (variable.description) {
                     const description = document.createElement('p');
                     description.textContent = variable.description;
                     row.append(description);
                 }
                 if (variable.startingValue !== undefined) {
-                    const label = document.createElement('label');
-                    label.textContent = 'Starting value';
+                    const label = this.variablesEditable ? variableLabel('Starts as') : document.createElement('label');
+                    if (!this.variablesEditable)
+                        label.textContent = 'Starting value';
                     const input = document.createElement('input');
                     input.type = 'text';
+                    input.placeholder = 'starts as, like 0';
+                    input.spellcheck = false;
+                    input.autocomplete = 'off';
                     identify(input, 'value');
                     input.value = variable.startingValue;
                     input.disabled = this.locked;
@@ -1160,13 +1523,26 @@ export class ProcessModeler extends BaseElement {
                     remove.type = 'button';
                     remove.setAttribute('part', 'variable-remove');
                     remove.setAttribute('aria-label', `Remove ${variable.name || 'this variable'}`);
-                    remove.textContent = '×';
+                    remove.append(variableGlyph());
                     remove.disabled = this.locked;
                     identify(remove, 'remove');
                     remove.onclick = () => this.requestVariableEdit({ type: 'remove', name: variable.name });
                     row.append(remove);
                 }
-                content.append(row);
+                if (this.variablesEditable) {
+                    // The grid's visual ordering must also be the keyboard/read order.
+                    for (const key of ['name', 'value', 'remove', 'description', 'scope']) {
+                        const control = row.querySelector(`[data-variable-key=${key}]`);
+                        if (control)
+                            row.append(control.closest('label') ?? control);
+                    }
+                    const problem = row.querySelector('[part=field-problem]');
+                    if (problem)
+                        row.append(problem);
+                }
+                row.setAttribute('role', 'group');
+                row.setAttribute('aria-label', `Variable ${index + 1}`);
+                collection.append(row);
             }
             if (this.variablesEditable) {
                 const add = document.createElement('button');
@@ -1174,11 +1550,45 @@ export class ProcessModeler extends BaseElement {
                 add.setAttribute('part', 'variable-add');
                 add.dataset.variable = '@add';
                 add.dataset.variableKey = 'add';
-                add.textContent = 'Add a variable';
+                add.append(variableGlyph(true), document.createTextNode('Add a variable'));
                 add.disabled = this.locked;
                 add.onclick = () => this.requestVariableEdit({ type: 'add' });
-                content.append(add);
+                const actions = document.createElement('div');
+                actions.setAttribute('part', 'variable-actions');
+                actions.append(add);
+                content.append(actions);
             }
+            const localRows = this.projection.boxes.flatMap(box => (box.localVariables ?? []).filter(variable => variable.name).map(variable => ({ name: variable.name, connective: 'only in', title: box.title })));
+            const savedRows = this.projection.boxes.filter(box => box.savedResult).map(box => ({ name: box.savedResult, connective: 'from', title: box.title }));
+            const summary = (part, heading, rows, empty) => {
+                if (!rows.length && !empty)
+                    return;
+                const section = document.createElement('section');
+                section.setAttribute('part', part);
+                const title = document.createElement('h3');
+                title.textContent = heading;
+                section.append(title);
+                if (rows.length) {
+                    const list = document.createElement('ul');
+                    for (const item of rows) {
+                        const row = document.createElement('li'), text = document.createElement('span'), name = document.createElement('code'), connective = document.createElement('em');
+                        name.textContent = item.name;
+                        connective.textContent = item.connective;
+                        text.append(name, document.createTextNode(' '), connective, document.createTextNode(` ${item.title}`));
+                        row.append(text);
+                        list.append(row);
+                    }
+                    section.append(list);
+                }
+                else {
+                    const help = document.createElement('p');
+                    help.textContent = empty;
+                    section.append(help);
+                }
+                content.append(section);
+            };
+            summary('local-variable-summary', 'Only in one step', localRows);
+            summary('saved-result-summary', 'Saved by steps', savedRows, 'No step saves its result yet. Set “Save the result as” on a step.');
         }
         else if (this.activePane === "Connections") {
             if (!this.connections.length)
@@ -1220,6 +1630,14 @@ export class ProcessModeler extends BaseElement {
         if (this.locked)
             return;
         const boxes = this.selectedBoxes;
+        if (command === "delete-many" && this.graphSelection) {
+            if (this.disableConnections && this.selectedLineIds.size) {
+                this.setStatus('Deleting selected lines is disabled');
+                return;
+            }
+            this.requestEdit({ type: 'delete-selection', selection: this.selection });
+            return;
+        }
         if (command === "delete-many") {
             for (const box of boxes)
                 this.requestEdit({ type: "delete", boxId: box.id });
@@ -1237,6 +1655,8 @@ export class ProcessModeler extends BaseElement {
     tidySelection() {
         if (this.locked || this.selectedBoxes.length < 2)
             return;
+        if (this.requestLayoutEdit('tidy', [...this.selectedIds]))
+            return;
         const next = this.layout;
         const roots = this.selectedBoxes.filter(box => {
             let parent = box.parentId;
@@ -1276,11 +1696,13 @@ export class ProcessModeler extends BaseElement {
             const arrangedY = Math.min(...group.map(box => arranged.boxes[box.id]?.y ?? Infinity));
             if (![arrangedX, arrangedY].every(Number.isFinite))
                 continue;
+            const dx = Math.round((startX - arrangedX) / 16) * 16;
+            const dy = Math.round((startY - arrangedY) / 16) * 16;
             for (const box of subset.boxes) {
                 const position = arranged.boxes[box.id];
                 if (!position || !next.boxes[box.id])
                     continue;
-                next.boxes[box.id] = { ...next.boxes[box.id], x: startX + position.x - arrangedX, y: startY + position.y - arrangedY };
+                next.boxes[box.id] = { ...next.boxes[box.id], x: position.x + dx, y: position.y + dy };
             }
         }
         this.commitLayout(next);
@@ -1373,7 +1795,11 @@ export class ProcessModeler extends BaseElement {
             this.commitLayout(next);
     }
     makeSection(title = 'New section') {
-        if (this.locked || this.selectedBoxes.length < 2)
+        if (this.locked || !this.selectedBoxes.length)
+            return;
+        if (this.requestLayoutEdit('make-section', [...this.selectedIds], title))
+            return;
+        if (this.selectedBoxes.length < 2)
             return;
         const positions = this.selectedBoxes.map(box => this.layoutValue.boxes[box.id]);
         const x = Math.min(...positions.map(position => position.x)) - 24;
@@ -1536,6 +1962,7 @@ export class ProcessModeler extends BaseElement {
         let claimed = false;
         const request = {
             sourceIds: Object.freeze([...this.selectedIds]),
+            selection: Object.freeze(this.selection.map(item => Object.freeze(item))),
             capture: clipboard => {
                 if (!active || claimed || session !== this.clipboardSession || !this.isConnected)
                     return;
@@ -1551,7 +1978,7 @@ export class ProcessModeler extends BaseElement {
                 return; claimed = true; this.setStatus(message ?? 'Copy is not supported by this host'); },
         };
         try {
-            emit(this, 'process-copy-request', request);
+            emit(this, this.graphSelection && (this.selectedLineIds.size || this.selectedNoteIds.size) ? 'process-selection-copy-request' : 'process-copy-request', request);
         }
         finally {
             active = false;
@@ -1632,11 +2059,15 @@ export class ProcessModeler extends BaseElement {
         }
         if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === 'a') {
             event.preventDefault();
-            this.selectMany(this.projection.boxes.map(box => box.id));
-            this.setStatus(`${this.projection.boxes.length} steps selected`);
+            this.selectItems([
+                ...this.projection.boxes.filter(box => box.kind !== 'section').map(box => ({ type: 'box', id: box.id })),
+                ...this.projection.lines.map(line => ({ type: 'line', id: line.id })),
+                ...(this.layoutValue.notes ?? []).map(note => ({ type: 'note', id: note.id })),
+            ]);
+            this.setStatus(`${this.selection.length} items selected`);
             return;
         }
-        if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === 'c' && this.selectedIds.size) {
+        if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === 'c' && (this.selectedIds.size || this.selectedNoteIds.size)) {
             if (this.copySelection())
                 event.preventDefault();
             return;
@@ -1674,6 +2105,11 @@ export class ProcessModeler extends BaseElement {
             this.setStatus("Whole process fitted to the canvas");
             return;
         }
+        if ((event.key === 'Delete' || event.key === 'Backspace') && this.graphSelection && this.selection.length && !this.locked) {
+            event.preventDefault();
+            this.selectionCommand('delete-many');
+            return;
+        }
         const box = this.selected;
         if (this.selectedLine && (event.key === 'Delete' || event.key === 'Backspace') && !this.locked && !this.disableConnections) {
             event.preventDefault();
@@ -1691,6 +2127,32 @@ export class ProcessModeler extends BaseElement {
             ArrowUp: [0, -1],
             ArrowDown: [0, 1],
         }[event.key];
+        if (direction && this.graphSelection && !this.locked && !event.altKey && !event.ctrlKey && !event.metaKey && (this.selectedIds.size || this.selectedNoteIds.size)) {
+            event.preventDefault();
+            const distance = event.shiftKey ? 64 : 16, dx = direction[0] * distance, dy = direction[1] * distance;
+            const next = this.layout, moved = new Set(this.selectedIds);
+            for (let changed = true; changed;) {
+                changed = false;
+                for (const box of this.projection.boxes)
+                    if (box.parentId && moved.has(box.parentId) && !moved.has(box.id)) {
+                        moved.add(box.id);
+                        changed = true;
+                    }
+            }
+            for (const id of moved) {
+                const p = next.boxes[id];
+                if (p)
+                    next.boxes[id] = { ...p, x: p.x + dx, y: p.y + dy };
+            }
+            next.notes = next.notes?.map(note => this.selectedNoteIds.has(note.id) ? { ...note, x: note.x + dx, y: note.y + dy } : note);
+            const primary = this.selectedId;
+            const allowed = primary
+                ? emit(this, 'move-request', { boxId: primary, position: next.boxes[primary], boxIds: [...moved], positions: next.boxes, noteIds: [...this.selectedNoteIds], notes: next.notes ?? [] })
+                : emit(this, 'note-move-request', { noteIds: [...this.selectedNoteIds], notes: next.notes ?? [] });
+            if (allowed)
+                this.commitLayout(next);
+            return;
+        }
         const canInsertDirection = event.ctrlKey && event.altKey && box && !this.locked && this.catalog.length && !this.disableConnections;
         if (direction && !canInsertDirection && (event.altKey || !box || this.locked)) {
             event.preventDefault();
@@ -2033,7 +2495,7 @@ export class ProcessModeler extends BaseElement {
                         if ((frame?.id ?? null) !== (source.parentId ?? null))
                             this.setStatus('Drop inside the same frame to add a connected step');
                         else
-                            this.openChooserAtPoint({ type: 'add', from: port.id, fromSide: port.side, parentId: source.parentId, position: point }, `Add after ${source.title}`, point);
+                            this.openChooserAtPoint({ type: 'add', from: port.id, fromSide: port.side, parentId: source.parentId, position: point, placement: { source: 'point', center: { ...point } } }, `Add after ${source.title}`, point);
                     }
                 }
             }
@@ -2093,8 +2555,11 @@ export class ProcessModeler extends BaseElement {
                 const position = this.alignedPoint(drag.id, drag.position.x + dx / this.viewport.zoom, drag.position.y + dy / this.viewport.zoom);
                 const line = this.lineAt(point, drag.id);
                 const frame = this.boxAt(point, drag.id, true);
-                if (line)
-                    this.requestEdit({ type: "insert", boxId: drag.id, lineId: line.id, from: line.from, to: line.to, position });
+                if (line) {
+                    const box = this.projection.boxes.find(box => box.id === drag.id);
+                    const { width, height } = this.selectionDimensions(box);
+                    this.requestEdit({ type: "insert", boxId: drag.id, lineId: line.id, from: line.from, to: line.to, position, placement: { source: 'point', center: { x: position.x + width / 2, y: position.y + height / 2 } } });
+                }
                 else if (this.projection.boxes.find(box => box.id === drag.id)?.parentId !== frame?.id)
                     this.requestEdit({ type: "reparent", boxId: drag.id, parentId: frame?.id, position });
                 else if (this.selectedIds.size > 1 && this.selectedIds.has(drag.id)) {
@@ -2219,9 +2684,10 @@ export class ProcessModeler extends BaseElement {
     nextEdit(box, side, position) {
         const shape = box.shape ?? this.catalog.find(kind => kind.kind === box.kind)?.shape;
         const outgoing = this.projection.lines.filter(line => line.from === box.id);
+        const placement = side ? { source: 'direction', side } : { source: 'next' };
         if ((!side || side === 'east') && shape !== 'gateway' && outgoing.length === 1)
-            return { type: 'insert', lineId: outgoing[0].id, from: box.id, to: outgoing[0].to };
-        return { type: 'add', from: box.id, ...(side ? { fromSide: side } : {}), parentId: box.parentId, ...(position ? { position } : {}) };
+            return { type: 'insert', lineId: outgoing[0].id, from: box.id, to: outgoing[0].to, placement };
+        return { type: 'add', from: box.id, placement, ...(side ? { fromSide: side } : {}), parentId: box.parentId, ...(position ? { position } : {}) };
     }
     nextChooserTitle(box, side) {
         const edit = this.nextEdit(box, side);
@@ -2247,7 +2713,7 @@ export class ProcessModeler extends BaseElement {
         const source = this.projection.boxes.find(box => box.id === line.from);
         const target = this.projection.boxes.find(box => box.id === line.to);
         const points = this.routedLines.get(line.id) ?? routeProcessLine(line, this.layoutValue, this.projection);
-        this.openChooserAtPoint({ type: 'insert', lineId: line.id, from: line.from, to: line.to }, `Insert between ${source?.title ?? line.from} and ${target?.title ?? line.to}`, lineMidpoint(points), returnFocus);
+        this.openChooserAtPoint({ type: 'insert', lineId: line.id, from: line.from, to: line.to, placement: { source: 'line', center: lineMidpoint(points) } }, `Insert between ${source?.title ?? line.from} and ${target?.title ?? line.to}`, lineMidpoint(points), returnFocus);
     }
     closeKeyboardChooser(returnFocus = false) {
         const chooser = this.shadowRoot?.querySelector('[part=keyboard-chooser]');
@@ -2258,9 +2724,10 @@ export class ProcessModeler extends BaseElement {
         this.transientChooserAnchor = undefined;
         document.removeEventListener('pointerdown', this.dismissKeyboardChooserOutside, true);
         this.keyboardInsertion = undefined;
-        if (returnFocus)
-            this.keyboardReturn?.focus({ preventScroll: true });
+        const target = this.keyboardReturn;
         this.keyboardReturn = undefined;
+        if (returnFocus)
+            target?.focus({ preventScroll: true });
     }
     dismissKeyboardChooserOutside = (event) => {
         const chooser = this.shadowRoot?.querySelector('[part=keyboard-chooser]');
@@ -2275,8 +2742,8 @@ export class ProcessModeler extends BaseElement {
         const anchor = Array.from(this.shadowRoot.querySelectorAll('[data-box-id]'))
             .find(element => element.dataset.boxId === box.id);
         this.openAnchoredChooser(insert
-            ? { type: 'insert', lineId: outgoing[0].id, from: box.id, to: target.id }
-            : { type: 'add', from: box.id }, insert ? `Insert between ${box.title} and ${target.title}`
+            ? { type: 'insert', lineId: outgoing[0].id, from: box.id, to: target.id, placement: { source: 'next' } }
+            : { type: 'add', from: box.id, placement: { source: 'next' } }, insert ? `Insert between ${box.title} and ${target.title}`
             : shape === 'gateway' ? `Add a path from ${box.title}` : `Add after ${box.title}`, anchor);
     }
     openAnchoredChooser(edit, title, anchor, returnFocus) {
@@ -2325,7 +2792,7 @@ export class ProcessModeler extends BaseElement {
         tooltip.style.top = `${point.y + 16}px`;
     }
     update() {
-        const selectionBefore = JSON.stringify({ ids: [...this.selectedIds], path: this.selectedPath });
+        const selectionBefore = JSON.stringify({ items: this.selection, path: this.selectedPath });
         if (this.documentValue !== undefined) {
             this.projection = this.model.project(this.documentValue);
             validateProjection(this.projection);
@@ -2340,10 +2807,12 @@ export class ProcessModeler extends BaseElement {
         if (this.selectedLineId && !this.selectedLine)
             this.selectedLineId = null;
         this.selectedIds = new Set([...this.selectedIds].filter(id => this.projection.boxes.some(box => box.id === id)));
+        this.selectedLineIds = new Set([...this.selectedLineIds].filter(id => this.projection.lines.some(line => line.id === id)));
+        this.selectedNoteIds = new Set([...this.selectedNoteIds].filter(id => this.layoutValue.notes?.some(note => note.id === id)));
         if (!this.selectedId)
             this.selectedId = this.selectedIds.values().next().value ?? null;
         const serialized = JSON.stringify({
-            boxes: this.projection.boxes.map(box => ({ id: box.id, kind: box.kind, title: box.title, description: box.description, path: box.path, fingerprint: box.fingerprint, frame: box.frame, loopMark: box.loopMark, parentId: box.parentId })),
+            boxes: this.projection.boxes.map(box => ({ id: box.id, kind: box.kind, title: box.title, description: box.description, path: box.path, fingerprint: box.fingerprint, frame: box.frame, loopMark: box.loopMark, parentId: box.parentId, localVariables: box.localVariables, localVariablesEditable: box.localVariablesEditable, savedResult: box.savedResult })),
             lines: this.projection.lines,
         });
         if (this.documentValue !== undefined && (serialized !== this.lastProjection || this.documentValue !== this.lastDocument)) {
@@ -2351,7 +2820,7 @@ export class ProcessModeler extends BaseElement {
                 this.versionValue = typeof this.versionValue === "number" ? this.versionValue + 1 : `${this.versionValue}+1`;
             this.lastProjection = serialized;
             this.lastDocument = this.documentValue;
-            emit(this, "projection-changed", { projection: snapshotProcessProjection(this.projection), version: this.versionValue, checks: this.allChecks });
+            this.notify("projection-changed", { projection: snapshotProcessProjection(this.projection), version: this.versionValue, checks: this.allChecks });
         }
         // Riptide or another host owns conversion. It supplies validate() and
         // receives this event only when that conversion can read the drawing.
@@ -2361,7 +2830,7 @@ export class ProcessModeler extends BaseElement {
         if (this.documentValue !== undefined && !this.allChecks.length && readableKey !== this.lastReadableProjection) {
             this.lastReadableProjection = readableKey;
             this.readableValue = snapshotProcessProjection(this.projection);
-            emit(this, "readable-projection-changed", { projection: snapshotProcessProjection(this.readableValue), version: this.versionValue });
+            this.notify("readable-projection-changed", { projection: snapshotProcessProjection(this.readableValue), version: this.versionValue });
         }
         if (this.documentValue === undefined) {
             this.lastProjection = "";
@@ -2369,16 +2838,16 @@ export class ProcessModeler extends BaseElement {
             this.readableValue = null;
             this.lastDocument = undefined;
         }
-        const focused = this.shadowRoot.activeElement
-            ?.dataset.boxId;
+        const active = this.shadowRoot.activeElement;
+        const focused = active?.dataset.boxId, focusedNote = active?.dataset.noteId;
         this.renderWorld();
         this.renderPalette();
         this.renderChecks();
         this.renderSelection();
         this.paintViewport();
         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 (selectionBefore !== JSON.stringify({ items: this.selection, path: this.selectedPath }))
+            this.notify("selection-changed", { box: this.selected, boxes: this.selectedBoxes, path: this.selectedPath, ...(this.graphSelection ? { selection: this.selection } : {}) });
         if (focused) {
             this.restoringBoxFocus = true;
             try {
@@ -2388,6 +2857,10 @@ export class ProcessModeler extends BaseElement {
                 this.restoringBoxFocus = false;
             }
         }
+        else if (focusedNote) {
+            const note = Array.from(this.shadowRoot.querySelectorAll('[data-note-id]')).find(note => note.dataset.noteId === focusedNote);
+            (note ?? this.shadowRoot.querySelector('[part=canvas]'))?.focus({ preventScroll: true });
+        }
     }
     get allChecks() { return this.computedChecks; }
     collectChecks() {
@@ -2434,7 +2907,7 @@ export class ProcessModeler extends BaseElement {
             const problem = this.allChecks.find(check => check.boxId === box.id || (check.path && JSON.stringify(check.path) === JSON.stringify(box.path)));
             const incoming = this.projection.lines.filter(line => line.to === box.id).length;
             const outgoing = this.projection.lines.filter(line => line.from === box.id).length;
-            element.setAttribute("aria-label", [`${kind?.label ?? box.kind}: ${box.title}. ${incoming} in, ${outgoing} out`, problem ? `Needs attention: ${problem.message}` : ""]
+            element.setAttribute("aria-label", [`${kind?.label ?? box.kind}: ${box.title}. ${incoming} in, ${outgoing} out`, problem ? `Needs attention: ${problem.title || problem.message}` : ""]
                 .filter(Boolean)
                 .join(". "));
             element.setAttribute("aria-current", String(this.selectedIds.has(box.id)));
@@ -2551,7 +3024,7 @@ export class ProcessModeler extends BaseElement {
             if (problem) {
                 const message = document.createElement("span");
                 message.setAttribute("part", "problem");
-                message.append(checkGlyph(), document.createTextNode(problem.title ?? problem.message));
+                message.append(checkGlyph(), document.createTextNode(problem.title || problem.message));
                 element.append(message);
             }
             element.addEventListener("keydown", event => {
@@ -2660,8 +3133,8 @@ export class ProcessModeler extends BaseElement {
             const path = svgElement("path");
             path.setAttribute("part", "line");
             path.dataset.lineId = line.id;
-            path.dataset.selected = String(this.selectedLineId === line.id);
-            path.setAttribute('marker-end', `url(#${this.selectedLineId === line.id ? 'boe-process-arrow-brand' : 'boe-process-arrow'})`);
+            path.dataset.selected = String(this.selectedLineIds.has(line.id));
+            path.setAttribute('marker-end', `url(#${this.selectedLineIds.has(line.id) ? 'boe-process-arrow-brand' : 'boe-process-arrow'})`);
             path.setAttribute("vector-effect", "non-scaling-stroke");
             path.setAttribute("d", roundedProcessPath(points));
             if (line.dashed)
@@ -2760,6 +3233,7 @@ export class ProcessModeler extends BaseElement {
                         lineId: line.id,
                         from: line.from,
                         to: line.to,
+                        ...(type === 'insert' ? { placement: { source: 'line', center: lineMidpoint(points) } } : {}),
                     };
                     if (type === "insert" && this.catalog.length) {
                         this.openLineChooser(line, button);
@@ -2789,6 +3263,18 @@ export class ProcessModeler extends BaseElement {
             const element = document.createElement("div");
             element.setAttribute("part", "note");
             element.textContent = note.text;
+            element.dataset.noteId = note.id;
+            element.addEventListener('pointerdown', event => event.stopPropagation());
+            element.tabIndex = 0;
+            element.setAttribute('role', 'button');
+            element.setAttribute('aria-label', note.text || 'Diagram note');
+            element.addEventListener('click', event => { const items = event.shiftKey ? this.selection.filter(item => !(item.type === 'note' && item.id === note.id)) : []; if (!event.shiftKey || !this.selectedNoteIds.has(note.id))
+                items.push({ type: 'note', id: note.id }); this.selectItems(items); });
+            element.addEventListener('keydown', event => { if (event.key === 'Enter' || event.key === ' ') {
+                event.preventDefault();
+                event.stopPropagation();
+                this.selectItems([{ type: 'note', id: note.id }]);
+            } });
             this.place(element, { ...note, width: 208, height: 80 });
             world.append(element);
         }
@@ -2814,9 +3300,13 @@ export class ProcessModeler extends BaseElement {
         }
         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 } : {}) });
+        if (from && selected)
+            this.requestEdit({ ...this.nextEdit(selected), kind });
+        else {
+            const canvas = this.shadowRoot.querySelector('[part=canvas]');
+            const center = { x: (canvas.clientWidth / 2 - this.viewport.x) / this.viewport.zoom, y: (canvas.clientHeight / 2 - this.viewport.y) / this.viewport.zoom };
+            this.requestEdit({ type: 'add', kind, placement: { source: 'point', center } });
+        }
     }
     paletteLineAt(point) {
         let nearest;
@@ -2938,7 +3428,7 @@ export class ProcessModeler extends BaseElement {
         }
         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 });
+        this.requestEdit({ type: line ? 'insert' : 'add', kind: drag.kind, lineId: line?.id, from: line?.from, to: line?.to, parentId: frame?.id, position: point, placement: { source: 'point', center: { ...point } } });
     }
     renderPalette() {
         const choices = this.shadowRoot.querySelector("[part=choices]");
@@ -3037,7 +3527,7 @@ export class ProcessModeler extends BaseElement {
                 type: line ? "insert" : "add",
                 kind,
                 lineId: line?.id, from: line?.from, to: line?.to, parentId: frame?.id,
-                position,
+                position, placement: { source: 'point', center: { ...position } },
             });
             this.markDropLine(undefined);
         };
@@ -3081,14 +3571,17 @@ export class ProcessModeler extends BaseElement {
             checks.append(button);
         });
     }
-    renderField(box, field) {
+    renderField(box, field, helpOpen = false) {
         const row = document.createElement('div');
         row.setAttribute('part', 'field');
         const label = document.createElement('label');
         label.textContent = field.label;
         let control;
-        if (field.kind === 'multiline')
+        if (field.kind === 'multiline' || (field.kind === 'expression' && (field.expression?.rows ?? 1) > 1)) {
             control = document.createElement('textarea');
+            if (field.expression?.rows)
+                control.rows = Math.max(2, Math.floor(field.expression.rows));
+        }
         else if (field.kind === 'choice') {
             const select = document.createElement('select');
             const groups = new Map();
@@ -3117,14 +3610,20 @@ export class ProcessModeler extends BaseElement {
             control = input;
         }
         control.dataset.field = field.key;
+        control.dataset.fieldBox = box.id;
         if (control instanceof HTMLInputElement && control.type === 'checkbox')
             control.checked = Boolean(field.value);
         else
             control.value = field.kind === 'action' ? field.options?.find(option => option.value === field.value)?.label ?? String(field.value) : String(field.value);
         control.disabled = Boolean(field.disabled || this.locked);
         control.required = Boolean(field.required);
-        if (field.placeholder && control instanceof HTMLInputElement)
+        if (field.placeholder && (control instanceof HTMLInputElement || control instanceof HTMLTextAreaElement))
             control.placeholder = field.placeholder;
+        if (field.kind === 'expression') {
+            control.spellcheck = false;
+            control.setAttribute('autocomplete', 'off');
+            control.setAttribute('part', 'expression-control');
+        }
         if (field.problem)
             control.setAttribute('aria-invalid', 'true');
         const submit = () => emit(this, 'process-field-change-request', { boxId: box.id, path: box.path, key: field.key, value: control instanceof HTMLInputElement && control.type === 'checkbox' ? control.checked : control instanceof HTMLInputElement && control.type === 'number' && control.value !== '' ? Number(control.value) : control.value });
@@ -3261,55 +3760,152 @@ export class ProcessModeler extends BaseElement {
             control.setAttribute('list', options.id);
             row.append(options);
         }
-        if (field.kind === 'expression' && this.variables.length) {
+        const scope = field.expression?.variables ?? this.variables;
+        if (field.kind === 'expression' && scope.length) {
             const chips = document.createElement('div');
             chips.setAttribute('part', 'variable-chips');
-            chips.setAttribute('aria-label', 'Variables in scope');
-            for (const variable of this.variables) {
+            chips.setAttribute('role', 'group');
+            chips.setAttribute('aria-label', 'Insert a variable');
+            for (const variable of scope) {
                 const chip = document.createElement('button');
                 chip.type = 'button';
                 chip.textContent = variable.name;
                 chip.disabled = control.disabled;
-                chip.onclick = () => { control.value += variable.name; submit(); control.focus(); };
+                if (variable.description)
+                    chip.title = variable.description;
+                chip.addEventListener('pointerdown', event => event.preventDefault());
+                chip.onclick = () => {
+                    if (control.disabled || !control.isConnected || this.selected?.id !== box.id)
+                        return;
+                    const input = control;
+                    const session = this.layoutEditSession;
+                    const start = input.selectionStart ?? input.value.length, end = input.selectionEnd ?? start;
+                    input.focus();
+                    if (session !== this.layoutEditSession || !input.isConnected || input.disabled || this.locked || this.selected?.id !== box.id || this.shadowRoot?.activeElement !== input || input.closest('[inert]'))
+                        return;
+                    input.value = input.value.slice(0, start) + variable.name + input.value.slice(end);
+                    input.setSelectionRange(start + variable.name.length, start + variable.name.length);
+                    submit();
+                };
                 chips.append(chip);
             }
             row.append(chips);
         }
+        const messageId = `process-field-${encodeURIComponent(box.id)}-${encodeURIComponent(field.key)}`;
+        const describedBy = [];
         if (field.description) {
             const help = document.createElement('small');
+            help.id = `${messageId}-description`;
             help.textContent = field.description;
             row.append(help);
+            describedBy.push(help.id);
         }
-        if (field.problem) {
-            const problem = document.createElement('small');
-            problem.setAttribute('part', 'field-problem');
-            problem.textContent = field.problem;
-            row.append(problem);
+        const feedback = field.problem || (field.kind === 'expression' ? field.expression?.feedback?.message : undefined);
+        if (feedback) {
+            const message = document.createElement('small');
+            message.id = `${messageId}-feedback`;
+            message.textContent = feedback;
+            message.setAttribute('part', field.problem ? 'field-problem' : 'field-feedback');
+            if (field.kind === 'expression')
+                message.setAttribute('aria-live', 'polite');
+            if (!field.problem && field.expression?.feedback?.tone)
+                message.dataset.tone = field.expression.feedback.tone;
+            const chips = row.querySelector('[part=variable-chips]');
+            row.insertBefore(message, chips);
+            describedBy.push(message.id);
+        }
+        if (describedBy.length)
+            control.setAttribute('aria-describedby', describedBy.join(' '));
+        if (field.kind === 'expression' && field.expression?.help) {
+            const details = document.createElement('details');
+            details.setAttribute('part', 'expression-help');
+            details.dataset.helpField = field.key;
+            details.dataset.session = String(this.layoutEditSession);
+            details.open = helpOpen;
+            const summary = document.createElement('summary');
+            summary.textContent = field.expression.help.summary;
+            details.append(summary);
+            const list = document.createElement('ul');
+            details.append(list);
+            for (const example of field.expression.help.examples) {
+                const paragraph = document.createElement('li'), code = document.createElement('code');
+                code.textContent = example.expression;
+                paragraph.append(code, document.createTextNode(' '));
+                if (example.segments)
+                    for (const segment of example.segments) {
+                        const run = document.createElement(segment.format === 'code' ? 'code' : 'span');
+                        run.textContent = segment.text;
+                        paragraph.append(run);
+                    }
+                else
+                    paragraph.append(document.createTextNode(example.description));
+                list.append(paragraph);
+            }
+            row.append(details);
         }
         return row;
     }
     renderSelection() {
+        this.shadowRoot?.querySelectorAll('[part=note]').forEach(note => { note.dataset.selected = String(this.selectedNoteIds.has(note.dataset.noteId)); note.setAttribute('aria-pressed', note.dataset.selected); });
         if (!this.isRendered)
             return;
         const focusedControl = this.shadowRoot.activeElement;
-        const focusedKey = focusedControl?.dataset.field ?? focusedControl?.dataset.variable;
+        const focusedKey = focusedControl?.dataset.field ?? focusedControl?.dataset.variable ?? focusedControl?.dataset.localVariable;
         const variableKey = focusedControl?.dataset.variableKey;
-        const focusedType = focusedControl?.dataset.field !== undefined ? 'field' : focusedControl?.dataset.variable !== undefined ? 'variable' : null;
+        const fieldBox = focusedControl?.dataset.fieldBox;
+        const localKey = focusedControl?.dataset.localKey, localName = focusedControl?.dataset.localName;
+        const focusedType = focusedControl?.dataset.field !== undefined ? 'field' : focusedControl?.dataset.variable !== undefined ? 'variable' : focusedControl?.dataset.localVariable !== undefined ? 'localVariable' : null;
         const caret = focusedControl && 'selectionStart' in focusedControl ? focusedControl.selectionStart : null;
+        const selectionEnd = focusedControl && 'selectionEnd' in focusedControl ? focusedControl.selectionEnd : null;
+        const direction = focusedControl && 'selectionDirection' in focusedControl ? focusedControl.selectionDirection : null;
+        const scrollTop = focusedControl?.scrollTop, scrollLeft = focusedControl?.scrollLeft;
         const restoreControlFocus = () => {
             if (focusedKey === undefined || !focusedType)
                 return;
+            if (focusedType === 'field' && (this.selected?.id !== fieldBox || this.locked))
+                return;
             const controls = Array.from(this.shadowRoot.querySelectorAll('input,textarea,select,button'));
-            const control = controls.find(item => item.dataset[focusedType] === focusedKey && (focusedType !== 'variable' || item.dataset.variableKey === variableKey))
+            const control = controls.find(item => item.dataset[focusedType] === focusedKey && (focusedType !== 'field' || item.dataset.fieldBox === fieldBox) && (focusedType !== 'variable' || item.dataset.variableKey === variableKey) && focusedType !== 'localVariable')
                 ?? (focusedType === 'variable' ? controls.find(item => this.pendingVariableRename?.name === focusedKey && item.dataset.variable === this.pendingVariableRename.value && item.dataset.variableKey === variableKey) ?? controls.find(item => item.dataset.variableKey === 'add') : undefined);
-            if (!control)
+            if (focusedType === 'localVariable') {
+                if (focusedControl?.dataset.localAmbiguous === 'true') {
+                    focusedControl.blur();
+                    return;
+                }
+                const names = [localName];
+                if (this.pendingLocalRename?.boxId === focusedKey && this.pendingLocalRename.name === localName && !this.pendingLocalRename.ambiguous)
+                    names.push(this.pendingLocalRename.value);
+                let localControl = undefined;
+                for (const name of names) {
+                    const matches = controls.filter(item => item.dataset.localVariable === focusedKey && item.dataset.localKey === localKey && item.dataset.localName === name);
+                    if (matches.length === 1) {
+                        localControl = matches[0];
+                        break;
+                    }
+                    if (matches.length > 1)
+                        break;
+                }
+                if (!localControl) {
+                    focusedControl?.blur();
+                    return;
+                }
+                localControl.focus();
+                if (caret !== null && localControl instanceof HTMLInputElement)
+                    localControl.setSelectionRange(caret, caret);
+                return;
+            }
+            if (!control || control.disabled || control.closest('[inert]'))
                 return;
-            control.focus();
+            control.focus({ preventScroll: true });
             if (caret !== null && (control instanceof HTMLInputElement || control instanceof HTMLTextAreaElement) && control.type !== 'number' && control.type !== 'checkbox')
-                control.setSelectionRange(caret, caret);
+                control.setSelectionRange(caret, selectionEnd ?? caret, direction ?? undefined);
+            if (scrollTop !== undefined)
+                control.scrollTop = scrollTop;
+            if (scrollLeft !== undefined)
+                control.scrollLeft = scrollLeft;
         };
         this.shadowRoot.querySelectorAll('[part=minimap] [data-map-box]').forEach(rect => rect.dataset.selected = String(this.selectedIds.has(rect.dataset.mapBox)));
-        this.shadowRoot.querySelectorAll('[part=line]').forEach(line => { const selected = line.dataset.lineId === this.selectedLineId; line.dataset.selected = String(selected); line.setAttribute('marker-end', `url(#${selected ? 'boe-process-arrow-brand' : 'boe-process-arrow'})`); });
+        this.shadowRoot.querySelectorAll('[part=line]').forEach(line => { const selected = this.selectedLineIds.has(line.dataset.lineId); line.dataset.selected = String(selected); line.setAttribute('marker-end', `url(#${selected ? 'boe-process-arrow-brand' : 'boe-process-arrow'})`); });
         this.shadowRoot.querySelectorAll("[data-box-id]").forEach((element) => {
             element.setAttribute("aria-current", String(this.selectedIds.has(element.dataset.boxId)));
             const box = this.projection.boxes.find((box) => box.id === element.dataset.boxId);
@@ -3319,9 +3915,10 @@ export class ProcessModeler extends BaseElement {
         });
         const editor = this.shadowRoot.querySelector("[part=editor]");
         const selected = this.selected;
-        const controlsKey = `${[...this.selectedIds].join(',')}|${this.locked}|${this.disableConnections}|${this.showLastRunValue}|${selected?.runMetrics}|${JSON.stringify(selected ? this.fieldsValue[selected.id] ?? [] : [])}`;
+        const fallbackScope = selected && (this.fieldsValue[selected.id] ?? []).some(field => field.kind === 'expression' && field.expression?.variables === undefined) ? this.variables.map(({ name, description }) => ({ name, description })) : undefined;
+        const controlsKey = `${JSON.stringify(fallbackScope)}|${[...this.selectedIds].join(',')}|${this.locked}|${this.disableConnections}|${this.showLastRunValue}|${selected?.runMetrics}|${JSON.stringify([selected?.localVariables, selected?.localVariablesEditable, selected?.frame])}|${JSON.stringify(selected ? this.fieldsValue[selected.id] ?? [] : [])}`;
         this.shadowRoot.querySelector("[part=palette]").hidden = false;
-        this.shadowRoot.querySelector('[part=selection-toolbar]').hidden = this.selectedIds.size === 0 && !this.selectedLineId;
+        this.shadowRoot.querySelector('[part=selection-toolbar]').hidden = this.selection.length === 0;
         this.renderSelectionToolbar();
         this.renderPane();
         this.positionSelectionToolbar();
@@ -3330,9 +3927,22 @@ export class ProcessModeler extends BaseElement {
             this.inspectedControls === controlsKey &&
             editor.querySelector(`[part=inspector-heading]`)?.tagName === `H${this.headingLevel}`) {
             editor.querySelector("[part=inspector-heading]").textContent = selected?.title ?? "";
+            const locals = editor.querySelector('[part=local-variables]');
+            if (selected && locals && locals.dataset.localEchoRevision !== String(this.localEchoRevision)) {
+                // Reconcile controlled local drafts without disposing the host's custom
+                // inspector or unrelated focused controls on unchanged document echoes.
+                locals.replaceWith(this.renderLocalVariables(selected));
+            }
             restoreControlFocus();
             return;
         }
+        const expressionHelp = new Map();
+        if (this.inspectedId === selected?.id && this.selectedIds.size === 1) {
+            for (const help of Array.from(editor.querySelectorAll('[part=expression-help]'))) {
+                if (help.dataset.session === String(this.layoutEditSession))
+                    expressionHelp.set(help.dataset.helpField, help.open);
+            }
+        }
         this.cleanupInspector?.();
         this.cleanupInspector = undefined;
         editor.replaceChildren();
@@ -3382,7 +3992,9 @@ export class ProcessModeler extends BaseElement {
                 editor.append(purpose);
             }
             for (const field of this.fieldsValue[selected.id] ?? [])
-                editor.append(this.renderField(selected, field));
+                editor.append(this.renderField(selected, field, expressionHelp.get(field.key)));
+            if (selected.localVariables !== undefined)
+                editor.append(this.renderLocalVariables(selected));
             this.cleanupInspector =
                 this.renderer?.(selected.node, editor) || undefined;
             const outgoing = this.projection.lines.filter(line => line.from === selected.id);
@@ -3469,14 +4081,118 @@ export class ProcessModeler extends BaseElement {
         }
         restoreControlFocus();
     }
+    renderLocalVariables(box) {
+        const section = document.createElement('section');
+        section.setAttribute('part', 'local-variables');
+        section.dataset.localEchoRevision = String(this.localEchoRevision);
+        const heading = document.createElement('h3');
+        heading.textContent = box.frame ? 'Variables for the steps inside' : 'Variables for this step';
+        const help = document.createElement('p');
+        help.textContent = box.frame ? 'Every step inside can read these; they’re gone once the frame is done.' : 'Only this step’s inputs can read these; they’re gone once it’s done.';
+        const collection = document.createElement('div');
+        collection.setAttribute('part', 'local-variable-list');
+        section.append(heading, help, collection);
+        for (const [index, variable] of (box.localVariables ?? []).entries()) {
+            const row = document.createElement('div');
+            row.setAttribute('part', 'local-variable-row');
+            row.setAttribute('role', 'group');
+            row.setAttribute('aria-label', `Step variable ${index + 1}`);
+            const identify = (control, key) => { control.dataset.localVariable = box.id; control.dataset.localIndex = String(index); control.dataset.localKey = key; control.dataset.localName = variable.name; control.dataset.localAmbiguous = String(box.localVariables?.filter(item => item.name === variable.name).length !== 1); };
+            for (const [key, label, value] of [['rename', 'Name', variable.name], ['starting-value', 'Starts as', variable.startingValue ?? '']]) {
+                const field = variableLabel(label);
+                const input = document.createElement('input');
+                input.type = 'text';
+                input.placeholder = key === 'rename' ? 'name' : 'starts as';
+                input.spellcheck = false;
+                input.autocomplete = 'off';
+                input.value = value;
+                input.disabled = this.locked || !box.localVariablesEditable;
+                identify(input, key);
+                if (variable.problem) {
+                    input.setAttribute('aria-invalid', 'true');
+                    input.setAttribute('aria-describedby', `process-local-problem-${encodeURIComponent(box.id)}-${index}`);
+                }
+                input.oninput = () => {
+                    if (key === 'rename')
+                        this.pendingLocalRename = { boxId: box.id, name: variable.name, value: input.value, echoRevision: this.localEchoRevision, ambiguous: input.dataset.localAmbiguous === 'true' };
+                    this.requestLocalVariableEdit(box, { type: key, index, name: variable.name, value: input.value });
+                };
+                field.append(input);
+                row.append(field);
+            }
+            if (box.localVariablesEditable) {
+                const remove = document.createElement('button');
+                remove.type = 'button';
+                remove.append(variableGlyph());
+                remove.setAttribute('aria-label', `Remove ${variable.name || 'this variable'}`);
+                remove.disabled = this.locked;
+                identify(remove, 'remove');
+                remove.onclick = () => this.requestLocalVariableEdit(box, { type: 'remove', index, name: variable.name });
+                row.append(remove);
+            }
+            if (variable.problem) {
+                const problem = document.createElement('small');
+                problem.setAttribute('part', 'field-problem');
+                problem.id = `process-local-problem-${encodeURIComponent(box.id)}-${index}`;
+                problem.textContent = variable.problem;
+                row.append(problem);
+            }
+            collection.append(row);
+        }
+        if (box.localVariablesEditable) {
+            const add = document.createElement('button');
+            add.type = 'button';
+            add.append(variableGlyph(true), document.createTextNode('Add a variable'));
+            add.disabled = this.locked;
+            add.dataset.localVariable = box.id;
+            add.dataset.localKey = 'add';
+            add.onclick = () => this.requestLocalVariableEdit(box, { type: 'add' });
+            const actions = document.createElement('div');
+            actions.setAttribute('part', 'local-variable-actions');
+            actions.append(add);
+            section.append(actions);
+        }
+        return section;
+    }
+    requestLocalVariableEdit(box, edit) {
+        const owner = this.selected;
+        if (this.locked || !owner?.localVariablesEditable || owner.id !== box.id)
+            return;
+        if (edit.type !== 'add' && owner.localVariables?.[edit.index]?.name !== edit.name)
+            return;
+        const request = { boxId: owner.id, ...(owner.path ? { path: [...owner.path] } : {}), edit };
+        const session = this.layoutEditSession, beforeNames = (owner.localVariables ?? []).map(variable => variable.name), beforeCount = beforeNames.length;
+        emit(this, 'process-local-variable-edit-request', request);
+        if (session !== this.layoutEditSession || this.selected?.id !== box.id)
+            return;
+        const count = this.selected.localVariables?.length ?? 0;
+        if (edit.type === 'add' && count > beforeCount) {
+            const remaining = [...beforeNames];
+            const added = (this.selected.localVariables ?? []).filter(variable => {
+                const index = remaining.indexOf(variable.name);
+                if (index < 0)
+                    return true;
+                remaining.splice(index, 1);
+                return false;
+            });
+            if (added.length === 1 && this.selected.localVariables?.filter(variable => variable.name === added[0].name).length === 1) {
+                const name = Array.from(this.shadowRoot.querySelectorAll('[data-local-key=rename]')).find(input => input.dataset.localVariable === box.id && input.dataset.localName === added[0].name);
+                name?.focus();
+                name?.select();
+            }
+        }
+        else if (edit.type === 'remove' && count < beforeCount) {
+            Array.from(this.shadowRoot.querySelectorAll('[data-local-key=add]')).find(button => button.dataset.localVariable === box.id)?.focus();
+        }
+    }
     renderSelectionToolbar() {
         const toolbar = this.shadowRoot.querySelector('[part=selection-toolbar]');
-        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(',')}`;
+        const key = `${JSON.stringify(this.selection)}|${this.graphSelection}|${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;
         toolbar.replaceChildren();
-        if (!this.selectedIds.size && !this.selectedLineId)
+        if (!this.selection.length)
             return;
         const add = (label, command, action, withPlus = false) => {
             const button = document.createElement('button');
@@ -3497,7 +4213,12 @@ export class ProcessModeler extends BaseElement {
             button.append(text);
             toolbar.append(button);
         };
-        if (this.selectedLine) {
+        if (this.graphSelection && (this.selectedNoteIds.size || this.selectedLineIds.size > 1 || this.selectedLineIds.size && this.selectedIds.size)) {
+            if (this.selectedIds.size > 1)
+                add('Line up', 'align', () => this.selectionCommand('align'));
+            add('Delete', 'delete-many', () => this.selectionCommand('delete-many'));
+        }
+        else 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] || line.fromSide || line.toSide || line.points?.length)
@@ -3513,7 +4234,7 @@ export class ProcessModeler extends BaseElement {
             if (!['end', 'finish', 'section', 'note'].includes(box.kind))
                 add(box.shape === 'gateway' ? 'Add a path' : 'Add next', 'add-next', () => this.openAnchoredChooser(this.nextEdit(box), this.nextChooserTitle(box), toolbar.querySelector('[data-selection-command=add-next]') ?? undefined), true);
             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);
+                add('If it fails', 'add-failure', () => this.openAnchoredChooser({ type: 'add', from: box.id, routeLabel: 'If it fails', dashed: true, placement: { source: 'next' } }, `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', () => this.duplicateBoxes([box.id], 48));
             if (!['start', 'timer'].includes(box.kind))
@@ -3530,25 +4251,56 @@ export class ProcessModeler extends BaseElement {
         button("undo").disabled = !this.history.canUndo || this.locked;
         button("redo").disabled = !this.history.canRedo || this.locked;
         button("tidy").disabled = this.locked;
+        this.shadowRoot.querySelector('[part=toolbar-title]').textContent = this.processTitleValue;
+        for (const command of ['undo', 'redo', 'tidy'])
+            this.shadowRoot.querySelector(`[data-view-option=${command}]`).disabled = button(command).disabled;
         button("lock").setAttribute("aria-pressed", String(this.locked));
         button("snap").setAttribute("aria-pressed", String(this.snapToGrid));
         this.shadowRoot.querySelectorAll('[data-detail]').forEach(control => {
-            control.setAttribute("aria-pressed", String(control.dataset.detail === this.detailValue));
+            if (!control.closest('[part=view-menu]'))
+                control.setAttribute("aria-pressed", String(control.dataset.detail === this.detailValue));
+            if (control.closest('[part=view-menu]'))
+                control.setAttribute('aria-checked', String(control.dataset.detail === this.detailValue));
+            if (control.closest('[part=view-menu]'))
+                control.textContent = `${control.dataset.detail === this.detailValue ? '✓ ' : ''}${control.dataset.detail === 'business' ? 'Business view' : 'Technical view'}`;
         });
         const runToggle = this.shadowRoot.querySelector('[part=run-toggle]');
         runToggle.hidden = !this.lastRunValue;
         runToggle.querySelector('input').checked = this.showLastRunValue;
         const mobileRun = this.shadowRoot.querySelector('[data-view-option=last-run]');
         mobileRun.hidden = !this.lastRunValue;
-        mobileRun.setAttribute('aria-pressed', String(this.showLastRunValue));
+        mobileRun.removeAttribute('aria-pressed');
+        mobileRun.textContent = this.showLastRunValue ? 'Hide last run' : 'Show last run';
         const checksStatus = button('checks-status');
         const count = this.allChecks.length;
-        checksStatus.textContent = count ? `${count} ${count === 1 ? 'problem' : 'problems'}` : '✓ Ready to run';
+        const glyph = svgElement('svg');
+        glyph.setAttribute('viewBox', '0 0 16 16');
+        glyph.setAttribute('aria-hidden', 'true');
+        const circle = svgElement('circle');
+        circle.setAttribute('cx', '8');
+        circle.setAttribute('cy', '8');
+        circle.setAttribute('r', '7');
+        circle.setAttribute('fill', 'currentColor');
+        const mark = svgElement('path');
+        mark.setAttribute('d', count ? 'm5 5 6 6m0-6-6 6' : 'm4.5 8 2.5 2.5 4.5-5');
+        mark.setAttribute('stroke', 'var(--boe-token-surface-surface, #fff)');
+        mark.setAttribute('stroke-width', '1.5');
+        mark.setAttribute('fill', 'none');
+        mark.setAttribute('stroke-linecap', 'round');
+        mark.setAttribute('stroke-linejoin', 'round');
+        glyph.append(circle, mark);
+        const label = document.createElement('span');
+        label.textContent = count ? `${count} ${count === 1 ? 'thing needs' : 'things need'} attention` : 'Ready to run';
+        checksStatus.replaceChildren(glyph, label);
         checksStatus.dataset.state = count ? 'bad' : 'ready';
+        this.shadowRoot.querySelector('[data-view-option=checks]').textContent = count ? `Checks (${count})` : 'Checks: ready to run';
     }
     paintViewport() {
         const world = this.shadowRoot.querySelector("[part=world]");
         world.style.setProperty('--boe-process-inverse-zoom', String(1 / this.viewport.zoom));
+        // A small screen-space margin keeps targets above 24px after fractional
+        // layout rounding without assuming a browser's CSS-pixel quantum.
+        world.style.setProperty('--boe-process-hit-target', `${24.1 / this.viewport.zoom}px`);
         world.style.transform =
             `translate(${this.viewport.x}px,${this.viewport.y}px) scale(${this.viewport.zoom})`;
         const canvas = this.shadowRoot.querySelector("[part=canvas]");
@@ -3596,17 +4348,27 @@ export class ProcessModeler extends BaseElement {
         minimap.append(viewport);
     }
     positionSelectionToolbar() {
-        if (!this.isRendered || (!this.selectedIds.size && !this.selectedLineId))
+        if (!this.isRendered || !this.selection.length)
             return;
         const canvas = this.shadowRoot.querySelector('[part=canvas]');
         const toolbar = this.shadowRoot.querySelector('[part=selection-toolbar]');
         const positions = [...this.selectedIds].map(id => this.layoutValue.boxes[id]).filter(Boolean);
+        positions.push(...(this.layoutValue.notes ?? []).filter(note => this.selectedNoteIds.has(note.id)).map(note => ({ ...note, width: 208, height: 80 })));
         if (!positions.length && this.selectedLine) {
             const point = lineMidpoint(this.routedLines.get(this.selectedLine.id) ?? []);
             toolbar.style.left = `${Math.max(8, Math.min(point.x * this.viewport.zoom + this.viewport.x, Math.max(8, canvas.clientWidth - toolbar.offsetWidth - 8)))}px`;
             toolbar.style.top = `${Math.max(8, point.y * this.viewport.zoom + this.viewport.y - 52)}px`;
             return;
         }
+        if (!positions.length) {
+            for (const id of this.selectedLineIds) {
+                const points = this.routedLines.get(id) ?? [];
+                if (!points.length)
+                    continue;
+                const x = Math.min(...points.map(point => point.x)), y = Math.min(...points.map(point => point.y));
+                positions.push({ x, y, width: Math.max(...points.map(point => point.x)) - x, height: Math.max(...points.map(point => point.y)) - y });
+            }
+        }
         if (!positions.length)
             return;
         const left = Math.min(...positions.map(position => position.x * this.viewport.zoom + this.viewport.x));